recursal/MDN huggingface dataset:
String.prototype.endsWith()
===========================

O método **`endsWith()`** indica se uma string termina com determinados caracteres, retornando `true` ou `false`.

Sintaxe
-------
```

str.endsWith(stringSendoBuscada[, tamanho])
```

### Parâmetros

`stringSendoBuscada`

Os caracteres a serem pesquisados no final da string.

`tamanho`

Opcional. Se fornecido, substitui o tamanho da string passada. Se omitido, o valor padrão é o tamanho da string.

### Valor retornado

**`true`** se os caracteres passados forem encontrados no final da string. Do contrário, retorna **`false`**.

Descrição
---------

Este método permite que você verifique se uma string termina ou não com determinados caracteres. Este método é case-sensitive.

Exemplos
--------

### Usando `endsWith()`


```js
var str = "Ser ou não ser, eis a questão";

console.log(str.endsWith("questão")); // retorna true
console.log(str.endsWith("ser")); // retorna false
console.log(str.endsWith("ser", 14)); // retorna true
```

Polyfill
--------

Este método foi adicionada na especificação ECMAScript 6 e talvez não esteja disponível em todos as implementações JavaScript ainda. No entanto, você pode criá-lo adicionando o seguinte código:


```js
if (!String.prototype.endsWith)
  String.prototype.endsWith = function (searchStr, Position) {
    // This works much better than >= because
    // it compensates for NaN:
    if (!(Position < this.length)) Position = this.length;
    else Position |= 0; // round position
    return (
      this.substr(Position - searchStr.length, searchStr.length) === searchStr
    );
  };
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.endswith |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.substr()
=========================

O método `substr()` retorna uma parte da string, começando no índice especificado e estendendo-se por um determinado número de caracteres posteriormente.

Experimente
-----------

Sintaxe
-------
```

str.substr(start[, length])
```

### Parâmetros

`start`

Local para começar a extrair os caracteres.

`length`

Opcional. O número de caracteres a serem extraídos.

### Valor de retorno

Uma nova string contendo a seção extraída da string fornecida.

Descrição
---------

O `substr()` extrai caracteres de comprimento de uma `str`, contando a partir do índice inicial.

* Se o `start` for um número positivo, o índice começa a contar no início da string. Seu valor é limitado ao tamanho da string (`str.length`).
* Se o `start` for um número negativo, o índice começa a contar a partir do final da string. Seu valor é limitado ao tamanho da string (`-str.length`).

**Nota:** No Microsoft JScript, valores negativos no argumento `start` não são considerados como referência ao final da string.

* Se `length` for omitido, `substr()` extrairá caracteres até o final da string.
* Se `length` for `undefined`, `substr()` extrai os caracteres até o final da string.
* Se `length` for um número negativo, ele será tratado como `0`.
* Para `start` e `length`, `NaN` é tratado como 0.
Exemplos
--------

### Usando `substr()`


```js
var aString = "Mozilla";

console.log(aString.substr(0, 1)); // 'M'
console.log(aString.substr(1, 0)); // ''
console.log(aString.substr(-1, 1)); // 'a'
console.log(aString.substr(1, -1)); // ''
console.log(aString.substr(-3)); // 'lla'
console.log(aString.substr(1)); // 'ozilla'
console.log(aString.substr(-20, 2)); // 'Mo'
console.log(aString.substr(20, 2)); // ''
```

Polyfill
--------

JScript da Microsoft não suporta valores negativos para o índice de `start`. Se você deseja usar esse recurso, você pode usar o seguinte código de compatibilidade para evitar esse erro:


```js
// only run when the substr() function is broken
if ("ab".substr(-1) != "b") {
  /\*\*
 \* Get the substring of a string
 \* @param {integer} start where to start the substring
 \* @param {integer} length how many characters to return
 \* @return {string}
 \*/
  String.prototype.substr = (function (substr) {
    return function (start, length) {
      // call the original method
      return substr.call(
        this,
        // did we get a negative start, calculate how much it is from the beginning of the string
        // adjust the start parameter for negative value
        start < 0 ? this.length + start : start,
        length,
      );
    };
  })(String.prototype.substr);
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.substr |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.slice()`
* `String.prototype.substring()`
String.prototype.trimEnd()
==========================

O método `trimEnd()` remove espaços do final de uma *string*. `trimRight()` é um apelido para este método.

Experimente
-----------

Sintaxe
-------
```

str.trimEnd();
str.trimRight();
```

### Valor retornado

Uma nova *string* representando a *string* original sem espaços ao seu final (direita).

Descrição
---------

Os métodos `trimEnd()` / `trimRight()` retornam a *string* sem os espaços à direita dela. `trimEnd()` ou `trimRight()` não altera o valor da *string* original.

### *Aliasing*

Para consistência com funções como `String.prototype.padEnd` o nome padrão do método é `trimEnd`. Entretanto, por razões de compatibilidade na *web*, `trimRight` permanece como um apelido para `trimEnd`. Em alguns motores isso significa:


```js
String.prototype.trimRight.name === "trimEnd";
```

Exemplos
--------

### Usando `trimEnd()`

O exemplo a seguir mostra a *string* em caixa baixa `' foo'`:


```js
var str = " foo ";

console.log(str.length); // retorna 8

str = str.trimEnd();
console.log(str.length); // retorna 6
console.log(str); // retorna ' foo'
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trimend |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.trim()`
* `String.prototype.trimStart()`
String.prototype[@@iterator]()
==============================

O método **`[@@iterator]()`** retorna um novo objeto `Iterator` que itera sobre os pontos de código do valor da String, retornando cada ponto de código como um valor String.

Sintaxe
-------
```

str[Symbol.iterator]
```

### Valor de Retorno

Novo objeto `Iterator`.

Exemplos
--------

### Usando `[@@iterator]()`


```js
var str = "A\uD835\uDC68";

var strIter = str[Symbol.iterator]();

console.log(strIter.next().value); // "A"
console.log(strIter.next().value); // "\uD835\uDC68"
```

### Usando `[@@iterator]()` com `for..of`


```js
var str = "A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A";

for (var v of str) {
  console.log(v);
}
// "A"
// "\uD835\uDC68"
// "B"
// "\uD835\uDC69"
// "C"
// "\uD835\uDC6A"
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype-@@iterator |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Iteration protocols
String.prototype.startsWith()
=============================

O método **`startsWith()`** determina se uma string começa com os caracteres especificados, retornando `true` ou `false`.

Experimente
-----------

Sintaxe
-------
```

str.startsWith(searchString[, position])
```

### Parâmetros

*`searchString`*

Os caracteres a serem procurados a partir do início dessa string.

*`position`*

Opcional. A posição nessa string na qual se inicia a busca pela *`searchString`*. O valor padrão é `0`.

### Valor retornado

**`true`** se os caracteres fornecidos forem encontrados no início da string. Se não, **`false`**.

Descrição
---------

Esse método permite determinar se uma string começa ou não com outra string. Esse método é case-sensitive (difere maiúsculas de minúsculas, e vice-versa).

Exemplos
--------

### Usando `startsWith()`


```js
//startswith
let str = "Ser ou não ser, eis a questão.";

console.log(str.startsWith("Ser")); // true
console.log(str.startsWith("não ser")); // false
console.log(str.startsWith("não ser", 7)); // true
```

Polyfill
--------

Este método foi adicionaldo à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o polyfill `String.prototype.startsWith()` adicionando o seguinte código:
```

if (!String.prototype.startsWith) {
    Object.defineProperty(String.prototype, 'startsWith', {
        value: function(search, rawPos) {
            var pos = rawPos > 0 ? rawPos|0 : 0;
            return this.substring(pos, pos + search.length) === search;
        }
    });
}
```


Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas com menor desempenho e compacto está disponível no GitHub por Mathias Bynens.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.startswith |

Navegadores compatíveis
-----------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.endsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.strike()
=========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `strike()` cria um elemento HTML `<strike>` (en-US) que faz com que uma string seja exibida com o texto riscado.

Sintaxe
-------
```

str.strike()
```

### Valor retornado

Uma string contendo um elemento HTML `<strike>` (en-US).

Descrição
---------

O método `strike()` cria uma string dentro uma tag `<strike>`: "`<strike>str</strike>`".

Exemplos
--------

### Usando `strike()`

O exemplo a seguir usa métodos do objeto global String para alterar a formatação da string:


```js
var worldString = "Olá, mundo";

console.log(worldString.blink()); // <blink>Olá, mundo</blink>
console.log(worldString.bold()); // <b>Olá, mundo</b>
console.log(worldString.italics()); // <i>Olá, mundo</i>
console.log(worldString.strike()); // <strike>Olá, mundo</strike>
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.strike |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.italics()`
String.prototype.fontsize()
===========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `fontsize()` cria um elemento HTML <font> (en-US) que faz com que uma string seja exibida no tamanho da fonte especificada.

**Nota:** O elemento `<font>` foi removido do HTML5 e não deve mais ser usado. Em vez disso, web developers devem usar a propriedade CSS correspondente.

Sintaxe
-------
```

str.fontsize(size)
```

### Parâmetros

`size`

Um número inteiro entre 1 e 7.

### Valor retornado

Uma string contendo um elemento HTML <font> (en-US).

Descrição
---------

Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do texto para um dos 7 tamanhos definidos. Ao especificar `size` como uma string como "-2", você ajusta o tamanho da fonte do texto em relação ao tamanho definido na tag <basefont> (en-US).

Exemplos
--------

### Usando `fontsize()`

O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string:


```js
var worldString = "Olá, mundo";

console.log(worldString.small()); // <small>Olá, mundo</small>
console.log(worldString.big()); // <big>Olá, mundo</big>
console.log(worldString.fontsize(7)); // <font size="7">Olá, mundo</fontsize>
```


Com o objeto `element.style` (en-US) você pode obter o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo:


```js
document.getElementById("#oIdDoElemento").style.fontSize = "0.7em";
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontsize |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.big()`
* `String.prototype.small()`
String.prototype.trim()
=======================

O método **`trim()`** remove os espaços em branco (whitespaces) do início e/ou fim de um texto. É considerado espaço em branco (espaço, tabulação, espaço fixo/rígido, etc.) e todo sinal de fim de linha de texto (LF, CR, etc.).Sintaxe
-------
```

str.trim()
```

Descrição
---------

O método `trim()` retorna o texto sem espaços em branco no início e/ou fim da string. O `trim()` não altera o valor da string original.

Experimente
-----------

Exemplos
--------

### Usando `trim()`

Os exemplos a seguir retornam o valor de `'foo'` sem espaços em branco:


```js
//.trim() removendo whitespace de ambos os lados

var str = " foo ";
console.log(str.trim()); // retorna 'foo'

// Outro exemplo de .trim() removendo whitespace de
// apenas um lado.

var str = "foo ";
console.log(str.trim()); // retorna 'foo'
```

Polyfill
--------

Executar o seguinte código antes antes de qualquer código irá criar o método `trim()` se o mesmo não estiver disponível nativamente.


```js
if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
  };
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trim |

Navegadores compatíveis
-----------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.trimLeft()` (en-US) 
Non-standard
* `String.prototype.trimRight()` (en-US) 
Non-standard
String.prototype.sub()
======================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `sub()` cria um elemento HTML `<sub>` (en-US) que faz com que uma string seja exibida como subscrito (texto pequeno).

Sintaxe
-------
```

str.sub()
```

### Valor retornado

Uma string contendo um elemento HTML `<sub>` (en-US).

Descrição
---------

O método `sub()` cria uma string dentro de uma tag `<sub>`: `"<sub>str</sub>"`.

Exemplos
--------

### Usando os métodos `sub()` e `sup()`

Os exemplos seguintes usam o métodos `sub()` e `sup()` para formatar uma string:


```js
var superText = "superscript";
var subText = "subscript";

console.log("This is what a " + superText.sup() + " looks like.");
// This is what a <sup>superscript</sup> looks like

console.log("This is what a " + subText.sub() + " looks like.");
// This is what a <sub>subscript</sub> looks like.
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.sub |

Navegadores compatíveis
-----------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.sup()`
String.prototype.fontcolor()
============================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `fontcolor()` cria um elemento HTML <font> (en-US) que faz com que uma string seja exibida na cor especificada.

**Nota:** O elemento `<font>` foi removido do HTML5 e não deve mais ser usado. Em vez disso, web developers devem usar a propriedade CSS correspondente.

Sintaxe
-------
```

str.fontcolor(color)
```

### Parâmetros

`color`

Deve ser um string que expresse uma cor em formato hexadecimal ou o nome, em Inglês, de uma cor. Os nomes das cores estão listados na referência de cores CSS.

### Valor retornado

Uma string contendo um elemento HTML <font> (en-US).

Descrição
---------

Se você expressar uma cor em formato hexadecimal, deve usar o formato `rrggbb`. Por exemplo, os valores RGB hexadecimais para salmão são vermelho = FA, verde = 80 e azul = 72, portanto, o tripleto RGB para salmão é "FA8072".

Exemplos
--------

### Usando `fontcolor()`

O exemplo a seguir usa o método `fontcolor()` para alterar a cor de uma string, produzindo uma string com a tag HTML `<font>`.


```js
var worldString = "Olá, mundo";

console.log(worldString.fontcolor("red") + " está vermelho nesta linha");
// '<font color="red">Olá, mundo</font> está vermelho nesta linha'

console.log(
  worldString.fontcolor("FF00") + " está vermelho em hexadecimal nesta linha",
);
// '<font color="FF00">Olá, mundo</font> está vermelho em hexadecimal nesta linha'
```


Com o objeto `element.style` (en-US) você pode obter o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo:


```js
document.getElementById("#oIdDoElemento").style.color = "red";
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontcolor |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.fontsize()`
String.prototype.blink()
========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`blink()`** cria um elemento HTML <blink> que faz uma string piscar.

**Aviso:** A criação de textos que piscam é desaprovada por vários padrões de acessibilidade. O próprio elemento `<blink>` não é padrão e está obsoleto!

Sintaxe
-------
```

str.blink()
```

### Valor retornado

Uma string contendo um elemento HTML <blink>.

Descrição
---------

 O método `blink()` cria uma string dentro de uma tag `<blink>`:
 `"<blink>str</blink>"`.

Exemplos
--------

### Usando `blink()`

Os exemplos abaixo usam métodos do objeto String para alterar a formatação de uma string:


```js
var worldString = "Olá, mundo";

console.log(worldString.blink()); // <blink>Olá, mundo</blink>
console.log(worldString.bold()); // <b>Olá, mundo</b>
console.log(worldString.italics()); // <i>Olá, mundo</i>
console.log(worldString.strike()); // <strike>Olá, mundo</strike>
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.blink |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.toString()
===========================

O método **`toString()`** retorna uma string representando o objeto especificado.

Sintaxe
-------
```

str.toString()
```

Descrição
---------

O objeto `String` substitui o método `toString()` do objeto `Object`. Ele não herda `Object.prototype.toString()`. Para objetos `String`, o método `toString()` retorna uma representação de string do objeto e é o mesmo que o método `String.prototype.valueOf()`.

Exemplos
--------

### Usando `toString()`

O exemplo a seguir exibe o valor string de um objeto `String`:


```js
var x = new String("Hello world");

console.log(x.toString()); // retorna 'Hello world'
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tostring |

Navegadores compatíveis
-----------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.toSource()`
* `String.prototype.valueOf()`
String.prototype.small()
========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `small()` cria um elemento HTML `<small>` (en-US) que faz com que uma string seja exibida em uma fonte pequena.

Sintaxe
-------
```

str.small()
```

### Valor retornado

Uma string contendo um elemento HTML `<small>` (en-US).

Descrição
---------

O método `small()` cria uma string dentro de uma tag `<small>`: `"<small>str</small>"`.

Exemplos
--------

### Usando `small()`

O exemplo a seguir usa métodos do objeto global String para alterar o tamanho da string:


```js
var worldString = "Olá, mundo";

console.log(worldString.small()); // <small>Olá, mundo</small>
console.log(worldString.big()); // <big>Olá, mundo</big>
console.log(worldString.fontsize(7)); // <font size="7">Olá, mundo</fontsize>
```


Com o objeto element.style (en-US) você pode pegar o atributo de estilo do elemento e manipulá-lo de forma mais genérica, por exemplo:


```js
document.getElementById("#oIdDoElemento").style.fontSize = "0.7em";
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.small |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `String.prototype.fontsize()`
* `String.prototype.big()`