Date.prototype.getTime() - JavaScript

Date.prototype.getTime()
========================

O método **`getTime()`** retorna o valor numérico correspondente ao horário da data especificada de acordo com o horário universal.

Você pode usar este método para atribuir uma data e horário a outro objeto `Date`. Este método é funcionalmente equivalente ao método `valueOf()`.

Sintaxe
-------
```

dateObj.getTime()
```

### Retorna

Um número representando os milissegundos passados entre 1 de Janeiro de 1970 00:00:00 UTC e a data atual.

Exemplos
--------

### Usando `getTime()` para duplicar datas

Construindo um objeto de data com um horário idêntico.

```js
// Sendo o mês iniciado em zero, birthday será 10 de Janeiro de 1995
var birthday = new Date(1994, 12, 10);
var copy = new Date();
copy.setTime(birthday.getTime());
```

### Medindo tempo de execução

Subtrair duas chamadas subsequentes a `getTime()` em objetos `Date` recém criados resultará no intervalo de tempo entre essas duas chamadas. Isso pode ser usado para calcular o tempo de execução de algumas operações. Veja também `Date.now()` para evitar instanciar objetos `Date` desnecessariamente.

```js
var end, start;

start = new Date();
for (var i = 0; i < 1000; i++) {
  Math.sqrt(i);
}
end = new Date();

console.log("Operation took " + (end.getTime() - start.getTime()) + " msec");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.gettime |

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

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

See also
--------

* `Date.prototype.setTime()`
* `Date.prototype.valueOf()`
* `Date.now()`


Date.parse() - JavaScript

Date.parse()
============

Resumo
------

O método **`Date.parse()`** analisa uma representação de data em *string*, e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC ou NaN se a string não for reconhecida ou, em alguns casos, contiver valores inválidos de data (ex. 2015-02-31).

O uso de `Date.parse` não é recomendado, uma vez que até ES5 a análise de strings era inteiramente dependente de implementação. Ainda existem muitas diferenças de como diferentes plataformas analisam strings de data, então strings de data devem ser manualmente analisadas (uma biblioteca pode ajudar caso seja necessário atender a vários formatos)

Sintaxe
-------

Chamada direta:
```

Date.parse(dateString)
```

Chamada implícita:
```

new Date(dateString)
```

### Parâmetros

`dateString`

Uma *string* de representação de datas no format RFC2822 ou ISO 8601 (outros formatos podem ser utilizados, mas os resultados podem não ser os esperados).

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

O método `parse()` analisa uma *string* de data (como `"Dec 25, 1995"`) e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC. Esta função é útil para definir valores de data baseados em valores de *string*, por exemplo em conjunto com o método `setTime()` e o objeto `Date`.

Dada uma string representando um tempo, `parse()` retorna o valor temporal. É aceito o RFC2822 / IETF sintaxe de data (RFC2822 Section 3.3), ex.: `"Mon, 25 Dec 1995 13:30:00 GMT"`. A função entende as abreviações dos fusos horários continentais dos EUA, mas para uso geral, use um deslocamento de fuso horário, por exemplo, `"Seg, 25 Dez 1995 13:30:00 +0430"` (4 horas, 30 minutos à leste do Meridiano de Greenwich). Se o fuso horário não é especificado e a string está em um formato ISO reconhecido pela ES5, então é adotado o formato UTC (Tempo Universal Coordenado). GMT e UTC são considerados equivalentes. O fuso horário do seu horário local é usado para interpreatar argumentos na RFC2822 Formato 3.3 (ou qualquer formato não reconhecido como ISO 8601 na ES5) que não contenha informação de fuso horário.

### Suporte ao formato ECMAScript 5 ISO-8601

*Astring* Data e hora pode ser no formato ISO 8601. Por exemplo, `"2011-10-10"` (apenas data) ou `"2011-10-10T14:48:00"` (data e hora) podem ser passados ou convertidos. O fuso horario UTC é usado para interpretar argumentos no formato ISO 8601 que não contenham informação de fuso horário (note que ECMAScript ed 6 draft especifica que a *string* do tipo data e hora sem um fuso horário são tratados como data local, não UTC).

While time zone specifiers are used during date string parsing to interpret the argument, the value returned is always the number of milliseconds between January 1, 1970 00:00:00 UTC and the point in time represented by the argument.

Because `parse()` is a static method of `Date`, it is called as `Date.parse()` rather than as a method of a `Date` instance.

### Differences in assumed time zone

Given a date string of `"March 7, 2014"`, `parse()` assumes a local time zone, but given an ISO format such as `"2014-03-07"` it will assume a time zone of UTC. Therefore `Date` objects produced using those strings will represent different moments in time unless the system is set with a local time zone of UTC. This means that two date strings that appear equivalent may result in two different values depending on the format of the string that is being converted (this behavior is changed in ECMAScript ed 6 so that both will be treated as local).

### Fall-back to implementation-specific date formats

The ECMAScript specification states: If the String does not conform to the standard format the function may fall back to any implementation–specific heuristics or implementation–specific parsing algorithm. Unrecognizable strings or dates containing illegal element values in ISO formatted strings shall cause `Date.parse()` to return `NaN`.

However, invalid values in date strings not recognized as ISO format as defined by ES5 may or may not result in `NaN`, depending on the browser and values provided, e.g.:

```js
// Non-ISO string with invalid date values
new Date("23/25/2014");
```

will be treated as a local date of 25 November, 2015 in Firefox 30 and an invalid date in Safari 7. However, if the string is recognized as an ISO format string and it contains invalid values, it will return `NaN` in all browsers compliant with ES5:

```js
// ISO string with invalid values
new Date("2014-25-23").toISOString();
// returns "RangeError: invalid date" in all es5 compliant browsers
```

SpiderMonkey's implementation-specific heuristic can be found in `jsdate.cpp`. The string `"10 06 2014"` is an example of a non–conforming ISO format and thus falls back to a custom routine. See also this rough outline on how the parsing works.

```js
new Date("10 06 2014");
```

will be treated as a local date of 6 October, 2014 and not 10 June, 2014. Other examples:

```js
new Date("foo-bar 2014").toString();
// returns: "Invalid Date"

Date.parse("foo-bar 2014");
// returns: NaN
```

Examples
--------

### Example: Using `Date.parse()`

If `IPOdate` is an existing `Date` object, it can be set to August 9, 1995 (local time) as follows:

```js
IPOdate.setTime(Date.parse("Aug 9, 1995"));
```

Some other examples of parsing non–standard date strings:

```js
Date.parse("Aug 9, 1995");
```

Returns `807937200000` in time zone GMT-0300, and other values in other time zones, since the string does not specify a time zone and is not ISO format, therefore the time zone defaults to local.

```js
Date.parse("Wed, 09 Aug 1995 00:00:00 GMT");
```

Returns `807926400000` no matter the local time zone as GMT (UTC) is provided.

```js
Date.parse("Wed, 09 Aug 1995 00:00:00");
```

Returns `807937200000` in time zone GMT-0300, and other values in other time zones, since there is no time zone specifier in the argument and it is not ISO format, so is treated as local.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00 GMT");
```

Returns `0` no matter the local time zone as a time zone GMT (UTC) is provided.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00");
```

Returns `14400000` in time zone GMT-0400, and other values in other time zones, since no time zone is provided and the string is not in ISO format, therfore the local time zone is used.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00 GMT-0400");
```

Returns `14400000` no matter the local time zone as a time zone GMT (UTC) is provided.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.parse |

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

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

See also
--------

* `Date.UTC()`


Date.now() - JavaScript

Date.now()
==========

Resumo
------

O método **`Date.now()`** retorna o número de milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC.

Sintaxe
-------
```

var timeInMs = Date.now();
```

### Parâmetros

Nenhum.

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

O método **`now()`** retorna os milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC até agora como um `Number`.

Por que **`now`** é um método estático de **`Date`**, você sempre o usará como **`Date.now()`**.

Polyfill
--------

Este método foi padronizado no ECMA-262 5th edition. Em ambientes que não estão atualizados para suportar este método você pode suprir esta carência utilizando o seguinte:

```js
if (!Date.now) {
  Date.now = function now() {
    return new Date().getTime();
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.now |

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

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

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

* `window.performance.now` - fornece timestamps com sub-millisegundo precisão para uso em medir o desempenho da página
* `console.time` / `console.timeEnd`


Date.prototype.getDay() - JavaScript

Date.prototype.getDay()
=======================

Resumo
------

O método **`getDay()`** retorna o dia da semana para a data especificada de acordo com a hora local, onde 0 representa o Domingo.

Sintaxe
-------
```

dateObj.getDay()
```

### Parâmetros

Nenhum.

### Retorna

O valor retornado por `getDay()` é um inteiro que corresponde com o dia da semana: 0 para Domingo, 1 para Segunda-Feira, 2 para Terça-Feira, e assim por diante.

Exemplos
--------

### Exemplo: Usando `getDay()`

O segundo statement abaixo atribui o valor 1 à variável weekday (dia da semana), baseado no valor do objeto `Date` `Xmas95`. A data 25 de Dezembro de 1995 é uma Segunda-Feira.

```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var weekday = Xmas95.getDay();

console.log(weekday); // 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getday |

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

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

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

* `Date.prototype.getUTCDate()`
* `Date.prototype.getUTCDay()`
* `Date.prototype.setDate()`


Date.prototype.setMonth() - JavaScript

Date.prototype.setMonth()
=========================

O método **`setMonth()`** atribui o mês para uma data específica de acordo com o ano corrente.

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

Sintaxe
-------
```

dateObj.setMonth(monthValue[, dayValue])
```

### Versões anteriores ao JavaScript 1.3
```

dateObj.setMonth(monthValue)
```

### Parâmetros

`monthValue`

Um inteiro baseado em zero representando o mês do ano a partir do começo do ano. Então, 0 representa Janeiro, 11 representa Dezembro, -1 representa Dezembro do ano passado, e 12 representa Janeiro do ano seguinte.

`dayValue`

Opcional. Um inteiro de 1 a 31, representando o dia do mês.

### Valor de retorno

O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

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

Se você não especifica o parâmetro `dayValue`, o valor retornado do método `getDate()` é utilizado.

Se um parâmetro que você especificou estiver fora do alcance esperado, `setMonth()` tenta atualizar a informação da data no objeto `Date`. Por exemplo, se você usa 15 para `monthValue`, o ano será incrementado em 1, e 3 será usado para o mês.

O dia corrente do mês terá um impacto no comportamento deste método. Conceitualmente ele irá adicionar o número de dias dado pelo dia corrente do mês ao primeiro dia do novo mês especificado como parâmetro, retornando uma nova data. Por exemplo, se o valor corrente é 31 de agosto de 2016, chamando `setMonth()` com um valor de 1 irá retornar 2 de Março de 2016. Isso acontece porque Fevereiro de 2016 tem 29 dias.

Exemplos
--------

### Usando `setMonth()`

```js
var theBigDay = new Date();
theBigDay.setMonth(6);

//Cuidado com transições de final de mês
var endOfMonth = new Date(2016, 7, 31);
endOfMonth.setMonth(1);
console.log(endOfMonth); //Wed Mar 02 2016 00:00:00
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setmonth |

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

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

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

* `Date.prototype.getMonth()`
* `Date.prototype.setUTCMonth()`


String.prototype.concat() - JavaScript

String.prototype.concat()
=========================

O método **`concat()`** combina o texto de duas ou mais strings e retorna uma nova string.

Sintaxe
-------
```

str.concat(string2 [, ...stringN])
```

### Parâmetros

`string2...stringN`

Strings para concatenar à **`string2`**.

### Valor retornado

Uma nova string contendo a string original concatenada à string passada como parâmetro.

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

A função **`concat()`** combina o texto de duas ou mais strings e retorna uma nova string. As alterações de texto de uma string não afetam a outra string.

Se o argumento passado não for do tipo string, o mesmo será convertido em uma string antes de ser concatenado.

Performance
-----------

É extremamente recomendado o uso dos operadores de atribuição (`+`, `+=`) em detrimento do método `concat()`.

Exemplos
--------

### Usando `concat()`

O exemplo a seguir concatena uma string à outra string originando uma terceira string.

```js
var hello = "Olá, ";
console.log(hello.concat("Kevin", " tenha um bom dia."));

// retorna 'Olá, Kevin tenha um bom dia.'
```

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

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

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

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

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

* `Array.prototype.concat()`
* Assignment operators (en-US)


String.prototype.endsWith() - JavaScript

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() - JavaScript

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.matchAll() - JavaScript

String.prototype.matchAll()
===========================

O método `matchAll()` retorna um iterador de todos os resultados correspondentes a uma string em relação a uma expressão regular, incluindo grupos de captura (en-US).

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

Sintaxe
-------
```

str.matchAll(regexp)
```

### Parâmetros

`regexp`

Um objeto de expressão regular.

Se um objeto *`obj`* não-RegExp for passado, ele será convertido implicitamente em um `RegExp` usando `new RegExp(obj)`.

O objeto `RegExp` deve ter o sinalizador (flag) `/g`, caso contrário, um `TypeError` será retornado.

### Valor retornado

Um iterador (que não é um iterável reinicializável).

Exemplos
--------

### Regexp.exec() e matchAll()

Antes da adição do `matchAll()` ao JavaScript, era possível usar chamadas regexp.exec (e regexes com a sinalização (flag) `/g`) em um loop para obter todas as correspondências:

```js
const regexp = RegExp("foo[a-z]\*", "g");
const str = "table football, foosball";
let match;

while ((match = regexp.exec(str)) !== null) {
  console.log(
    `Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`,
  );
  // retorna "Encontrou football início=6 fim=14."
  // retorna "Encontou foosball início=16 fim=24."
}
```

Com o `matchAll()` disponível, você pode evitar o loop `while` e executar com `g`.

Em vez disso, usando o `matchAll()`, você obtém um iterador para usar com o mais conveniente `for...of`, `array spread` ou construções `Array.from()`:

```js
const regexp = RegExp("foo[a-z]\*", "g");
const str = "table football, foosball";
const matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(
    `Encontrou ${match[0]} início=${match.index} fim=${
 match.index + match[0].length
 }.`,
  );
}
// retorna "Encontrou football início=6 fim=14."
// retorna "Encontrou foosball início=16 fim=24."

// O iterador de correspondências se esgota após a iterção for..of
// Chame matchAll novamente para criar um novo iterador
Array.from(str.matchAll(regexp), (m) => m[0]);
// Array [ "football", "foosball" ]
```

`matchAll()` retornará uma exceção se o sinalizador (flag) `g` estiver ausente.

```js
const regexp = RegExp("[a-c]", "");
const str = "abc";
str.matchAll(regexp);
// retorna TypeError
```

`matchAll()` cria internamente um clone da `regexp` - portanto, ao contrário de `regexp.exec()`, o `lastIndex` não muda conforme a string é verificada.

```js
const regexp = RegExp("[a-c]", "g");
regexp.lastIndex = 1;
const str = "abc";
Array.from(str.matchAll(regexp), (m) => `${regexp.lastIndex} ${m[0]}`);
// Array [ "1 b", "1 c" ]
```

### Melhor acesso para capturar grupos (do que String.prototype.match())

Outra razão convincente para usar `matchAll()` é o acesso aprimorado para capturar grupos.

Os grupos de captura são ignorados ao usar `match()` com o sinalizador global `/g`:

```js
let regexp = /t(e)(st(\d?))/g;
let str = "test1test2";

str.match(regexp);
// Array ['test1', 'test2']
```

Usando o `matchAll()`, você pode acessar os grupos de captura facilmente:

```js
let array = [...str.matchAll(regexp)];

array[0];
// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
array[1];
// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
```

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

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

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

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

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

* `String.prototype.match()`
* Using regular expressions in JavaScript
* Capturing groups (en-US)
* `RegExp`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.trimEnd() - JavaScript

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.includes() - JavaScript

String.prototype.includes()
===========================

O método **includes()** determina se um conjunto de caracteres pode ser encontrado dentro de outra string, retornando `true` ou `false`.

Sintaxe
-------
```

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

### Parâmetros

`searchString`

É o conjunto de caracteres que será pesquisado dentro desta string.

`position`

Opcional. É um número inteiro que indica por onde a busca iniciará, referente ao índice da string a ser pesquisada. O valor padrão é 0.

### Valor retornado

`true` se o conjunto de caracteres for encontrado em algum lugar dentro da string sendo pesquisada. Do contrário, retorna `false`.

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

Este método permite conferir se uma string contém um determinado conjunto de caracteres.

### Case-sensitivity

O método `includes()` é case sensitive. Por exemplo, a seguinte expressão retorna `false`:

```js
"Bandeira do Brasil".includes("brasil"); // retorna false
```

Exemplos
--------

### Utilizando `includes()`

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

console.log(str.includes("Ser")); // true
console.log(str.includes("questão")); // true
console.log(str.includes("não existe")); // false
console.log(str.includes("ser", 1)); // true
console.log(str.includes("SER")); // false
```

Implementação
-------------

Este método foi adicionado à especificação ECMAScript 6 e pode não estar disponível em todas as implementações JavaScript. No entanto, você pode facilmente implementar este método:

```js
if (!String.prototype.includes) {
  String.prototype.includes = function () {
    "use strict";
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}
```

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

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

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

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

String.prototype.contains
-------------------------

No Firefox 18 - 39, o nome deste método era `contains()`. Ele foi renomeado para `includes()` no Erro do Firefox 1102219 devido ao seguinte motivo:

Foi reportado que alguns websites que utilizam MooTools 1.2 não funcionavam no Firefox 17. Esta versão do MooTools verifica se `String.prototype.contains()` existe e, se não existir, MooTools adiciona sua própria função. Com a implementação desta função no Firefox 17, o comportamento desta validação mudou de uma forma que códigos baseados na implementação da função `String.prototype.contains()` do MooTools parassem de funcionar. Como resultado, esta mudança foi desabilitada no Firefox 17 e `String.prototype.contains()` foi disponibilizada na versão seguinte, no Firefox 18.

MooTools 1.3 força sua própria versão do `String.prototype.contains()`, portanto websites baseados nela não devem parar de funcionar. No entanto, você deve notar que a assinatura do MooTools 1.3 e a assinatura ECMAScript 6 diferem (no segundo argumento). Posteriormente, MooTools 1.5+ mudou sua assinatura para o padrão ES6.

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

* `Array.prototype.includes()`
Experimental
* `TypedArray.prototype.includes()` (en-US)
Experimental
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
Experimental
* `String.prototype.endsWith()`
Experimental


String.prototype[@@iterator]() - JavaScript

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.match() - JavaScript

String.prototype.match()
========================

Resumo
------

O método `match()` retorna uma correspondência entre uma string com uma expressão regular.

Sintaxe
-------
```

str.match(regexp);
```

### Parâmetros

`regexp`

Um objeto de expressão regular. Se *`regexp`* não for uma **`RegExp`**, o mesmo será convertido para uma nova RegExp usando `new RegExp(regexp)`.

Se você não fornecer nenhum parâmetro ao usar o método `match()`, você obterá um `Array` com uma string vazia: `[""]`.

### Valor retornado

* Se o sinalizador `g` for usado, todos os resultados correspondentes à expressão regular serão retornados, mas a captura de grupos não.
* se o sinalizador `g` não for usado, apenas a primeira correspondência completa e seus grupos de captura relacionados serão retornados. Nesse caso, o item devolvido terá propriedades adicionais conforme descrito a seguir.

`array`

Um `Array` cujo conteúdo depende da presença ou ausência do sinalizador global (`g`), ou `null` se nenhuma correspondência for encontrada.

#### Propriedades adicionais

Conforme explicado acima, alguns resultados contêm propriedades adicionais conforme descrito abaixo.

`groups`

Um objeto de grupos de captura nomeados cujas chaves são os nomes, e valores são os grupos de captura ou `undefined` se nenhum grupo de captura nomeado foi definido. Consulte Grupos e Intervalos (en-US) para obter mais informações.

`index`

O índice da pesquisa em que o resultado foi encontrado.

`input`

Uma cópia da string pesquisada.

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

Se a expressão regular não incluir o sinalizador `g`, `str.match()` retornará o mesmo resultado que `RegExp.exec()`.

### Veja também: métodos RegExp

* Se você precisar saber se uma string corresponde a uma expressão regular, use `RegExp.test()`.
* Se você quiser encontrar apenas uma correspondência, você pode querer usar `RegExp.exec()`.
* Se você deseja obter grupos de captura e o sinalizador global (`g`) está definido, você precisa usar `RegExp.exec()` ou `String. prototype.matchAll()`  em vez disso.
Exemplos
--------

### Usando `match()`

No exemplo a seguir, `match()` é usado para encontrar "Capítulo", seguido de um ou mais caracteres numéricos, seguido por um ponto decimal e caracteres numéricos 0 ou mais vezes. A expressão inclui a flag `i` para que diferenças de maiúscula/minúscula sejam ignoradas.

```js
const str = "Para maiores informações, veja o Capítulo 3.4.5.1";
const re = /(capítulo \d+(\.\d)\*)/i;
const found = str.match(re);

console.log(found);

// retorna ["Capítulo 3.4.5.1",
            "Capítulo 3.4.5.1",
            ".1",
            index: 33,
            input: "Para maiores informações, veja o Capítulo 3.4.5.1"]

// "Capítulo 3.4.5.1" é a primeira correspondência e o primeiro valor
// capturado a partir de (capítulo \d+(\.\d)\*).
// ".1" é o útlimo valor de (\.\d).
// A propriedade "index" (33) é o índice de base zero da correspôndencia inteira.
// A propriedade "input" é a string original que foi analisada.
```

### Usando as bandeiras (flags) global e ignore com`match()`

O exemplo a seguir demonstra o uso das bandeiras (flags) global e ignore com `match()`. Todas as letras de `A` a `E` e `a` a `e` são retornadas, com cada letra sendo um elemento no array.

```js
const str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const regexp = /[A-E]/gi;
const matches_array = str.match(regexp);

console.log(matches_array);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']
```

**Nota:** Veja também `String.prototype.matchAll()` e Pesquisa avançada com sinalizadores.

### Usando grupos de captura nomeados

Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "`fox`" ou "`cat`" em um grupo denominado "`animal`":

```js
const paragraph = "The quick brown fox jumps over the lazy dog. It barked.";

const capturingRegex = /(?<animal>fox|cat) jumps over/;
const found = paragraph.match(capturingRegex);
console.log(found.groups); // {animal: "fox"}
```

### Usando `match()` sem parâmetros

```js
const str = "nada se perde, tudo se transforma";

str.match(); // retorna [""]
```

### Um objeto não-RegExp como parâmetro

Quando o parâmetro *`regexp`* é uma string ou um número, ele é convertido implicitamente em um `RegExp` usando o `new RegExp(regexp)`.

Se for um número positivo com um sinal positivo, `RegExp()` irá ignorar o sinal positivo.

```js
const str1 =
  "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript.";
const str2 = "Meu avô tem 65 anos e minha avô tem 63.";
const str3 = "O contrato foi declarado null (nulo) e void (sem efeito)";
str1.match("número"); // "número" é um string. retorna ["número"]
str1.match(NaN); // o tipo de NaN é um número. retorna ["NaN"]
str1.match(Infinity); // o tipo de Infinity é um número. retorna ["Infinity"]
str1.match(+Infinity); // retorna ["Infinity"]
str1.match(-Infinity); // retorna ["-Infinity"]
str2.match(65); // retorna ["65"]
str2.match(+65); // Um número com sinal positivo. retorna ["65"]
str3.match(null); // retorna ["null"]
```

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

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

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

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

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

* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.charCodeAt() - JavaScript

String.prototype.charCodeAt()
=============================

O método **`charCodeAt()`** retorna um número inteiro entre `0` e `65535` que representa a unidade de código UTF-16 no índice fornecido. A unidade de código UTF-16 corresponde ao ponto de código Unicode para pontos de códigos representáveis em uma única unidade de código UTF-16, mas também pode ser a primeira unidade de código de um par substituto não representável em uma única unidade de código UTF-16. Po exemplo: pontos de código Unicode > (0x10000). Se você quer o valor do ponto de código inteiro, use **`codePointAt`**().

Sintaxe
-------
```

str.charCodeAt(index)
```

### Parâmetros

`index`

Um inteiro maior ou igual a `0` e menor que o comprimento da string. Se não for um número, o padrão será `0`.

### Valor retornado

Um número representando o valor de unidade de código UTF-16 do caractere no índice fornecido. O valor `NaN` é retornado se o índice estiver fora do intervalo aceitável.

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

Os pontos de código Unicode variam de `0` a `1114111` (`0x10FFFF`). Os primeiros 128 pontos de código Unicode são uma correspondência direta da codificação de caracteres ASCII. (Para informações sobre Unicode, veja o JavaScript Guide.)

**Nota:** o `charCodeAt()` sempre retornará um valor menor do que `65536`. Isso ocorre pois os pontos de código mais altos são representados por um par de pseudo-caracteres "substitutos" (de menor valor) que são usados para compreender o caracter real.

Por isso, para examinar (ou reproduzir) o caractere completo para valores de caracteres individuais de valor `65536` e acima, é necessário recuperar não apenas o `charCodeAt(i)`, mas também o `charCodeAt(i+1)` (como se examinando/reproduzindo a string com duas letras), ou usar o `codePointAt(i)`. Veja o exemplo 2 e 3 (abaixo).

Compatibilidade com versões anteriores: Em versões históricas (como JavaScript 1.2) o método `charCodeAt()` retorna um número indicando o valor de conjunto de códigos ISO-Latin-1 do caractere no dado índice. O conjunto de códigos ISO-Latin-1 varia de `0` a `255`. Os primeiros `128` (do `0` ao `127`) são uma correspondência direta ao conjunto de caracteres ASCII.

Exemplos
--------

### Usando `charCodeAt()`

O exemplo a seguir retorna `65`, o valor Unicode para A.

```js
"ABC".charCodeAt(0); // retorna 65
```

### Corrigindo o `charCodeAt()` para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida

Essa versão pode ser usada em loops **for** e afins quando não sabemos se caracteres de Plano Multilingual não Básico existem antes da posição do índice especificado.

```js
function fixedCharCodeAt(str, idx) {
  // ex. fixedCharCodeAt('\uD800\uDC00', 0); // 65536
  // ex. fixedCharCodeAt('\uD800\uDC00', 1); // false
  idx = idx || 0;
  var code = str.charCodeAt(idx);
  var hi, low;

  // Substituto elevado (poderia mudar o último hex para 0xDB7F para tratar
  // substitutos privados elevados como caracteres únicos)
  if (0xd800 <= code && code <= 0xdbff) {
    hi = code;
    low = str.charCodeAt(idx + 1);
    if (isNaN(low)) {
      throw "High surrogate not followed by low surrogate in fixedCharCodeAt()";
    }
    return (hi - 0xd800) \* 0x400 + (low - 0xdc00) + 0x10000;
  }
  if (0xdc00 <= code && code <= 0xdfff) {
    // Low surrogate
    // Retornamos false para permitir os loops pularem essa iteração já que já deveria
    //ter tratado os substitutos elevados acima, na iteração anterior
    return false;
    /\*hi = str.charCodeAt(idx - 1);
 low = code;
 return ((hi - 0xD800) \* 0x400) + (low - 0xDC00) + 0x10000;\*/
  }
  return code;
}
```

### Corrigindo o `charCodeAt()` para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida

```js
function knownCharCodeAt(str, idx) {
  str += "";
  var code,
    end = str.length;

  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  while (surrogatePairs.exec(str) != null) {
    var li = surrogatePairs.lastIndex;
    if (li - 2 < idx) {
      idx++;
    } else {
      break;
    }
  }

  if (idx >= end || idx < 0) {
    return NaN;
  }

  code = str.charCodeAt(idx);

  var hi, low;
  if (0xd800 <= code && code <= 0xdbff) {
    hi = code;
    low = str.charCodeAt(idx + 1);
    // Vá um adiante, já que um dos "characters" é parte de um par substituto
    return (hi - 0xd800) \* 0x400 + (low - 0xdc00) + 0x10000;
  }
  return code;
}
```

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

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

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

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

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

* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.fromCodePoint()`
* `String.prototype.codePointAt()`


String.prototype.startsWith() - JavaScript

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.normalize() - JavaScript

String.prototype.normalize()
============================

O método **`normalize()`** retorna a Forma de Normalização Unicode (Unicode Normalization Form) de uma dada string (se o valor não é uma string, ele será convertido para uma primeiramente).

Sintaxe
-------
```

str.normalize([form])
```

### Parâmetros

`form`

Opcional. Um dentre os seguintes valores: `"NFC"`, `"NFD"`, `"NFKC"`, ou `"NFKD"`, especificando o formato de normalização. Se o valor for omitido ou for `undefined`, `"NFC"` será utilizado.

* `NFC` — Formato de Normalização Canônico de Composição.
* `NFD` — Formato de Normalização Canônico de Decomposição.
* `NFKC` — Formato de Normalização de Compatibilidade de Composição.
* `NFKD` — Formato de Normalização de Compatibilidade de Decomposição.

### Valor retornado

Uma string contendo a Forma de Normalização Unicode da string dada.

### Erros lançados

`RangeError` (en-US)

Em erro `RangeError` (en-US) é lançado se `form` não for um dos valores especificados acima.

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

O Unicode atribui um valor numérico exclusivo, denominado *ponto de código*, a cada caractere. Por exemplo, o ponto de código para *"A"* é fornecido como U+0041. No entanto, às vezes mais de um ponto de código, ou sequência de pontos de código, podem representar o mesmo caractere abstrato - o caractere `"ñ"`, por exemplo, pode ser representado por:

* Apenas um ponto de código U+00F1.
* O ponto de código para `"n"` (U+006E) seguido pelo ponto de código para o til (U+0303).

```js
let string1 = "\u00F1";
let string2 = "\u006E\u0303";

console.log(string1); // retorna ñ
console.log(string2); // retorna ñ
```

No entanto, como os pontos de código são diferentes, a comparação de strings não os tratará como iguais. E como o número de pontos de código em cada versão é diferente, eles até mesmo possuem comprimentos diferentes.

```js
let string1 = "\u00F1"; // ñ
let string2 = "\u006E\u0303"; // ñ

console.log(string1 === string2); // retorna false
console.log(string1.length); // retorna 1
console.log(string2.length); // retorna 2
```

O método `normalize()` ajuda a resolver esse problema convertendo uma string em uma forma normalizada comum para todas as sequências de pontos de código que representam os mesmos caracteres. Existem duas principais formas de normalização, uma baseada na **equivalência canônica** e a outra baseada na **compatibilidade**.

### Normalização de equivalência canônica

Em Unicode, duas sequências de pontos de código têm equivalência canônica se representarem os mesmos caracteres abstratos e tiverem sempre a mesma aparência visual e comportamento (por exemplo, eles devem sempre ser classificados da mesma maneira).

Você pode usar o `normalize()` usando os argumentos `"NFD"` ou `"NFC"` para produzir uma forma de string que será a mesma para todas as strings canonicamente equivalentes. No exemplo abaixo, normalizamos duas representações do caractere `"ñ"`:

```js
let string1 = "\u00F1"; // ñ
let string2 = "\u006E\u0303"; // ñ

string1 = string1.normalize("NFD");
string2 = string2.normalize("NFD");

console.log(string1 === string2); // retorna true
console.log(string1.length); // retorna 2
console.log(string2.length); // retorna 2
```

#### Formas compostas e decompostas

Observe que o comprimento da forma normalizada em `"NFD"` é `2`. Isso porque `"NFD"` fornece a versão **decomposta** da forma canônica, na qual pontos de código únicos são divididos em vários combinados. A forma canônica decomposta para `"ñ"` é `"\u006E\u0303"`.

Você pode especificar `"NFC"` para obter a forma canônica **composta**, na qual vários pontos de código são substituídos por pontos de código únicos sempre que possível. A forma canônica composta para `"ñ"` é `"\u00F1"`:

```js
let string1 = "\u00F1"; // ñ
let string2 = "\u006E\u0303"; // ñ

string1 = string1.normalize("NFC");
string2 = string2.normalize("NFC");

console.log(string1 === string2); // true
console.log(string1.length); // 1
console.log(string2.length); // 1
console.log(string2.codePointAt(0).toString(16)); // f1
```

### Normalização de compatibilidade

No Unicode, duas sequências de pontos de código são compatíveis se representarem os mesmos caracteres abstratos e devem ser tratadas da mesma forma em algumas - mas não necessariamente em todas - aplicações.

Todas as sequências canonicamente equivalentes também são compatíveis, mas não o contrário.

Por exemplo:

* o ponto de código U+FB00 representa a ligadura (en-US) `"ﬀ"`. É compatível com dois pontos de código U+0066 consecutivos (`"ff"`).
* o ponto de código U+24B9 representa o símbolo `"Ⓓ"`. É compatível com o ponto de código U+0044 (`"D"`).

Em alguns aspectos (como classificação), eles devem ser tratados como equivalentes - e em alguns (como a aparência visual) não devem, portanto, não são canonicamente equivalentes.

Você pode usar o `normalize()` usando os argumentos `"NFKD"` ou `"NFKC"` para produzir uma forma de string que será a mesma para todas as strings compatíveis:

```js
let string1 = "\uFB00";
let string2 = "\u0066\u0066";

console.log(string1); // ﬀ
console.log(string2); // ff
console.log(string1 === string2); // false
console.log(string1.length); // 1
console.log(string2.length); // 2

string1 = string1.normalize("NFKD");
string2 = string2.normalize("NFKD");

console.log(string1); // ff <- aparência visual modificada
console.log(string2); // ff
console.log(string1 === string2); // true
console.log(string1.length); // 2
console.log(string2.length); // 2
```

Ao aplicar a normalização de compatibilidade, é importante considerar o que você pretende fazer com as strings, uma vez que a forma normalizada pode não ser apropriada para as aplicações. No exemplo acima, a normalização é apropriada para pesquisa, porque permite que um usuário encontre a string pesquisando por `"f"`. Mas pode não ser apropriado para exibição, porque a representação visual é diferente.

Como na normalização canônica, você pode solicitar formulários compatíveis decompostos ou compostos passando `"NFKD"` ou `"NFKC"`, respectivamente.

Exemplos
--------

### Usando `normalize()`

```js
// String Inicial

// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
// U+0323: COMBINANDO PONTO ABAIXO
var str = "\u1E9B\u0323";

// Formato de Normalização Canônico de Composição (NFC)

// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
// U+0323: COMBINANDO PONTO ABAIXO
str.normalize("NFC"); // '\u1E9B\u0323'
str.normalize(); // igual à linha de cima

// Formato de Normalização Canônico de Decomposição (NFD)

// U+017F: CARACTERE LATINO - LETRA S COMPRIDA
// U+0323: COMBINANDO PONTO ABAIXO
// U+0307: COMBINANDO PONTO ACIMA
str.normalize("NFD"); // '\u017F\u0323\u0307'

// Formato de Normalização de Compatibilidade de Composição. (NFKC)

// U+1E69: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA E ABAIXO
str.normalize("NFKC"); // '\u1E69'

// Formato de Normalização de Compatibilidade de Decomposição (NFKD)

// U+0073: CARACTERE LATINO - LETRA S COMPRIDA
// U+0323: COMBINANDO PONTO ABAIXO
// U+0307: COMBINANDO PONTO ACIMA
str.normalize("NFKD"); // '\u0073\u0323\u0307'
```

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

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

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

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

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

* Unicode Standard Annex #15, Unicode Normalization Forms
* Unicode equivalence


String.prototype.indexOf() - JavaScript

String.prototype.indexOf()
==========================

Sumário
-------

O método `indexOf()` retorna o índice da primeira ocorrência do valor fornecido em searchValue, começando a busca a partir de `fromIndex`. Retorna `-1` se o valor não for encontrado.

**Nota:** Para o método de Array, veja `Array.prototype.indexOf()`.

Sintaxe
-------
```

str.indexOf(searchValue[, fromIndex])
```

### Parâmetros

`searchValue`

Uma string representando o valor a ser buscado. Se nenhuma string for fornecida explicitamente, `searchValue` terá o valor de `undefined`, e esse valor será buscado na string atual. Por exemplo, `'undefined'.indexOf()` retornará `0`, já que `undefined` é encontrado na posição `0`. Já `'undefine'.indexOf()` retornará `-1`, já que `undefined` não pôde ser encontrado.

`fromIndex`

Um número inteiro representando um índice da string original a partir da qual a busca deve começar. Por padrão é `0`. Se `fromIndex < 0`, a string toda é percorrida (equivale a passar 0). Se `fromIndex >= str.length`, o método retornará `-1`, já que a busca será iniciada após o final da string.

### Valor retornado

O índice da primeira ocorrência de *searchValue*, ou `-1` se não for encontrado.

Uma string vazia no *searchValue* produz resultados estranhos. Sem `fromIndex`, ou com qualquer `fromIndex` menor que o comprimento da string, o valor retornado é o próprio `fromIndex`:

```js
"Olá, mundo".indexOf(""); // retorna 0
"Olá, mundo".indexOf("", 0); // retorna 0
"Olá, mundo".indexOf("", 3); // retorna 3
"Olá, mundo".indexOf("", 8); // retorna 8
```

Entretanto, com qualquer `fromIndex` igual ou maior que o comprimento da string, o valor retornado é o comprimento da string:

```js
"Olá, mundo".indexOf("", 11); // retorna 10
"Olá, mundo".indexOf("", 13); // retorna 10
"Olá, mundo".indexOf("", 22); // retorna 10
```

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

Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é `0`, e o índice do último caractere de uma string chamada `stringName` é `stringName.length - 1`.

```js
"Blue Whale".indexOf("Blue"); // retorna 0
"Blue Whale".indexOf("Whale"); // retorna 5
"Blue Whale".indexOf("Blute"); // retorna -1
"Blue Whale".indexOf("Whale", 0); // retorna 5
"Blue Whale".indexOf("Whale", 5); // retorna 5
"Blue Whale".indexOf("Whale", 7); // retorna -1
"Blue Whale".indexOf(""); // retorna 0
"Blue Whale".indexOf("", 9); // retorna 9
"Blue Whale".indexOf("", 10); // retorna 10
"Blue Whale".indexOf("", 11); // retorna 10
```

### Verificando ocorrências

Note que um retorno `0` não implica em `true`, e `-1` não implica em `false`. Portanto, a maneira correta de se verificar se uma string específica está contida em outra string seria:

```js
"Blue Whale".indexOf("Blue") !== -1; // true
"Blue Whale".indexOf("Bloe") !== -1; // false
```

Exemplos
--------

### Usando `indexOf()`

O exemplo a seguir usa `indexOf()` para localizar valores dentro da string "`Brave new world`".

```js
var anyString = "Brave new world";

console.log(
  "O índice do primeiro w partindo do começo é " + anyString.indexOf("w"),
);
// Exibe 8

console.log(
  "O índice de 'new' partindo do começo é " + anyString.indexOf("new"),
);
// Exibe 6
```

### `indexOf()` e sensibilidade a maiúsculas e minúsculas

O exemplo a seguir define duas variáveis string. Ambas contém a mesma string, exceto que a segunda string tem letras maiúsculas. O primeiro método `console.log()` exibe `19`. Porém, como o método `indexOf` é sensível a letras maiúsculas e minúsculas, a string `"cheddar"` não é encontrada em `myCapString`, portanto, o segundo método `console.log()` exibe `-1`.

```js
var myString = "brie, pepper jack, cheddar";
var myCapString = "Brie, Pepper Jack, Cheddar";

console.log('myString.indexOf("cheddar") é ' + myString.indexOf("cheddar"));
// Exibe 19
console.log(
  'myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar"),
);
// Exibe -1
```

### Usando `indexOf()` para contar as ocorrências de uma letra numa string

O exemplo a seguir atribui à variável `count` o número de ocorrências da letra `x` na string `str`:

```js
const str = "Serx ou não ser, eisx a questão";
count = 0;
pos = str.indexOf("x"); // retorna 3

while (pos != -1) {
  count++;
  pos = str.indexOf("x", pos + 1 /\* o mesmo que 3 + 1 \*/);
}

console.log(count);
```

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

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

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

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

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

* `String.prototype.charAt()`
* `String.prototype.lastIndexOf()`
* `String.prototype.includes()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`


String.prototype.charAt() - JavaScript

String.prototype.charAt()
=========================

O método **`charAt()`** retorna o caractere especificado a partir de uma string.

Sintaxe
-------
```

str.charAt(index)
```

### Parâmetros

`index`

Um inteiro entre `0` e `str.length - 1`. Se nenhum índice for definido, `charAt()` usará `0` como índice.

### Valor retornado

Uma string representando o caractere no índice especificado. Uma string vazia se o **`index`** fornecido estiver fora do intervalo de índices da string `str`.

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

Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é `0` (zero), e o índice do último caractere em uma string declarada como `stringName` é `stringName.length - 1`. Se o índice que você fornecer estiver fora do intervalo de índices da string, JavaScript retornará uma string vazia.

Se nenhum índice for passado para `charAt()`, `0` será usado por padrão.

Exemplos
--------

### Mostrando caracteres em diferente localizações em uma string

O exemplo a seguir mostra caracteres em diferentes locais em uma string `"Brave new world"`:

```js
var anyString = "Brave new world";

console.log("A letra no índice 0 é '" + anyString.charAt(0) + "'");
console.log("A letra no índice 1 é '" + anyString.charAt(1) + "'");
console.log("A letra no índice 2 é '" + anyString.charAt(2) + "'");
console.log("A letra no índice 3 é '" + anyString.charAt(3) + "'");
console.log("A letra no índice 4 é '" + anyString.charAt(4) + "'");
console.log("A letra no índice 99 é '" + anyString.charAt(999) + "'");
```

As linhas acima retornam o seguinte:

```js
A letra no índice 0 é 'B'
A letra no índice 1 é 'r'
A letra no índice 2 é 'a'
A letra no índice 3 é 'v'
A letra no índice 4 é 'e'
A letra no índice 99 é ''
```

### Obtendo caracteres inteiros

O seguinte código fornece um meio de garantir que passar por um loop de string sempre forneça um caractere inteiro, mesmo se a string contiver caracteres que não estão no Plano Multilíngue Básico.

```js
var str = "A \uD87E\uDC04 Z"; // We could also use a non-BMP character directly
for (var i = 0, chr; i < str.length; i++) {
  if ((chr = getWholeChar(str, i)) === false) {
    continue;
  }
  // Adapt this line at the top of each loop, passing in the whole string and
  // the current iteration and returning a variable to represent the
  // individual character

  console.log(chr);
}

function getWholeChar(str, i) {
  var code = str.charCodeAt(i);

  if (isNaN(code)) {
    return ""; // Position not found
  }
  if (code < 0xd800 || code > 0xdfff) {
    return str.charAt(i);
  }

  // High surrogate (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xd800 <= code && code <= 0xdbff) {
    if (str.length <= i + 1) {
      throw "High surrogate without following low surrogate";
    }
    var next = str.charCodeAt(i + 1);
    if (0xdc00 > next || next > 0xdfff) {
      throw "High surrogate without following low surrogate";
    }
    return str.charAt(i) + str.charAt(i + 1);
  }
  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
  if (i === 0) {
    throw "Low surrogate without preceding high surrogate";
  }
  var prev = str.charCodeAt(i - 1);

  // (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xd800 > prev || prev > 0xdbff) {
    throw "Low surrogate without preceding high surrogate";
  }
  // We can pass over low surrogates now as the second component
  // in a pair which we have already processed
  return false;
}
```

Em um ambiente ECMAScript 2016 que permite atribuição desestruturada, o seguinte código é uma alternativa mais sucinta e um pouco mais flexível, pois faz incremento para uma variável de incremento automaticamente (se o caractere justificar que seja um par substituto).

```js
var str = "A\uD87E\uDC04Z"; // We could also use a non-BMP character directly
for (var i = 0, chr; i < str.length; i++) {
  [chr, i] = getWholeCharAndI(str, i);
  // Adapt this line at the top of each loop, passing in the whole string and
  // the current iteration and returning an array with the individual character
  // and 'i' value (only changed if a surrogate pair)

  console.log(chr);
}

function getWholeCharAndI(str, i) {
  var code = str.charCodeAt(i);

  if (isNaN(code)) {
    return ""; // Position not found
  }
  if (code < 0xd800 || code > 0xdfff) {
    return [str.charAt(i), i]; // Normal character, keeping 'i' the same
  }

  // High surrogate (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xd800 <= code && code <= 0xdbff) {
    if (str.length <= i + 1) {
      throw "High surrogate without following low surrogate";
    }
    var next = str.charCodeAt(i + 1);
    if (0xdc00 > next || next > 0xdfff) {
      throw "High surrogate without following low surrogate";
    }
    return [str.charAt(i) + str.charAt(i + 1), i + 1];
  }
  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
  if (i === 0) {
    throw "Low surrogate without preceding high surrogate";
  }
  var prev = str.charCodeAt(i - 1);

  // (could change last hex to 0xDB7F to treat high private surrogates
  // as single characters)
  if (0xd800 > prev || prev > 0xdbff) {
    throw "Low surrogate without preceding high surrogate";
  }
  // Return the next character instead (and increment)
  return [str.charAt(i + 1), i + 1];
}
```

### Corrigindo `charAt()` para suportar caracteres não-Plano-Multilíngüe-Básico (PMB)

Embora o exemplo anterior possa ser mais útil para programas que devem suportar caracteres não BMP (uma vez que não exige que o chamador saiba onde qualquer caractere não BMP pode aparecer), no caso de desejar, na escolha de um caractere por índice, para tratar os pares substitutos em uma string como os caracteres únicos que eles representam, pode-se usar o seguinte:

```js
function fixedCharAt(str, idx) {
  var ret = "";
  str += "";
  var end = str.length;

  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  while (surrogatePairs.exec(str) != null) {
    var li = surrogatePairs.lastIndex;
    if (li - 2 < idx) {
      idx++;
    } else {
      break;
    }
  }

  if (idx >= end || idx < 0) {
    return "";
  }

  ret += str.charAt(idx);

  if (
    /[\uD800-\uDBFF]/.test(ret) &&
    /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))
  ) {
    // Go one further, since one of the "characters" is part of a surrogate pair
    ret += str.charAt(idx + 1);
  }
  return ret;
}
```

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

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

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

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

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

* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
* `String.prototype.split()`
* `String.fromCodePoint()`
* JavaScript has a Unicode problem – Mathias Bynens


String.prototype.substring() - JavaScript

String.prototype.substring()
============================

Resumo
------

O método `substring()` retorna a parte da string entre os índices inicial e final, ou até o final da string.

Sintaxe
-------
```

str.substring(indexStart[, indexEnd])
```

### Parâmetros

`indexStart`

Um inteiro entre `0` e o comprimento da string (`str.length`), especificando a posição na string do primeiro caractere a ser incluído na substring retornada.

`indexEnd`

Opcional. Um inteiro entre `0` e o comprimento da string (`str.length`), especificando a posição na string do primeiro caractere a **não** ser mais incluído na substring retornada.

### Valor retornado

Uma nova string contendo a parte especificada da string fornecida.

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

`substring()` extrai caracteres desde `indexStart` até, mas **não** **incluindo**, `indexEnd`. Em particular:

* Se `indexStart` é igual a `indexEnd`, `substring()` retorna uma string vazia.
* Se `indexEnd` for omitido, `substring()` extrai caracteres até o fim da string.
* Se qualquer argumento for menor que `0` ou `NaN`, ele será tratado como `0`.
* Se qualquer argumento for maior que `stringName.length`, ele será tratado como se fosse `stringName.length`

Se `indexStart` for maior que `indexEnd`, então o efeito do `substring()` é como se os dois argumentos estivessem trocados, por exemplo, `str.substring(1, 0) == str.substring(0, 1)`.

Exemplos
--------

### Usando `substring()`

O seguinte exemplo usa `substring()` para mostrar caracteres da palavra 'Mozilla':

```js
var anyString = "Mozilla";

// Mostra "Moz"
console.log(anyString.substring(0, 3));
console.log(anyString.substring(3, 0));

// Mostra "lla"
console.log(anyString.substring(4, 7));
console.log(anyString.substring(7, 4));

// Mostra "Mozill"
console.log(anyString.substring(0, 6));

// Mostra "Mozilla"
console.log(anyString.substring(0, 7));
console.log(anyString.substring(0, 10));
```

### Usando `substring()` com `length`

O exemplo a seguir usa o método `substring()` e a propriedade `length` para extrair os últimos caracteres de uma string específica. Este método pode ser mais fácil de lembrar, visto que você não precisa saber os índices inicial e final como faria nos exemplos acima.

```js
// Mostra 'illa', os últimos 4 caracteres
let anyString = "Mozilla";
let anyString4 = anyString.substring(anyString.length - 4);
console.log(anyString4);

// Mostra 'zilla', os últimos 5 caracteres
let anyString = "Mozilla";
let anyString5 = anyString.substring(anyString.length - 5);
console.log(anyString5);
```

### A diferença entre `substring()` e `substr()`

Há uma diferença sutil entre os métodos `substring()` e `substr()`, então você deve ter cuidado para não confundi-los.

Os argumentos de `substring()` representam os índices inicial e final, enquanto os argumentos de `substr()` representam o índice inicial e o número de caracteres a serem incluídos na string retornada.

Além disso, `substr()` é considerado um **recurso legacy no ECMAScript** e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível.

```js
let text = "Mozilla";
console.log(text.substring(2, 5)); // retorna "zil"
console.log(text.substr(2, 3)); // retorna "zil"
```

### Diferenças entre `substring()` e `slice()`

Os métodos `substring()` e `slice()` são quase idênticos, mas existem algumas diferenças sutis entre os dois, especialmente na forma como os argumentos negativos são tratados.

O método `substring()` troca seus dois argumentos se `indexStart` for maior que `indexEnd`, o que significa que uma string ainda será retornada. O método `slice()` retorna uma string vazia caso o mesmo ocorra.

```js
let text = "Mozilla";
console.log(text.substring(5, 2)); // retorna "zil"
console.log(text.slice(5, 2)); // retorna ""
```

Se um ou ambos os argumentos forem negativos ou `NaN`, o método `substring()` os tratará como se fossem `0`.

```js
console.log(text.substring(-5, 2)); // retorna "Mo"
console.log(text.substring(-5, -2)); // retorna ""
```

`slice()` também trata os argumentos `NaN` como `0`, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices.

```js
console.log(text.slice(-5, 2)); // retorna ""
console.log(text.slice(-5, -2)); // retorna "zil"
```

Veja a página `slice()` para mais exemplos com números negativos.

### Substituindo uma `substring()` com uma string

O seguinte exemplo substitui uma substring dentro de uma string. Ela irá substituir ambos caracteres e substrings individualmente. A função invocada na linha final do exemplo altera a string "`Brave New World`" para "`Brave New Web`".

```js
function replaceString(oldS, newS, fullS) {
  // Substitui oldS por newS na string fullS
  for (var i = 0; i < fullS.length; i++) {
    if (fullS.substring(i, i + oldS.length) == oldS) {
      fullS =
        fullS.substring(0, i) +
        newS +
        fullS.substring(i + oldS.length, fullS.length);
    }
  }
  return fullS;
}

replaceString("World", "Web", "Brave New World");
```

Note que isto pode resultar em um loop infinito se `oldS` for um substring de `newS` — por exemplo, se você tentou substituir "`World`" com "`OtherWorld`". O melhor método para substituir strings é o seguinte:

```js
function replaceString(oldS, newS, fullS) {
  return fullS.split(oldS).join(newS);
}
```

O código acima serve como um exemplo para operações com substring. Se você precisa substituir substrings, na maioria das vezes você vai querer usar `String.prototype.replace()`.

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

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

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

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

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

* `String.prototype.substr()`
* `String.prototype.slice()`


String.prototype.strike() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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()`


String.prototype.italics() - JavaScript

String.prototype.italics()
==========================

**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 `italics()` cria um elemento HTML `<i>` que faz com que uma string fique em itálico.

Sintaxe
-------
```

str.italics()
```

### Valor retornado

Uma string contendo um elemento HTML `<i>`.

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

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

Exemplos
--------

### Usando `italics()`

O exemplo a seguir usa métodos do objeto global 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.italics |

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.strike()`


String.prototype.padEnd() - JavaScript

String.prototype.padEnd()
=========================

O método `padEnd()` preenche a string original com um determinado caractere, ou conjunto de caraceres, (repetidamente, se necessário) para que a string resultante alcance um determinado comprimento. O preenchimento é aplicado a partir do final (direita) da string original. A string original não é modificada.

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

Sintaxe
-------
```

str.padEnd(targetLength [, padString])
```

### Parâmetros

`targetLength`

O comprimento da string resultante após a string original ter sido preenchida. Se o valor for menor do que o próprio comprimento da string original, a string original é retornada sem modificações.

`padString`

Opcional. O caractere (ou caracteres) que deve completar a string atual. Caso o comprimento desta string seja muito longo, estando acima do comprimento alvo, ela será truncada e sua parte esquerda restante é aplicada. O valor padrão para esse parâmetro é " " (`U+0020`).

### Valor retornado

Uma `String` cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.

Exemplos
--------

### Usando padEnd

```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

Polyfill
--------

Rodando o seguinte código antes de qualquer código irá criar o método `String.prototype.padEnd()` caso ele não esteja disponível nativamente:

```js
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
// https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/String/padEnd
if (!String.prototype.padEnd) {
  String.prototype.padEnd = function padEnd(targetLength, padString) {
    targetLength = targetLength >> 0; //floor if number or convert non-number to 0;
    padString = String(typeof padString !== "undefined" ? padString : " ");
    if (this.length > targetLength) {
      return String(this);
    } else {
      targetLength = targetLength - this.length;
      if (targetLength > padString.length) {
        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
      }
      return String(this) + padString.slice(0, targetLength);
    }
  };
}
```

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

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

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

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

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

* `String.prototype.padStart()`


String.fromCodePoint() - JavaScript

String.fromCodePoint()
======================

O método estático **String.fromCodePoint()** retorna uma seqüência de caracteres criado usando a seqüência especificada de pontos de código.

Syntax
------
```

String.fromCodePoint(num1[, ...[, numN]])
```

### Parâmetros

`num1, ..., numN`

Uma sequência de pontos de código.

### Exceções

`RangeError` (en-US)

O `RangeError` (en-US) é lançado se um ponto de código Unicode inválido é dado (por exemplo, "RangeError: NaN não é um ponto de código válido").

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

Como o fromCodePoint() é um método estático do `String`, você sempre vai chamar esse método como **String.fromCodePoint()✔** em vez de usá-lo como um método de uma string que você criar, como **"minha string".fromCodePoint()❌**.

Exemplos
--------

### Usando `fromCodePoint()`

```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"

String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

```js
// String.fromCharCode() alone cannot get the character at such a high code point
// The following, on the other hand, can return a 4-byte character as well as the
// usual 2-byte ones (i.e., it can return a single character which actually has
// a string length of 2 instead of 1!)
console.log(String.fromCodePoint(0x2f804)); // or 194564 in decimal
```

Polyfill
--------

O método **String.fromCodePoint** foi adicionado ao padrão ECMAScript na versão 6 e pode não ser suportado em todos os navegadores da Web ou em todos os ambientes ainda. Use o código abaixo para um polyfill:

```js
/\*! http://mths.be/fromcodepoint v0.1.0 by @mathias \*/
if (!String.fromCodePoint) {
  (function () {
    var defineProperty = (function () {
      // IE 8 only supports `Object.defineProperty` on DOM elements
      try {
        var object = {};
        var $defineProperty = Object.defineProperty;
        var result = $defineProperty(object, object, object) && $defineProperty;
      } catch (error) {}
      return result;
    })();
    var stringFromCharCode = String.fromCharCode;
    var floor = Math.floor;
    var fromCodePoint = function () {
      var MAX\_SIZE = 0x4000;
      var codeUnits = [];
      var highSurrogate;
      var lowSurrogate;
      var index = -1;
      var length = arguments.length;
      if (!length) {
        return "";
      }
      var result = "";
      while (++index < length) {
        var codePoint = Number(arguments[index]);
        if (
          !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
          codePoint < 0 || // not a valid Unicode code point
          codePoint > 0x10ffff || // not a valid Unicode code point
          floor(codePoint) != codePoint // not an integer
        ) {
          throw RangeError("Invalid code point: " + codePoint);
        }
        if (codePoint <= 0xffff) {
          // BMP code point
          codeUnits.push(codePoint);
        } else {
          // Astral code point; split in surrogate halves
          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
          codePoint -= 0x10000;
          highSurrogate = (codePoint >> 10) + 0xd800;
          lowSurrogate = (codePoint % 0x400) + 0xdc00;
          codeUnits.push(highSurrogate, lowSurrogate);
        }
        if (index + 1 == length || codeUnits.length > MAX\_SIZE) {
          result += stringFromCharCode.apply(null, codeUnits);
          codeUnits.length = 0;
        }
      }
      return result;
    };
    if (defineProperty) {
      defineProperty(String, "fromCodePoint", {
        value: fromCodePoint,
        configurable: true,
        writable: true,
      });
    } else {
      String.fromCodePoint = fromCodePoint;
    }
  })();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcodepoint |

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

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

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

* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.prototype.codePointAt()`
* `String.prototype.charCodeAt()`


String.prototype.link() - JavaScript

String.prototype.link()
=======================

**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 `link()` cria uma string que representa o código para um elemento HTML `<a>` a ser usado como um link de hipertexto para outro URL.

Sintaxe
-------
```

str.link(url)
```

### Parâmetros

`url`

Qualquer string que especifique o atributo `href` da tag `<a>`. Deve ser um URL válido (relativo ou absoluto), com qualquer caractere `&` escapado como `&amp` e qualquer `"` caractere escapado como `&quot`.

### Valor retornado

Uma string contendo um elemento HTML `<a>`.

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

Use o método `link()` para criar um elemento HTML `<a>`. A string retornada pode então ser adicionada ao documento por meio de `document.write()` ou `element.innerHTML`.

Os links criados com o método `link()` tornam-se elementos na array de links do objeto `document`. Veja `document.links` (en-US).

Exemplos
--------

### Usando `link()`

O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network.

```js
var hotText = "MDN";
var URL = "https://developer.mozilla.org/";

console.log("Clique para retornar à" + hotText.link(URL));
// Clique para retornar à <a href="https://developer.mozilla.org/">MDN</a>
```

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

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

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

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

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

* `String.prototype.anchor()`


String.prototype.toLocaleUpperCase() - JavaScript

String.prototype.toLocaleUpperCase()
====================================

O método `toLocaleUpperCase()` retorna o valor da string em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.

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

Sintaxe
-------
```

str.toLocaleUpperCase()
str.toLocaleUpperCase(locale)
str.toLocaleUpperCase([locale, locale, ...])
```

### Parâmetros

`locale`

Opcional. O parâmetro `locale` indica a localização a ser usada para converter para maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se vários locais forem fornecidos em um `Array`, a melhor localidade disponível é usada. A localidade padrão é a localidade atual do ambiente do host.

### Valor retornado

Uma nova string que representa a string original convertida em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.

### Exceções

* Um `RangeError` (en-US) ("invalid language tag: xx\_yy") é lançado se um argumento `locale` não for uma tag de idioma válido.
* Um `TypeError` ("invalid element in locales argument") é lançado se um elemento do array não for do tipo string.
Descrição
---------

O método `toLocaleUpperCase()` retorna o valor da string convertida em maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. `toLocaleUpperCase()` não afeta o valor da string em si. Na maioria dos casos, ele produzirá o mesmo resultado que `toUpperCase()`, mas para alguns locais, como turco, cujos mapeamentos de caixa de texto não seguem o mapeamento de caixa de texto padrão em Unicode, pode haver um resultado diferente.

 Observe também que a conversão não é necessariamente um mapeamento de caracteres 1:1, pois alguns caracteres podem resultar em dois (ou até mais) caracteres quando transformados em maiúsculas. Portanto, o comprimento da string resultante pode ser diferente do comprimento da string de entrada. Isso também implica que a conversão não é estável, então, por exemplo, o seguinte pode retornar `false`:
 `x.toLocaleLowerCase() === x.toLocaleUpperCase(). toLocaleLowerCase()`

Exemplos
--------

### Usando `toLocaleUpperCase()`

```js
"alfabeto".toLocaleUpperCase(); // 'ALFABETO'

"Gesäß".toLocaleUpperCase(); // 'GESÄSS'

"i\u0307".toLocaleUpperCase("lt-LT"); // 'I'

let locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocaleuppercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocaleuppercase |

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

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`


String.prototype.trimStart() - JavaScript

String.prototype.trimStart()
============================

O método `trimStart()` remove espaços do começo de uma *string*. `trimLeft()` é um apelido para este método.

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

Sintaxe
-------
```

str.trimStart();
str.trimLeft();
```

### Valor retornado

Uma nova *string* representando a *string* original sem os espaços no começo (fim à esquerda).

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

Os métodos `trimStart()` / `trimLeft()` retornam a *string* sem os espaços no fim à esquerda. `trimLeft()` ou `trimStart()` não altera o valor da *string* original.

### *Aliasing*

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

```js
String.prototype.trimLeft.name === "trimStart";
```

Polyfill
--------

```js
//https://github.com/FabioVergani/js-Polyfill\_String-trimStart

(function (w) {
  var String = w.String,
    Proto = String.prototype;

  (function (o, p) {
    if (p in o ? (o[p] ? false : true) : true) {
      var r = /^\s+/;
      o[p] =
        o.trimLeft ||
        function () {
          return this.replace(r, "");
        };
    }
  })(Proto, "trimStart");
})(window);

/\*
ES6:
(w=>{
 const String=w.String, Proto=String.prototype;

 ((o,p)=>{
 if(p in o?o[p]?false:true:true){
 const r=/^\s+/;
 o[p]=o.trimLeft||function(){
 return this.replace(r,'')
 }
 }
 })(Proto,'trimStart');

})(window);
\*/
```

Exemplos
--------

### Usando `trimStart()`

O seguinte exemplo mostra uma *string* em caixa baixa `'foo '`:

```js
var str = " foo ";

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

str = str.trimStart();
console.log(str.length); // retorna 5
console.log(str); // retorna 'foo '
```

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

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

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.trimEnd()`