RegExp - JavaScript

RegExp
======

Sumário
-------

O construtor **`RegExp`** cria um objeto de expressão regular para realizar uma correspondência de texto com um padrão.

Para uma introdução à expressões regulares, leia o capítulo de Expressões Regulares no Guia de JavaScript.

Construtor
----------

Notações literais e de construtores são possíveis:
```

/padrão/flags
new RegExp(padrão[, flags])
RegExp(padrão[, flags])
```

### Parâmetros

`padrão`

O texto da expressão regular, ou como em ES5, outro objeto RegExp. Os padrões podem incluir caracteres especiais para correspondencia em um intervalo maior de valores do que uma string literal.

`flags`

Se especificado, `flags`indica os marcadores que podem ser adicionados, ou se um objeto é suficiente para o padrão, os valores de flags serão substituidos por qualquer uma das flags de objetos. O valor de `flags`é uma string contendo qualquer combinação dos seguintes valores:

`g`

corresponder globalmente; acha **todas** as correspondências em vez de parar após achar a primeira

`i`

ignorar maiúsc./minúsc.; Se a *flag `u`* estiver ativa, deve ser utilizado o *Unicode case folding*

`m`

multilinha; trata caracteres de início e fim (^ e $) ao operar sobre múltiplas linhas (ou seja, corresponder o início ou fim de *cada* linha (delimitado por \n ou \r), e não apenas o começo ou fim de toda a string de entrada)

`u`
Experimental

unicode; trata o padrão como uma sequência de código unicode

`y`
Experimental

aderente; corresponde apenas pelo index indicado pela propriedade `lastIndex` dessa expressão regular na string alvo (e não tenta corresponder de qualquer indexes posteriores).

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

Há dois modos de criar um objeto `RegExp`: uma notação literal e um construtor. Para indicar strings, os parâmetros para a notação literal não usam aspas, enquanto os parâmetros para a função do construtor usam. Então, as seguintes expressões criam a mesma expressão regular:

```js
/ab+c/i;
new RegExp("ab+c", "i");
```

A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um *loop*, a expressão regular não será recompilada a cada iteração

O construtor do objeto da expressão regular, por exemplo, `new RegExp('ab+c')`, fornece uma compilação em tempo de execução da expressão regular. Use a função construtora quando você sabe que o padrão da expressão regular será mudado, ou você não sabe o padrão e o está recebendo de outra fonte, como uma entrada do usuário.

Começando com ECMAScript 6, `new RegExp(/ab+c/, 'i')`, deixou de lançar um `TypeError` ("can't supply flags quando constructing one RegExp from another") quando o primeiro argumento é um `RegExp` e o segundo argumento `flags` está presente. Uma nova `RegExp` dos argumentos é criada ao invés disso.

Quando se usa a função construtora, as regras de escapar em uma string (preceder caracteres especiais com \ quando incluídos na string) são necessárias. Por exemplo, as declarações a seguir são equivalentes:

```js
var re = /\w+/;
var re = new RegExp("\\w+");
```

Significado dos caracteres especiais nas expressões regulares
-------------------------------------------------------------

* Classes de Caracteres
* Conjuntos de Caracteres
* Limites
* Agrupamentos e back references
* Quantificadores

| Classes de Caracteres |
| --- |
| Caractere | Significado |
| `.` |
 (O ponto) corresponde um único caracter qualquer *exceto* os
 caracteres de nova linha: `\n`, `\r`,
 `\u2028` ou `\u2029`.

 Note que a flag multilinha `m` não muda o comportamento do
 ponto. Então para corresponder um padrão por múltiplas linhas, o
 conjunto de caracteres `[^]` pode ser usado, que
 corresponderá qualquer caractere, incluindo novas linhas.

 Por exemplo, `/.y/` corresponde "my" e "ay", mas não "yes",
 em "yes make my day".
  |
| `\d` |
 Corresponde um caractere de dígito no alfabeto basic Latin.
 Equivalente `a [0-9]`.

 Por exemplo, `/\d/` ou `/[0-9]/` corresponde "2"
 em "B2 é o número da suíte".
  |
| `\D` |
 Corresponde qualquer caractere que não é um dígito no alfabeto basic
 Latin. Equivalente a `[^0-9]`.

 Por exemplo, `/\D/` ou `/[^0-9]/` corresponde
 "B" em "B2 é o suite number".
  |
| `\w` |
 Corresponde qualquer caractere alfanumérico do alfabeto basic Latin,
 incluindo o underline. Equivalente a `[A-Za-z0-9_]`.

 Por exemplo, `/\w/` corresponde "a" em "apple", "5" em
 "$5.28", e "3" em "3D".
  |
| `\W` |
 Corresponde qualquer caractere que não é um alfanumérico do alfabeto
 basic Latin. Equivalente a `[^A-Za-z0-9_]`.

 Por exemplo, `/\W/` ou
 `/[^A-Za-z0-9_]/` corresponde "%" em "50%".
  |
| `\s` |
 Corresponde um único caractere de espaço em branco, incluindo espaço,
 tabulação (tab), quebra de página, nova linha (LF) e outros espaços
 Unicode. Equivalente a
 `[
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

Por exemplo, `/\s\w*/` corresponde " bar" em "foo bar". |
| `\S` |
 Corresponde um único caractere que não seja um espaço em branco.
 Equivalente a
 `[^
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

Por exemplo, `/\S\w*/` corresponde "foo" em "foo bar". |
| `\t` | Corresponde uma tabulação. |
| `\r` | Corresponde uma quebra de linha. |
| `\n` | Corresponde uma nova linha. |
| `\v` | Corresponde uma tabulação vertical. |
| `\f` | Corresponde uma quebra de página. |
| `[\b]` | Corresponde um caracter backspace. (Não confundir com `\b`) |
| `\0` | Corresponde um caractere NUL. Não coloque outro dígito seguinte a esse. |
| `\c*X*` |
 Onde `*X*` é uma letra de A - Z. Corresponde um
 caractere de controle em uma string.

Por exemplo, `/\cM/` corresponde control-M em uma string. |
| `\x*hh*` |
 Corresponde o caractere com o código `*hh*` (dois
 dígitos hexadecimais).
  |
| `\u*hhhh*` |
 Corresponde o caractere com o valor Unicode
 `*hhhh*` (quatro dígitos hexadecimais).
  |
| `\` |
 Para caracteres que são geralmente tratados literalmente, indica que o
 próximo caractere é especial e não deve ser interpretado literalmente.

 Por exemplo, `/b/` corresponde o caractere "b". Colocando
 uma barra invertida antes do "b", ou seja, usando `/\b/`, o
 caractere se torna especial, significando corresponder o limite de uma
 palavra.

*ou*

 Para caracteres que são geralmente tratados especialmente, indica que
 o próximo caractere não é especial e deve ser interpretado
 literalmente.

 Por exemplo, "\*" é um caractere especial que significa 0 ou mais
 ocorrências do caractere precedente devem ser correspondidas; por
 exemplo, `/a*/` significa corresponder 0 ou mais "a"s. Para
 corresponder `*` literalmente, preceda-o com uma barra
 invertida; por exemplo, `/a\*/` corresponde "a\*".
  |
| Conjuntos de Caracteres |
| --- |
| Caractere | Significado |
| `[xyz]` |
 Um conjunto de caracteres. Corresponde qualquer um dos caracteres
 cercados. Você pode especificar uma extensão de caracteres usando um
 hífen.

 Por exemplo, `[abcd]` é o mesmo que `[a-d]`.
 Eles correspondem o "b" em "banco" e o "c" em "cortar".
  |
| `[^xyz]` |
 Um conjunto de caracteres negativo ou complementado. Isto é,
 corresponde qualquer coisa que não esteja cercada nos colchetes. Você
 pode especificar uma extensão de caracteres usando um hífen.

 Por exemplo, `[^abc]` é o mesmo que `[^a-c]`.
 Eles inicialmente correspondem "n" em "banco" e "o" em "cortar".
  |
| Limites |
| --- |
| Caractere | Significado |
| `^` |
 Corresponde o início de uma entrada. Se a flag multilinha é utilizada,
 também corresponde imediatamente após um caractere de quebra de linha.

 Por exemplo, `/^A/` não corresponde o "A" em "an A", mas
 corresponde o primeiro "A" em "An A".
  |
| `$` |
 Corresponde o fim de uma entrada. Se a flag multilinha é utilizada,
 também corresponde imediatamente antes de um caractere de quebra de
 linha.

 Por exemplo, `/o$/` não corresponde o "o" em "cantor", mas
 corresponde em "canto".
  |
| `\b` |
 Corresponde um limite de palavra de largura zero, como entre uma letra
 e um espaço. (Não confundir com `[\b]`)

 Por exemplo, `/\bno/` corresponde o "no" em "de noite";
 `/ly\b/` corresponde o "ly" em "possibly yesterday".
  |
| `\B` |
 Corresponde um limite de uma não palavra de largura zero, como entre
 duas letras ou entre dois espaços.

 Por exemplo, `/\Bte/` corresponde "te" em "de noite", e
 `/on\B/` corresponde "on" em "possivelmente ontem".
  |
| Agrupamentos e back references |
| --- |
| Caractere | Significado |
| `(*x*)` |
 Corresponde `*x*` e memoriza a correspondência.
 Esses são chamados parênteses de captura.

 Por exemplo, `/(foo)/` corresponde e memoriza "foo" em "foo
 bar". A substring correspondida pode ser chamada novamente dos
 elementos do array resultante `[1], ..., [n]` ou das
 propriedades predefinidas do objeto `RegExp`
`$1, ..., $9`.

 Grupos de captura têm uma falta na performance. Se você não necessita
 que a substring correspondida seja chamada novamente, prefira
 parênteses de não-captura (veja mais abaixo).
  |
| `\*n*` |
 Onde `*n*` é um inteiro positivo. A back reference
 to o last substring matching o n parenthetical no expressão regular
 (counting left parentheses).

 Por exemplo, `/apple(,)\sorange\1/` corresponde "apple,
 orange," em "apple, orange, cherry, peach". Um exemplo mais completo
 está a seguir nesta tabela.
  |
| `(?:*x*)` |
 Corresponde `*x*` mas não memoriza a correspondência.
 Esses são chamados parênteses de não-captura. A substring correspondida
 não pode ser chamada novamente dos elementos do array resultante
 `[1], ..., [n]` ou das propriedades predefinidas do objeto
 `RegExp` `$1, ..., $9`.
  |
| Quantificadores |
| --- |
| Caractere | Significado |
| `*x**` | Corresponde o item precedente *x* zero ou mais vezes.

 Por exemplo, `/assusto*/` corresponde "assustoooo" em "Um
 fantasma assustoooou" e "assust" em "Não me assustei", mas nada em "Um
 bode grunhiu".

 Note que no caso acima, o único caractere a ser selecionado é "o",
 pois ele é o caractere imediatamente anterior ao asterisco e não há
 qualquer operador de agrupamento que indique que mais caracteres
 deveriam ser submetidos à repetição. Se quiséssemos selecionar a
 ocorrência sequencial da palavra completa "blah", por exemplo,
 poderíamos utilizar algum agrupamento como `/(blah)*/` o
 que geraria a seleção de "blahblahblah" na frase "blahblahblah ração
 para gatos" ou de "blah" na frase "algoritmo blahut-arimoto".
  |
| `*x*+` |
 Corresponde o item precedente *x* uma ou mais vezes.
 Equivalente a `{1,}`.

 Por exemplo, `/a+/` corresponde o "o" em "doce" e todos os
 "o"s em "doooooooce".
  |
| `*x*?` | Corresponde o item precedente *x* nenhuma ou uma vez.

 Por exemplo, `/e?le?/` corresponde o "el" em "angel" e o
 "le" em "angle."

 If used imediatamente after qualquer dos quantifiers `*`,
 `+`, `?`, ou `{}`, makes o quantifier
 non-greedy (matching o minimum number of vezes), como opposed to o
 default, which é greedy (matching o maximum number of vezes).

 Also used em lookahead assertions, described under `(?=)`,
 `(?!)`, e `(?:)` em this table.
  |
| `*x*(?=*y*)` |
 Corresponde `*x*` apenas se `*x*` é
 seguido por `*y*`. Por exemplo, `/Jack(?=Sprat)/` corresponde "Jack" apenas
 se for seguido por "Sprat".
 `/Jack(?=Sprat|Frost)/` corresponde "Jack" apenas se for
 seguido por "Sprat" ou "Frost". Porém, nem "Sprat" nem "Frost" são
 partes do resultado da correspondência.
  |
| `*x*(?!*y*)` |
 Corresponde `*x*` apenas se
 `*x*` não é seguido por `*y*`. Por exemplo, `/\d+(?!\.)/` corresponde um número apenas
 se não for seguido por um ponto.

`/\d+(?!\.)/.exec('3.141')` corresponde "141", mas não
 "3.141".
  |
| `*x*|*y*` | Corresponde `*x*`ou `*y*`*.*

 Por exemplo, `/verde|vermelha/` corresponde "verde" em
 "maçã verde" e "vermelha" em "maçã vermelha".

 Entretanto, a primeira expressão tem preferência. Se uma string fosse
 corresponder às duas expressões, ela vai corresponder à que aparece do
 lado esquerdo do operador `|`. Por exemplo,
 `/maçãs|maçã/` corresponde "maçãs" na frase "*maçãs*
 vermelhas" e "maçã" na frase "*maçã* verde".
  |
| `*x*{*n*}` |
 Onde `*n*` é um número inteiro positivo. Corresponde
 exatamente `*n*` ocorrências do item precedente
 *x*.

 Por exemplo, `/o{2}/` não corresponde o "o" em
 "brigadeiro", mas corresponde todos os dois "o"s em
 "brigadeir*oo*", e o dois primeiros "o"s em
 "brigadeir*oo*o".
  |
| `*x*{*n*,}` |
 Onde `*n*` é um número inteiro positivo. Corresponde
 *pelo menos* `*n*` ocorrências do item
 precedente *x* (sem que haja um limite superior).

 Por exemplo, `/o{2,}/` não corresponde o "o" em
 "brigadeiro", mas corresponde todos os "o"s em "brigadeir*oo*" e
 em "brigadeir*ooooooooo*".
  |
| `*x*{*n*,*m*}` |
 Onde `*n*` e `*m*` são números
 inteiros positivos. Corresponde pelo menos `*n*` e
 no máximo `*m*` ocorrências do item precedente
 *x*.

 Por exemplo, `/o{2,4}/` corresponde nada em "brigadeiro",
 os dois "o"s em "brigadeir*oo*", os três "o"s em
 "brigadeir*ooo*", e os primeiros quatro "o"s em
 "brigadeir*oooo*o".

 É importante perceber que no último caso a correspondência não inclui
 o último "o" de "brigadeirooooo". Isso se deve ao fato do operador
 quantificador ter definido o número máximo de ocorrências como 4,
 ignorando a quinta repetição do caractere.
  |
| `*x**?``*x*+?*x??**x{n,}?**x{n,m}?*` |
**Operadores *non-greedy* ou *lazy* (não-gulosos ou
preguiçosos)**Esses operadores com a `?` no final, operam de
 maneira semelhante aos seus análogos sem `?` mostrados
 acima, correspondendo múltiplas ocorrências do item precedente
 *x.* Entretanto, desta vez a ocorrência selecionada será a
 mínima possível.

 No exemplo `/(blah)*?/`, diante da frase "blahblahblah
 ração para gatos", nada seria selecionado, pois a ocorrência mínima
 aceita pelo operador `*?` seria ocorrência de 0 (zero)
 vezes da *string* "blah", o que resulta no nada.

 Já a expressão regular `/(blah)+?/`, diante da mesma frase,
 corresponderia a "blah", que é a ocorrência mínima aceita pelo
 operador `+?`*,* ou seja, 1 (uma) repetição da
 sequência "blah".

 Em outro exemplo com mais aplicação prática, digamos que se quer
 corresponder todos os termos que ficam entre aspas em um texto. Se
 fizéssemos simplesmente a *regex* `/".*"/`, diante
 de um texto com múltiplas ocorrências de termos entre aspas, como:
 *'Eu "gosto" muito de "estudar" regex'*, a nossa expressão
 regular seria gulosa e selecionaria o maior texto possível que
 correspondesse à definição, nesse caso, selecionando '*"gosto" muito de "estudar"*', pois todo esse texto está compreendido entre a primeira aspa
 (antes de *'gosto'*) e a última aspa (após *'estudar'*),
 o que é um resultado talvez indesejado.Se usarmos a regex
 `/".*?"/`, com o operador não-guloso, as correspondências
 para a mesma frase seriam '*"gosto"*' e '*"estudar"*'
 separadamente, conforme era a intenção inicial.
  |

Propriedades
------------

`RegExp.prototype` (en-US)

Permite a adição de propriedades a todos os objetos.

`RegExp.length`

O valor of `RegExp.length` é 2.

Métodos
-------

O objeto global `RegExp não possui métodos próprios, no entanto, herda alguns métodos através da cadeia de prototype.`

Objetos e instancias
--------------------

### Propriedades

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Properties')}}### Métodos

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Methods')}}Exemplos
--------

### Exemplo: Usando uma expressão regular para mudar o fomato dos dados

O seguinte script usa o método `replace()` da instância de `String` para casar o nome no format *nome sobrenome* e produzir no formato *sobrenome, nome*. No texto substituto, o script usa `$1` e `$2` para indicar os respectivos parênteses de casamento no padrão da expressão regular.

```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
```

Isto retornará "Smith, John".

### Exemplo: Usando expressões regulares para quebrar linhas com diferentes **fins de linha**/**quebras de linha**

O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(*split*) de linha fornecida neste exemplo funciona com todas as plataformas.

```js
var text = "Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim";
var lines = text.split(/\r\n|\r|\n/);
console.log(lines); // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ]
```

Note que a ordem dos padrões na expressão regular importa.

### Exemplo: Usando expressão regular sobre múltiplas linhas

```js
var s = "Please yes\nmake my day!";
s.match(/yes.\*day/);
// Retorna null
s.match(/yes[^]\*day/);
// Retorna'yes\nmake my day'
```

### Exemplo: Using a expressão regular com o "sticky" flag

Este exemplo mostra como utilizar a sticky flag em expressões regulares.

```js
var text = "First line\nSecond line";
var regex = /(\S+) line\n?/y;

var match = regex.exec(text);
console.log(match[1]); // prints 'First'
console.log(regex.lastIndex); // prints '11'

var match2 = regex.exec(text);
console.log(match2[1]); // prints 'Second'
console.log(regex.lastIndex); // prints '22'

var match3 = regex.exec(text);
console.log(match3 === null); // prints 'true'
```

One can test at run-time whether o sticky flag é supported, using `try { … } catch { … }`. Para this, either an `eval(…)` expression ou o `RegExp(regex-string, flags-string)` syntax must be used (since o `/regex/flags` notation é processed at compile-time, so throws an exception before o `catch` block é encountered). Por exemplo:

```js
var supports_sticky;
try {
  RegExp("", "y");
  supports_sticky = true;
} catch (e) {
  supports_sticky = false;
}
console.log(supports_sticky); // prints 'true'
```

### Exemplo: Expressão regular e Unicode caracteres

As mentioned above, `\w` ou `\W` only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "\_". To match caracteres from other languages such como Cyrillic ou Hebrew, use `\uhhhh`, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra.

```js
var text = "Образец text на русском языке";
var regex = /[\u0400-\u04FF]+/g;

var match = regex.exec(text);
console.log(match[0]); // prints 'Образец'
console.log(regex.lastIndex); // prints '7'

var match2 = regex.exec(text);
console.log(match2[0]); // prints 'на' [não print 'text']
console.log(regex.lastIndex); // prints '15'

// e assim vai
```

Here's an external resource para getting o complete Unicode block range para different scripts: Regexp-unicode-block.

### Exemplo: Extracting subdomain name from URL

```js
var url = "http://xxx.domain.com";
console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-regular-expression-objects |

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

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

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

* Regular Expressions chapter no JavaScript Guide
* `String.prototype.match()`
* `String.prototype.replace()`


Date - JavaScript

Date
====

Resumo
------

Cria uma instância JavaScript de **`Date`** que representa um único momento no tempo. Objetos Date são baseados no valor de tempo que é o número de milisegundos desde 1º de Janeiro de 1970 (UTC).

Construtor
----------

```js
new Date();
new Date(valor);
new Date(dataString);
new Date(ano, mês, dia, hora, minuto, segundo, milissegundo);
```

**Nota:** Note que objetos JavaScript `Date` só podem ser instanciados chamando JavaScript `Date` como um construtor: chamá-lo como uma função regular (ou seja, sem o operador new) irá retornar uma string ao invés de um objeto `Date`; ao contrário de outros tipos de objetos JavaScript, objetos JavaScript `Date` não têm sintaxe literal.

### Parâmetros para o constructor Date

Nota: Quando Date for chamado como um construtor com mais de um argumento, se os valores forem maiores do que seu limite lógico (e.g. se 13 for fornecido como um valor para mês ou 70 for o valor para minuto), o valor adjacente será ajustado. E.g. new Date(2013, 13, 1) é equivalente a new Date(2014, 1, 1), ambos criam uma data para 2014-02-01 (note que o mês começa em 0). Similarmente para outros valores: new Date(2013, 2, 1, 0, 70) é equivalente a new Date(2013, 2, 1, 1, 10), pois ambos criam uma data para 2013-03-01T01:10:00.

*`value`*

Um valor inteiro representando o número de milisegundos desde 1 de Janeiro de 1970 00:00:00 UTC (Era Unix ou Marco Zero).

*`dataString`*

Um valor do tipo String que representa uma data. A string deverá estar uma formato reconhecido pelo método `Date.parse()` (IETF-compliant RFC 2822 timestamps e também uma versão da ISO8601).

*`year`*

Um valor inteiro que representa o ano. Valores de 0 a 99 correspondem aos anos de 1900 a 1999. Veja o exemplo abaixo.

*`month`*

Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.

*`day`*

Um valor inteiro que representa o dia do mês.

*`hour`*

Um valor inteiro que representa a hora do dia.

*`minute`*

Um valor inteiro que representa o segmento de um minuto de tempo.

*`second`*

Um valor inteiro que representa o segmento de segundo do tempo.

*`millisecond`*

Um valor inteiro que representa o segmento de milisegundo do tempo.

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

* Se nenhum argumento for fornecido, o construtor criará um objeto JavaScript Date com a data e hora corrente de acordo com as configurações do sistema.
* Se ao menos 2 argumentos forem fornecidos, os argumentos ausentes serão configurados como 1 (se o dia estiver ausente) ou 0 para todos os outros.
* A data do JavaScript é baseada no valor de tempo em milisegundos desde a meia noite de 01 de Janeiro de 1970, UTC. Um dia corresponde a 86.400,000 milisegundos. O intervalo do objeto Date no JavaScript é de -100.000,000 dias a 100.000,000 dias relativo a 01 de Janeiro de 1970, UTC.
* O objeto Date no JavaScript tem um comportamento uniforme nas plataformas. O valor do tempo pode ser transmitido entre sistemas para representar o mesmo instante no tempo e se for usado para criar um objeto de data local, ele refletirá o tempo local equivalente.
* O objeto Date JavaScript suporta vários métodos UTC (universal), assim como métodos de tempo locais. UTC, também conhecido como Tempo Médio de Greenwich (Greenwich Mean Time, GMT), refere-se ao tempo como definido pelo Padrão de Tempo Mundial (World Time Standard). O tempo local é o tempo conhecido pelo computador onde o JavaScript é executado.
* Invocar o objeto Date no JavaScript como uma função (i.e., sem o operador new) retornatá uma string representando a data e hora corrente.
Propriedades
------------

`Date.prototype` (en-US)

Permite adicionar propriedades a um objeto javaScript Date.

Date.length

O valor de `Date.length` é 7. Esse é o número de argumentos manipulados pelo construtor.

Métodos
-------

`Date.now()`

Retorna o valor numérico correspondente ao tempo corrente - o número de milisegundos passados desde 1 de Janeiro de 1970 00:00:00 UTC.

`Date.parse()`

Analisa uma string que representa uma data e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00, hora local.

`Date.UTC()`

Aceita os mesmos parâmetros como a forma mais longa do construtor (i.e. 2 até 7) e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00 UTC.

Instâncias JavaScript de `Date`
-------------------------------

Todas as instâncias `Date` são herdadas de `Date.prototype` (en-US). O objeto protótipo do construtor `Date` pode ser modificado para afetar todas as instâncias de `Date`.

### Métodos

{{ page("/pt-BR/docs/JavaScript/Reference/Global\_Objects/Date/prototype", "Methods") }}Exemplos
--------

### Várias formas de se criar um objeto Date

Os seguintes exemplos mostram várias formas de se criar datas em JavaScript:

**Nota:** a conversão de *strings* com o construtor de `Date` (`Date.parse` é equivalente ao contrutor) é fortemente desencorajada devido às inconsistências e diferenças dos navegadores.

```js
var today = new Date();
var birthday = new Date("December 17, 1995 03:24:00");
var birthday = new Date("1995-12-17T03:24:00");
var birthday = new Date(1995, 11, 17);
var birthday = new Date(1995, 11, 17, 3, 24, 0);
```

### Anos com dois dígitos mapeados para 1900 - 1999

Para criar e obter datas entre os anos 0 e 99 os métodos `Date.prototype.setFullYear()` e `Date.prototype.getFullYear()` devem ser usados.

```js
var data = new Date(98, 1); // Dom Fev 01 1998 00:00:00 GMT+0000 (GMT)

// Métodos em desuso, 98 mapeia para 1998 aqui também
data.setYear(98); // Dom Fev 01 1998 00:00:00 GMT+0000 (GMT)

data.setFullYear(98); // Sab Fev 01 0098 00:00:00 GMT+0000 (BST)
```

### Calculando o tempo decorrido

Os seguintes exemplos mostram como determinar o tempo decorrido entre duas datas no JavaScript em milissegundos.

Devido aos tamanhos diferentes dos dias (devido à mudança do horário de verão), meses e dias, expressar o tempo decorrido em unidades maiores que horas, minutos e segundos requer analisar os problemas e deve ser cuidadosamente investigado antes de se tentar utilizar.

```js
// usando objetos Date
var inicio = Date.now();

// o evento para o tempo vai aqui:
facaAlgoPorUmLongoTempo();
var fim = Date.now();
var decorrido = fim - inicio; // tempo decorrido em milisegundos
```

```js
// utilizando métodos embutidos
var inicio = new Date();

// o evento para o tempo vai aqui:
facaAlgoPorUmLongoTempo();
var fim = new Date();
var decorrido = fim.getTime() - inicio.getTime(); // tempo decorrido em milisegundos
```

```js
// para testar uma função e obter o seu retorno
function imprimirTempoDecorrido(fTeste) {
  var nHoraInicial = Date.now(),
    vRetorno = fTeste(),
    nHoraFinal = Date.now();

  alert(
    "Tempo decorrido: " + String(nHoraFinal - nHoraInicial) + " milisegundos",
  );
  return vRetorno;
}

retornoDaSuaFuncao = imprimirTempoDecorrido(suaFuncao);
```

**Nota:** Nota: Em navegadores que suportam a API de Desempenho Web (Web Performance API) com o recurso de tempo de alta resolução, `Performance.now()` pode fornecer medidas de tempo decorrido mais confiáveis e precisas do que `Date.now()`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date-objects |

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

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


escape() - JavaScript

escape()
========

A função obsoleta `escape() retorna uma nova string com` certos caracteres substituídos por sua sequência hexadecial. Use `encodeURI` ou `encodeURIComponent` em seu lugar.Sintaxe
-------
```

escape(str)
```

### Parâmetros

`str`

Uma string para ser codificada.

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

A função **`escape`** é uma propriedade do *global object*. Caracteres especiais são codificados, com a exceção de: `@*_+-./`

O formato hexadecimal de caracteres, que o valor unitário do código é **0xFF or less,** é uma sequência de escape de 2 digitos: %xx. Para caracteres com um código unitário maior, uma sequência de 4 digitos %**u**xxxx é usada.

Exemplos
--------

```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// Caracteres Especiais
escape("@\*\_+-./"); // "@\*\_+-./"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

Veja Também
-----------

* `encodeURI`
* `encodeURIComponent`


Proxy - JavaScript

Proxy
=====

O objeto **Proxy** é usado para definir comportamentos customizados para operações fundamentais (por exemplo, pesquisa de propriedade, atribuição, enumeração, invocação de função, etc.).

Terminologia
------------

handler (en-US)

Objeto marcador que contém *traps*.

traps

Métodos que fornecem acesso à propriedade. Isto é análogo ao conceito de *traps* (armadilhas) em sistemas operacionais

target

Objeto que o proxy virtualiza. É frequentemente utilizado como back-end de armazenamento para o proxy. Os invariantes (semânticas que permanecem inalterados) em relação à não-extensibilidade do objeto ou propriedades não-configuráveis são verificados em relação ao *target*.

Sintaxe
-------
```

var p = new Proxy(target, handler);
```

### Parâmetros

`target`

Um objeto target (pode ser qualquer tipo de objeto, incluindo um array, uma função ou até mesmo outro *Proxy*) a ser envolvido com o `Proxy`.

`handler`

Um objeto cujas propriedades são funções que definem o comportamento do proxy quando uma operação é realizada sobre ele.

Métodos
-------

`Proxy.revocable()` (en-US)

Cria um objeto `Proxy` revogável.

Métodos para manipular objetos
------------------------------

O objeto manipulado é um objeto reservado que contém traps para `Proxy.`

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Proxy/handler', 'Methods') }}Exemplos
--------

### Exemplo básico

Neste exemplo simples, o número `37` é retornado como o valor padrão quando o nome da propriedade não está no objeto. Usa-se o manipulador `get` (en-US).

```js
var handler = {
  get: function (target, name) {
    return name in target ? target[name] : 37;
  },
};

var p = new Proxy({}, handler);
p.a = 1;
p.b = undefined;

console.log(p.a, p.b); // 1, undefined
console.log("c" in p, p.c); // false, 37
```

### Encaminhamento de Proxy

Neste exemplo, estamos usando um objeto JavaScript nativo ao qual nosso proxy irá encaminhar todas as operações que são aplicadas para ele.

```js
var target = {};
var p = new Proxy(target, {});

p.a = 37; // Operação encaminhada para o alvo

console.log(target.a); // 37. A operação foi devidamente encaminhada
```

### Validação

Com um `Proxy`, você pode validar facilmente o valor passado para um objeto. Este exemplo usa o manipulador `set` (en-US).

```js
let validator = {
  set: function (obj, prop, value) {
    if (prop === "age") {
      if (!Number.isInteger(value)) {
        throw new TypeError("The age is not an integer");
      }
      if (value > 200) {
        throw new RangeError("The age seems invalid");
      }
    }

    //O comportamento padrão para armazenar o valor
    obj[prop] = value;

    // Indique o sucesso
    return true;
  },
};

let person = new Proxy({}, validator);

person.age = 100;
console.log(person.age); // 100
person.age = "young"; // Lança uma exceção
person.age = 300; // Lança uma exceção
```

### Construtor de extensão

Um proxy de função poderia facilmente estender um construtor com um novo construtor. Este exemplo usa os manipuladores `construct` (en-US) e `apply`.

```js
function extend(sup, base) {
  var descriptor = Object.getOwnPropertyDescriptor(
    base.prototype,
    "constructor",
  );
  base.prototype = Object.create(sup.prototype);
  var handler = {
    construct: function (target, args) {
      var obj = Object.create(base.prototype);
      this.apply(target, obj, args);
      return obj;
    },
    apply: function (target, that, args) {
      sup.apply(that, args);
      base.apply(that, args);
    },
  };
  var proxy = new Proxy(base, handler);
  descriptor.value = proxy;
  Object.defineProperty(base.prototype, "constructor", descriptor);
  return proxy;
}

var Person = function (name) {
  this.name = name;
};

var Boy = extend(Person, function (name, age) {
  this.age = age;
});

Boy.prototype.sex = "M";

var Peter = new Boy("Peter", 13);
console.log(Peter.sex); // "M"
console.log(Peter.name); // "Peter"
console.log(Peter.age); // 13
```

### DOM manipulação de nós

Às vezes, você deseja alternar o atributo ou o nome da classe de dois elementos diferentes. Veja como usar o manipulador `set` (en-US).

```js
let view = new Proxy(
  {
    selected: null,
  },
  {
    set: function (obj, prop, newval) {
      let oldval = obj[prop];

      if (prop === "selected") {
        if (oldval) {
          oldval.setAttribute("aria-selected", "false");
        }
        if (newval) {
          newval.setAttribute("aria-selected", "true");
        }
      }

      // O comportamento para armazenar o valor padrão
      obj[prop] = newval;

      // Indica o sucesso
      return true;
    },
  },
);

let i1 = (view.selected = document.getElementById("item-1"));
console.log(i1.getAttribute("aria-selected")); // 'true'

let i2 = (view.selected = document.getElementById("item-2"));
console.log(i1.getAttribute("aria-selected")); // 'false'
console.log(i2.getAttribute("aria-selected")); // 'true'
```

### Correção de valor e uma propriedade extra

O objeto de proxy `produtos` avalia o valor passado e converte-o em uma matriz, se necessário. O objeto também suporta uma propriedade adicional chamada `latestBrowser` tanto em getters como em setters.

```js
let products = new Proxy(
  {
    browsers: ["Internet Explorer", "Netscape"],
  },
  {
    get: function (obj, prop) {
      // An extra property
      if (prop === "latestBrowser") {
        return obj.browsers[obj.browsers.length - 1];
      }

      // O comportamento para armazenar o valor padrão
      return obj[prop];
    },
    set: function (obj, prop, value) {
      // An extra property
      if (prop === "latestBrowser") {
        obj.browsers.push(value);
        return true;
      }

      // Converta o valor se não for uma matriz
      if (typeof value === "string") {
        value = [value];
      }

      // O comportamento para armazenar o valor padrão
      obj[prop] = value;

      // Indicate success
      return true;
    },
  },
);

console.log(products.browsers); // ['Internet Explorer', 'Netscape']
products.browsers = "Firefox"; // pass a string (by mistake)
console.log(products.browsers); // ['Firefox'] <- no problem, the value is an array

products.latestBrowser = "Chrome";
console.log(products.browsers); // ['Firefox', 'Chrome']
console.log(products.latestBrowser); // 'Chrome'
```

### Encontrando um item de objeto em uma matriz por propriedade

Esta proxy estende uma matriz com alguns recursos de utilidade. Como você vê, você pode "definir" propriedades flexíveis sem usar `Object.defineProperties`. Este exemplo pode ser adaptado para encontrar uma linha de tabela por sua célula. Nesse caso, o alvo será `table.rows` (en-US)

```js
let products = new Proxy(
  [
    { name: "Firefox", type: "browser" },
    { name: "SeaMonkey", type: "browser" },
    { name: "Thunderbird", type: "mailer" },
  ],
  {
    get: function (obj, prop) {
      // O comportamento para retornar o valor; Prop geralmente é um inteiro
      if (prop in obj) {
        return obj[prop];
      }

      // Obter o número de produtos; Com products.length
      if (prop === "number") {
        return obj.length;
      }

      let result,
        types = {};

      for (let product of obj) {
        if (product.name === prop) {
          result = product;
        }
        if (types[product.type]) {
          types[product.type].push(product);
        } else {
          types[product.type] = [product];
        }
      }

      // Obtém um produto por nome
      if (result) {
        return result;
      }

      // Obtém produtos por tipo
      if (prop in types) {
        return types[prop];
      }

      // Obtém tipos de produto
      if (prop === "types") {
        return Object.keys(types);
      }

      return undefined;
    },
  },
);

console.log(products[0]); // { name: 'Firefox', type: 'browser' }
console.log(products["Firefox"]); // { name: 'Firefox', type: 'browser' }
console.log(products["Chrome"]); // undefined
console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }]
console.log(products.types); // ['browser', 'mailer']
console.log(products.number); // 3
```

### Um exemplo completo de lista de `traps`

Agora, para criar uma lista completa de amostra de `traps`, para fins didáticos, tentaremos propor um objeto *não nativo* que seja particularmente adequado para este tipo de operação: o objeto global `docCookies` criado por a "little framework" publicada na página`document.cookie`.

```js
/\*
 var docCookies = ... get the "docCookies" object here:
 https://developer.mozilla.org/pt-BR/docs/DOM/document.cookie#A\_little\_framework.3A\_a\_complete\_cookies\_reader.2Fwriter\_with\_full\_unicode\_support
\*/

var docCookies = new Proxy(docCookies, {
  get: function (oTarget, sKey) {
    return oTarget[sKey] || oTarget.getItem(sKey) || undefined;
  },
  set: function (oTarget, sKey, vValue) {
    if (sKey in oTarget) {
      return false;
    }
    return oTarget.setItem(sKey, vValue);
  },
  deleteProperty: function (oTarget, sKey) {
    if (sKey in oTarget) {
      return false;
    }
    return oTarget.removeItem(sKey);
  },
  enumerate: function (oTarget, sKey) {
    return oTarget.keys();
  },
  ownKeys: function (oTarget, sKey) {
    return oTarget.keys();
  },
  has: function (oTarget, sKey) {
    return sKey in oTarget || oTarget.hasItem(sKey);
  },
  defineProperty: function (oTarget, sKey, oDesc) {
    if (oDesc && "value" in oDesc) {
      oTarget.setItem(sKey, oDesc.value);
    }
    return oTarget;
  },
  getOwnPropertyDescriptor: function (oTarget, sKey) {
    var vValue = oTarget.getItem(sKey);
    return vValue
      ? {
          value: vValue,
          writable: true,
          enumerable: true,
          configurable: false,
        }
      : undefined;
  },
});

/\* Teste Cookies \*/

console.log((docCookies.my_cookie1 = "First value"));
console.log(docCookies.getItem("my\_cookie1"));

docCookies.setItem("my\_cookie1", "Changed value");
console.log(docCookies.my_cookie1);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-objects |

Navegadores Compatíveis
-----------------------

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

Notas Especificas Gecko
-----------------------

* No momento, `Object.getPrototypeOf(proxy)` retorna incondicionalmente um `Object.getPrototypeOf(target)`, porque a trap ES2015 getPrototypeOf não foi implementada (Erro do Firefox 795904, Erro do Firefox 888969).
* `Array.isArray(proxy)` retorna incondicionalmente um `Array.isArray(target)` (Erro do Firefox 1096753, Erro do Firefox 1111785).
* `Object.prototype.toString.call(proxy)` retorna incondicionalmente `Object.prototype.toString.call(target)`, porque ES2015 Symbol.toStringTag não foi implementado (Erro do Firefox 1114580).
Veja também
-----------

* "Proxies are awesome" Brendan Eich presentation at JSConf (slides)
* ECMAScript Harmony Proxy proposal page e ECMAScript página de semântica de proxy Harmony
* Tutorial em proxies
* SpiderMonkey specific Old Proxy API
* `Object.watch()` É um recurso não padrão, mas foi suportado no Gecko há muito tempo.
`Nota de licença`
-----------------

Alguns conteúdos (texto, exemplos) nesta página foram copiados ou adaptados do ECMAScript wiki que contém à licença de conteúdo CC 2.0 BY-NC-SA.


Object - JavaScript

Object
======

O construtor `Object` cria um wrapper de objeto.

Sintaxe
-------
```

// Object initialiser or literal
{ [ nameValuePair1[, nameValuePair2[, ...nameValuePairN] ] ] }

// Called as a constructor
new Object([value])
```

### Parametros

`nameValuePair1, nameValuePair2, ... nameValuePairN`

Pares de nomes (strings) e valores (qualquer valor) em que o nome é separado do valor por dois pontos.

`value`

Qualquer valor.

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

O construtor `Object` cria um wrapper de objeto para o valor fornecido. Se o valor for `null` ou `undefined`, ele criará e retornará um objeto vazio, caso contrário, retornará um objeto de um Type que corresponde ao dado valor. Se o valor já for um objeto, ele retornará o valor.

Quando chamado em um contexto não-construtor, o `object` se comporta de forma idêntica ao `new Object ()`.

Veja também object initializer / literal syntax.

Propriedades do construtor `Object`
-----------------------------------

`Object.length`

Tem um valor de 1.

`Object.prototype` (en-US)

Permite a adição de propriedades a todos os objetos do tipo Object.

Métodos do construtor `Object`
------------------------------

`Object.assign()`

Copia os valores de todas as propriedades próprias enumeráveis de um ou mais objetos de origem para um objeto de destino.

`Object.create()`

Cria um novo objeto com o objeto e as propriedades do protótipo especificado.

`Object.defineProperty()`

Adiciona a propriedade nomeada descrita por um determinado descritor a um objeto.

`Object.defineProperties()`

Adiciona as propriedades nomeadas descritas pelos descritores fornecidos a um objeto.

`Object.entries()`

Retorna uma matriz contendo todos os pares `[key, value]` das próprias propriedades de string enumeráveis de um determinado objeto.

`Object.freeze()`

Congela um objeto: outro código não pode excluir ou alterar nenhuma propriedade.

`Object.fromEntries()`

Retorna um novo objeto de um iterável de pares de valor-chave (reverso à `Object.entries`).

`Object.getOwnPropertyDescriptor()`

Retorna um descritor de propriedade para uma propriedade nomeada em um objeto.

`Object.getOwnPropertyDescriptors()`

Retorna um objeto contendo todos os descritores de propriedade para um objeto.

`Object.getOwnPropertyNames()`

Retorna uma matriz contendo os nomes de todas as propriedades enumeráveis e não enumeráveis do próprio objeto fornecido.

`Object.getOwnPropertySymbols()`

Retorna uma matriz de todas as propriedades de símbolo encontradas diretamente sobre um determinado objeto.

`Object.getPrototypeOf()`

Retorna o protótipo do objeto especificado.

`Object.is()`

Compara se dois valores são o mesmo valor. Equivale a todos os valores de `NaN` (que diferem da Comparação de Igualdade Abstrata e da Comparação de Igualdade Estrita).

`Object.isExtensible()`

Determina se a extensão de um objeto é permitida.

`Object.isFrozen()`

Determina se um objeto foi congelado.

`Object.isSealed()`

Determina se um objeto está selado.

`Object.keys()`

Retorna uma matriz contendo os nomes de todas as propriedades de string enumeráveis do objeto fornecido.

`Object.preventExtensions()`

Impede qualquer extensão de um objeto.

`Object.seal()`

Impede que outro código exclua propriedades de um objeto.

`Object.setPrototypeOf()`

Define o protótipo (isto é, a propriedade interna `[[Prototype]]`).

`Object.values()`

Retorna uma matriz contendo os valores que correspondem a todas as propriedades de string enumeráveis do próprio objeto.

Instâncias de `Object` e `Object` de protótipo de objeto
--------------------------------------------------------

Todos os objetos em JavaScript são descendentes do `Object`; todos os objetos herdam métodos e propriedades de `Object.prototype` (en-US), embora eles possam ser substituídos. Por exemplo, protótipos de outros construtores substituem a propriedade `constructor` e fornecer seus próprios métodos `toString()`. As alterações no objeto de protótipo `Object` são propagadas para todos os objetos, a menos que as propriedades e os métodos sujeitos a essas alterações sejam substituídos na cadeia de protótipos.

### Propriedades (enUS)

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Object/prototype', 'Properties')}}### Métodos (enUS)

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Object/prototype', 'Methods')}}Excluindo uma propriedade de um objeto
--------------------------------------

Não há nenhum método em um Objeto para excluir suas próprias propriedades (por exemplo, como `Map.prototype.delete()`). Para isso, é necessário usar o operador delete.

Exemplos
--------

### Usando `Object` com tipos `undefined` e `null`

Os exemplos a seguir armazenam um `Object` vazio na variável "`o`":

```js
var o = new Object();
```

```js
var o = new Object(undefined);
```

```js
var o = new Object(null);
```

### Using `Object` to create `Boolean` objects

Os exemplos a seguir armazenam objetos `Boolean` na variável "`o`":

```js
// equivalent to o = new Boolean(true);
var o = new Object(true);
```

```js
// equivalent to o = new Boolean(false);
var o = new Object(Boolean());
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object-objects |

Compatibilidade
---------------

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

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

* Object initializer


Reflect - JavaScript

Reflect
=======

**Reflect** é um objeto nativo que provê métodos para operações JavaScript interceptáveis. Os métodos são os mesmos que o dos manipuladores de Proxy. `Reflect` não é um objeto de função, então não é construtível.

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

Ao contrário da maioria dos objetos globais, `Reflect` não é um construtor. Você não pode usá-lo com o operador new ou invocar o objeto `Reflect` como uma função. Todas as propriedades e métodos do `Reflect` são estáticos (igual o objeto `Math`).

O objeto `Reflect` provê as seguintes funções estáticas as quais tem os mesmos nomes usados pelos métodos manipuladores de Proxy.

Alguns deste métodos são também os mesmos correspondentes aos métodos em `Object`, embora eles tenham diferenças sutis entre eles.

Métodos
-------

`Reflect.apply(target, thisArgument, argumentsList)`

Chama uma função de destino com os argumentos, conforme especificado pelo parâmetro *`argumentsList`*. Veja também `Function.prototype.apply()`.

`Reflect.construct(target, argumentsList[, newTarget])`

O operador new como uma função. Equivalente a chamada `new target(...args)`. Também possui a opção de especificar um `prototype` diferente

`Reflect.defineProperty(target, propertyKey, attributes)`

Similar ao `Object.defineProperty()`. Retorna um `Boolean` com o valor `true` *se a propriedade foi definida com sucesso*.

`Reflect.deleteProperty(target, propertyKey)` (en-US)

O operador delete (en-US) como uma função. Equivalente a chamada `delete target[name]`.

`Reflect.get()` (en-US), "Reflect.get(*target*, *propertyKey*[, *receiver*])"}}

Uma função que retorna o valor da propriedade. Funciona como obter uma propriedade de um objeto (`target[propertyKey]`) como uma função.

`Reflect.getOwnPropertyDescriptor(target, propertyKey)` (en-US)

Similar ao `Object.getOwnPropertyDescriptor()`. Retorna um descritor de propriedade da propriedade dada se existir no objeto, `undefined` caso contrário.

`Reflect.getPrototypeOf(target)` (en-US)

Igual ao `Object.getPrototypeOf()`.

`Reflect.has(target, propertyKey)` (en-US)

O operador in como função. Retorna um `Boolean` indicando se existe uma propriedade própria ou herdada.

`Reflect.isExtensible(target)` (en-US)

Igual ao `Object.isExtensible()`. Retorna um `Boolean` com o valor `true` se o destino (parâmetro target) for extensível.

`Reflect.ownKeys(target)` (en-US)

Retorna uma matriz das chaves de propriedade do próprio objeto de destino (não herdadas).

`Reflect.preventExtensions(target)` (en-US)

Similar ao `Object.preventExtensions()`. Retorna um `Boolean` com o valor `true` se a atualização foi bem sucedida.

`Reflect.set(target, propertyKey, value[, receiver])`

Uma função que atribui valores a propriedades. Retorna um `Boolean` com o valor `true` se a atualização foi bem sucedida.

`Reflect.setPrototypeOf(target, prototype)` (en-US)

Uma função que define o protótipo de um objeto (en-US). Retorna um `Boolean` com o valor `true` se a atualização foi bem sucedida.

Exemplos
--------

### Verificando se um objeto contém determinadas propriedades

```js
const duck = {
  name: "Maurice",
  color: "white",
  greeting: function () {
    console.log(`Quaaaack! My name is ${this.name}`);
  },
};

Reflect.has(duck, "color");
// true
Reflect.has(duck, "haircut");
// false
```

### Retornando as próprias chaves do objeto

```js
Reflect.ownKeys(duck);
// [ "name", "color", "greeting" ]
```

### Adicionando uma nova propriedade ao objeto

```js
Reflect.set(duck, "eyes", "black");
// returns "true" if successful
// "duck" now contains the property "eyes: 'black'"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect-object |

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

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

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

* The `Proxy` global object.
* The `handler` (en-US) object.


eval() - JavaScript

eval()
======

Resumo
------

A função **`eval()`** computa um código JavaScript representado como uma string.

Sintaxe
-------

```js
eval(string);
```

### Parâmetros

`string`

Uma sequência de caracteres que representa uma expressão JavaScript, declaração, ou sequência de declarações. A expressão pode incluir variáveis e propriedades de objetos existentes.

### Retorno

É o valor computado do código passado para a função. Se o valor estiver vazio, retornará `undefined`.

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

`eval() é uma função de propriedade do objeto global (window)`.

O argumento da função `eval()` é uma string. Se a string representa uma expressão, `eval()` avalia a expressão. Se o argumento representa uma ou mais declarações em JavaScript, `eval()` avalia as declarações. Não chame o `eval()` para avaliar uma expressão aritmética; JavaScript avalia expressões aritméticas automaticamente.

Se você construir uma expressão aritmética como uma string, você pode usar `eval()` para calcular o resultado depois. Por exemplo, suponha que você tenha uma variável x. Você pode adiar a avaliação de uma expressão envolvendo x atribuindo o valor de string da expressão, dizer `"3 * x + 2"`, a uma variável, e, em seguida, chamando `eval()` em um ponto posterior no seu script.

Se o argumento de `eval()` não é uma string, `eval()` retorna o argumento inalterado. No exemplo a seguir, o construtor `String` é especificado, e `eval()` retorna um objeto `String` em vez de avaliar a string.

```js
eval(new String("2 + 2")); // retorna um objeto String contendo "2 + 2"
eval("2 + 2"); // retorna 4
```

Você pode contornar esta limitação de forma genérica usando `toString()`.

```js
var expression = new String("2 + 2");
eval(expression.toString()); // retorna 4
```

Se você usar a função `eval` *indiretamente*, invocando-a por outra referência além de `eval`, a partir do ECMAScript 5 funciona no escopo global ao invés do escopo local. Significa que, por exemplo, aquelas declarações de funções criam funções globais e que o código que está sendo avaliado não tem acesso às variáveis locais dentro do escopo onde está sendo chamada.

```js
function test() {
  var x = 2,
    y = 4;
  console.log(eval("x + y")); // Chamada direta, usa o escopo local, resulta em 6
  var geval = eval; // equivalente a chamar eval no escopo global
  console.log(geval("x + y")); // Chamada indireta, usa o escopo global, lança uma exceção ReferenceError porque `x` não foi declarado
  (0, eval)("x + y"); // outro exemplo de chamada indireta
}
```

Nunca use `eval`!
-----------------

`eval()` é uma função perigosa, que executa o código passado com os privilégios do caller. Se você executar o `eval()` com uma sequência de caracteres que podem ser afetados por uma parte maliciosa, você pode acabar executando código malicioso na máquina do usuário com as permissões da sua página/extensão. Mais importante ainda, o código de terceiros pode ver o escopo em que `eval()` foi chamado, o que pode levar a possíveis ataques como `Function` não é suscetível.

`eval()` é geralmente mais lento do que as alternativas, uma vez que tem de invocar o interpretador JS, enquanto muitos outros construtores são otimizados por *engines* de JS modernos.

Os interpretadores modernos convertem javascript em código de máquina. Resumindo, o nome das variáveis será desmanchado. Portanto, o uso de `eval` forçará o navegador a fazer buscas caras para descobrir o endereço e seu valor no código de máquina. Além disso, novos valores podem ser introduzidos em `eval` como mudanças no tipo da variável, fazendo o navegador recalcular todo o código de máquina gerado anteriormente. Felizmente, existem alternativas mais seguras (e rápidas) ao `eval()` para usos comuns.

### Acessando propriedades dos membros

Você não deve utilizar `eval()` para converter nomes de propriedades em propriedades. Considere o seguinte exemplo onde as propriedades do objeto a ser acessado não são conhecidas até o código ser executado. Isso pode ser feito com eval:

```js
var obj = { a: 20, b: 30 };
var propname = getPropName(); //retorna "a" ou "b"

eval("var result = obj." + propname);
```

No entanto, `eval()` não é necessário aqui. De fato, sua utilização não é recomendada. Ao invés disso, utilize os operadores de acesso (en-US), que são mais rápidos e seguros:

```js
var obj = { a: 20, b: 30 };
var propname = getPropName(); //retorna "a" ou "b"
var result = obj[propname]; // obj[ "a" ] é o mesmo como obj.a
```

### Utilize funções ao invés de avaliar snippets de código

JavaScript possui first-class functions, o que significa que você pode passar os argumentos para outras APIs, armazená-los em variáveis e propriedades de objeto, e assim por diante. Muitas APIs de DOM foram desenvolvidas com isso em mente, então você pode (e deve) escrever:

```js
// ao invés de setTimeout(" ... ", 1000) use:
setTimeout(function() { ... }, 1000);

// ao invés de elt.setAttribute("onclick", "...") use:
elt.addEventListener("click", function() { ... } , false);
```

Closures são úteis como forma de criar funcções parametrizáveis sem concatenar strings.

### Analisando JSON (convertendo string para objetos JavaScript)

Se a string para a qual você está chamando o `eval()` contém dados (por exemplo, um array: `"[1, 2, 3]"`), ao invés de código, você deve considerar mudar para JSON, que permite a string usar um subconjunto de sintaxe Javascript para representar dados. Veja também Downloading JSON and JavaScript in extensions.

Perceba que como a sintaxe JSON é limitada comparada com a sintaxe JavaScript, muitos literais JavaScript válidos não serão analisados como JSON. Por exemplo, trailing commas não são permitidas em JSON, e nomes de propriedades (keys) em literais de objetos devem ser colocados entre aspas. Certifique-se de usar um serializados JSON para gerar strings que serão analisadas como JSON mais tarde.

### Passar dados em vez de códigos

Por exemplo, uma extensão concebida para raspar conteúdos de páginas web pode ter as regras de raspagem definidas no XPath (en-US) em vez de código JavaScript.

### Rodando o código com privilégios limitados

Se você precisa executar o código, considere executá-lo com privilégios limitados. Esse conselho se aplica principalmente para extensões e aplicações XUL, que podem usar Components.utils.evalInSandbox para obter o resultado.

Exemplos
--------

Os exemplos a seguir mostram o retorno do `document.write` (en-US). No JavaScript rodando no server-side, você pode obter o mesmo resultado chamando o método `write()ao invés` de usar o `document.write()`.

### Exemplo: Usando `eval`

No código a seguir, ambas as declarações contendo `eval()` retornam 42. A primeira avalia a string "`x + y + 1`"; a segunda avalia a string "`42`".

```js
var x = 2;
var y = 39;
var z = "42";
eval("x + y + 1"); // returns 42
eval(z); // returns 42
```

### Exemplo: Using `eval` to evaluate a string of JavaScript statements

O exemplo a seguir usa `eval()` para avaliar a string `str`. Essa string consiste de instruções JavaScript que abrem uma caixa de diálogo de alerta e atribuem ao `z` o valor de 42 se `x` for cinco, e do contrário, atribui 0 a `z`. Quando a segunda instrução é executada, `eval()` fará com que essas instruções sejam executadas e também irá avaliar o conjunto de instruções e retornará o valor atribuído a z.

```js
var x = 5;
var str = "if (x == 5) {alert('z is 42'); z = 42;} else z = 0; ";

document.write("<P>z is ", eval(str));
```

### Exemplo: A última expressão é avaliada

`eval()` retorna o valor da última expressão avaliada.

```js
var str = "if ( a ) { 1+1; } else { 1+2; }";
var a = true;
var b = eval(str); // returns 2

alert("b is : " + b);

a = false;
b = eval(str); // returns 3

alert("b is : " + b);
```

### Exemplo: avaliar uma string definindo a função necessária "(" and ")" como prefixo e sufixo

```js
var fctStr1 = "function a() {}";
var fctStr2 = "(function a() {})";
var fct1 = eval(fctStr1); // return undefined
var fct2 = eval(fctStr2); // return a function
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-eval-x |

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

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

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

* `uneval()`
* Member operators (en-US)


Boolean - JavaScript

Boolean
=======

O objeto **`Boolean`** é um objeto wrapper para um valor booleano.

Sintaxe
-------
```

new Boolean([value])
```

### Parâmetros

`value`

Opcional. O valor inicial do objeto `Boolean.`

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

O valor passado como primeiro parâmetro é convertido para um valor boleano, se necessário. Se o valor é omitido ou é `0`, `-0`, `null`, `false`, `NaN`, `undefined` ou é uma string vazia(`""`), o objeto terá um valor inicial de `false`. Todos outros valores, incluindo qualquer objeto ou string `"false"`, criam um objeto com valor inicial `true`.

Não confunda os valores primitivos Boolean `true` e `false` com os valores `true` and `false` do objeto `Boolean`.

Qualquer objeto cujo o valor não é `undefined` ou `null`, incluindo um objeto `Boolean` que o valor seja `false`, é avaliado para `true` quando passa por uma declaração condicional. Por exemplo, a condição a seguir `if` a declaração é avaliada como `true`:

```js
var x = new Boolean(false);
if (x) {
  // esse código é executado
}
```

Esse comportamento não se aplica aos primitivos `Boolean`. Por exemplo, a condição a seguir `if` a declaração é avaliada como `false`:

```js
var x = false;
if (x) {
  // esse código não é executado
}
```

Não use um objeto `Boolean` para converter um valor não-boleano para um valor boleano. Ao invés disso use `Boolean` como uma função para executar essa tarefa:

```js
var x = Boolean(expression); // preferido
var x = new Boolean(expression); // não use
```

Se você especificar qualquer objeto, incluindo um objeto `Boolean` cujo valor é `false`, como valor inicial de um objeto `Boolean`, o novo objeto `Boolean` terá o valor de `true`.

```js
var myFalse = new Boolean(false); // valor inicial false
var g = new Boolean(myFalse); // valor inicial true
var myString = new String("Hello"); // objeto String
var s = new Boolean(myString); // valor inicial true
```

Não use um um objeto `Boolean` no lugar de um primitivo `Boolean`.

Propriedades
------------

`Boolean.length`

Propriedade Length cujo valor é 1.

`Boolean.prototype` (en-US)

Representa o protótipo para o construtor `Boolean`.

Métodos
-------

O objeto global `Boolean` contém métodos próprios, entretanto, ele herda alguns métodos através da cadeia de protótipos:

Instâncias `Boolean`
--------------------

Todas instâncias `Boolean` herdam de `Boolean.prototype` (en-US). Assim como todos os construtores, o protótipo do objeto dita as propriedades e métodos herdados.

### Propriedades

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Boolean/prototype', 'Properties')}}### Métodos

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Boolean/prototype', 'Methods')}}Exemplos
--------

### Criando objetos `Boolean` com um valor inicial `false`

```js
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
```

### Criando objetos `Boolean` com um valor inicial `true`

```js
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");
var bArrayProto = new Boolean([]);
var bObjProto = new Boolean({});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-objects |

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

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

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

* `Boolean.prototype` (en-US)
* Boolean
* Boolean data type (Wikipedia)


parseInt() - JavaScript

parseInt()
==========

Sumário
-------

A função **`parseInt()`** analisa um argumento `string` e retorna um inteiro na `base` especificada.

Sintaxe
-------
```

parseInt(string, base);
```

Parâmetros
----------

`string`

O valor a analisar. Se o argumento `string` não for uma string, então o valor é convertido para uma string (utilizando a operação abstrata `ToString`). Os espaços em branco na `string` são ignorados.

`base`

Um inteiro entre `2` e `36` que representa a *base* da `string` (sistemas numéricos matemáticos) mencionada no parâmetro anterior. Especifique `10` para o sistema numérico decimal comumente usado por humanos. **Sempre especifique este parâmetro** para eliminar confusão do leitor e para garantir o comportamento esperado. Implementações diferentes produzem resultados diferentes quando `base` não é especificado, normalmente assumindo o valor como `10`.

### Valor de retorno

Um número inteiro analisado a partir da string fornecida. Se o primeiro caracter não puder ser convertido para um número, `NaN` é retornado.

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

A função `parseInt` converte seu primeiro argumento para uma string, analisa, e retorna um inteiro ou `NaN`. Se não `NaN`, o valor retornado será a representação decimal inteira do primeiro argumento obtido como um número na base especificada. Por exemplo, uma*base* 10 indica para converter de um número decimal, 8 octal, 16 hexadecimal, e assim por diante. Para bases acima de `10`, as letras do alfabeto indicam numerais maiores que `9`. Por exemplo, para números hexadecimais (base 16), `A` até `F` são usados.

Se `parseInt` encontrar um caracter que não seja um numeral na base especificada, ele o ignora e a todos os caracteres subsequentes e retorna o valor inteiro analisado até aquele ponto. `parseInt` trunca números para valores inteiros. Espaços no início e fim são permitidos.

Se *base* é `undefined` ou 0 (ou ausente), JavaScript assume o seguinte:

* Se a `string` de entrada começa com "0x" ou "0X", a *base* é 16 (hexadecimal) e o restante da string é analisado.
* Se a `string` de entrada começa com "0", a *base* é oito (octal) ou 10 (decimal). Exatamente qual base é escolhida é dependente da implementação. O ECMAScript 5 especifica que 10 (decimal) seja utilizado, mas nem todos os browsers suportam isso ainda. Por essa razão **sempre especifique uma base quando estiver usando `parseInt`**.
* Se a `string` de entrada começa com qualquer outro valor, a base é 10 (decimal).

Se o primeiro caracter não puder ser convertido para um número, `parseInt` retorna `NaN`.

Para propósitos aritméticos, o valor `NaN` não é um número em qualquer base. Você pode chamar a função `isNaN` para determinar se o resultado de `parseInt` é `NaN`. Se `NaN` for passado em operações aritméticas, o resultado da operação também será `NaN`.

Para converter um número para seu literal string em uma base específica use `intValue.toString(base)`.

Exemplos
--------

### Exemplo: Usando `parseInt`

Os seguintes exemplos sempre retornam **`15`**:
```

parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);
```

Os seguintes exemplos sempre retornam **`NaN`**:
```

parseInt("Hello", 8); // Não é realmente um número
parseInt("546", 2);   // Dígitos não são válidos para representações binárias
```

Os seguintes exemplos sempre retornam **`-15`**:
```

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10)
parseInt(" -17", 8);
parseInt(" -15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);
```

O seguinte exemplo retorna **`224`**:
```

parseInt("0e0", 16);
```

Interpretação octal sem informar a base
---------------------------------------

Embora desencorajado pelo ECMAScript 3 e proibido pelo ECMAScript 5, muitas implementações interpretam uma string numérica começando com um `0` como octal. O exemplo abaixo pode ter um resultado octal, ou ele pode ter um resultado decimal. **Sempre especifique uma base para evitar este comportamento não confiável.**
```

parseInt("0e0"); // 0
parseInt("08"); // 0, '8' não é um dígito octal.
```

### O ECMAScript 5 remove a interpretação octal

A especificação ECMAScript 5 da funcão `parseInt` não permite mais que as implementações tratem Strings começando com o caracter 0 como um valor octal. O ECMAScript 5 declara:

A função `parseInt` produz um valor inteiro ditado pela interpretação do conteúdo de uma argumento string de acordo com uma base específicada. Espaços em branco no início da string são ignorados. Se a base for undefined ou `0`, ela é assumida como `10` exceto quando o número começa com os pares de caracter `0x` or `0X`, e neste caso a base 16 é assumida. Se a base é `16`, o número pode também opcionalmente começar com os pares de caracter `0x` or `0X`.

Isto difere do ECMAScript 3, que desencoraja mas permite a interpretação octal.

Muitas implementações não adotaram este comportamento a partir de 2013, e porque browser antigos devem ser suportados, **sempre especifique uma base**.

Uma função de análise mais rigorosa
-----------------------------------

É útil em algum momento ter uma maneira mais rigorosa para analisar valores inteiros. Expressões regulares podem ajudar:

```js
filterInt = function (value) {
  if (/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) return Number(value);
  return NaN;
};

console.log(filterInt("421")); // 421
console.log(filterInt("-421")); // -421
console.log(filterInt("+421")); // 421
console.log(filterInt("Infinity")); // Infinity
console.log(filterInt("421e+0")); // NaN
console.log(filterInt("421hop")); // NaN
console.log(filterInt("hop1.61803398875")); // NaN
console.log(filterInt("1.61803398875")); // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-parseint-string-radix |

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

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

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

* `parseFloat()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`
* `Number.toString()`
* `Object.valueOf`


WeakSet - JavaScript

WeakSet
=======

O objeto **WeakSet** pertmite que você armazene objetos mantidos "fracamente" na coleção.Syntaxe
-------
```

 new WeakSet([iterable]);
```

### Parâmetros

iterable

Se umobjeto interagível é passado, todos os seus elementos serão adicionados ao novo `WeakSet`.

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

Objetos `WeakSet` são coleções de objetos. Um objeto no `WeakSet` pode ocorrer uma vez; é único na coleção do `WeakSet`.

As principais diferenças para o objeto `Set` são:

* Em contraste ao `Sets`, `WeakSets` são **coleções apenas de objetos** e não de valores arbitrários de qualquer tipo.
* O `WeakSet` é *fraco*. Referências aos objetos nas coleções são mantidas "fracamente". Se não há outra referência para um objeto mantido na `WeakSet`, eles pode ser coletados pelo gerenciamento de memória (*garbage collection*).
Propriedades
------------

`WeakSet.length`

O valor da propriedade de comprimento é 0.

`WeakSet.prototype` (en-US)

Representa o protóripo para o construtos `Set`. Permite a adição de propriedades para todos os objetos do `WeakSet`.

`Instâncias WeakSet`
--------------------

Todas as instâncias do `WeakSet` herdam do `WeakSet.prototype` (en-US).

### Propriedades

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/WeakSet/prototype','Properties')}}### Métodos

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/WeakSet/prototype','Methods')}}Exemplos
--------

### Usando o objeto do `WeakSet`

```js
var ws = new WeakSet();
var obj = {};
var foo = {};

ws.add(window);
ws.add(obj);

ws.has(window); // true
ws.has(foo); // false, foo não foi adicionado ao set

ws.delete(window); // remove window do set
ws.has(window); // false, window foi removido
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-objects |

Compatilidade de Browser
------------------------

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

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

* `Map`
* `Set`
* `WeakMap`


Infinity - JavaScript

Infinity
========

Sumário
-------

A propriedade global **`Infinity`** é um valor numérico que representa infinito.

| Property attributes of `Infinity` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Sintaxe
-------
```

Infinity
```

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

`Infinity` é uma propriedade do *objeto global*, ou seja, é uma varíavel no escopo global.

O valor inicial de `Infinity` é `Number.POSITIVE_INFINITY`. O valor `Infinity` (positivo) é maior do que qualquer outro número. Este valor se comporta matematicamente como infinito; por exemplo, qualquer número positivo multiplicado por `Infinity` é `Infinity`, e qualquer coisa dividida por `Infinity` é 0.

Pela especificação ECMAScript 5, `Infinity` é somente leitura (implementado no JavaScript 1.8.5 / Firefox 4).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-infinity |

Compatibilidade
---------------

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

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

* `Number.NEGATIVE_INFINITY`
* `Number.POSITIVE_INFINITY`


Generator - JavaScript

Generator
=========

O objeto **`Generator`** é retornado por generator function e conforme iterable protocol e o iterator protocol.

Síntaxe
-------
```

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
```

Métodos
-------

`Generator.prototype.next()` (en-US)

Retorna o valor fornecido pela expressão `yield`.

`Generator.prototype.return()` (en-US)

Retorna o valor fornecido a finaliza o generator.

`Generator.prototype.throw()` (en-US)

Lança um erro no generator.

Example
-------

### An infinite iterator

```js
function\* idMaker() {
  var index = 0;
  while (true) yield index++;
}

var gen = idMaker(); // "Generator { }"

console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
// ...
```

Objeto legacy generator
-----------------------

Firefox (SpiderMonkey) também implementa a versão anterior do generator em JavaScript 1.7, onde o asterisco (\*) na declaração da função não era necessário (somente era necessário usar a palavra reservada `yield` no corpo da função). Contudo, legacy generators estão obsoletos. Não os use, eles serão removidos (Erro do Firefox 1083482).

### Métodos legacy generator

`Generator.prototype.next()`
Non-standard

Retorna o valor fornecido pela expressão `yield`. Isto corresponde ao `next()` do ES6.

`Generator.prototype.close()`
Non-standard

Fecha o generator, então quando chamar `next()` um erro `StopIteration` será lançado. Isto corresponde ao método `return()` do ES6.

`Generator.prototype.send()`
Non-standard

Usado para enviar um valor para o generator. Este valor é retordo pela expressão `yield`, e retorna o valor fornecido pelo pelo next `yield`. `send(x)` corresponde ao `next(x)` do ES6.

`Generator.prototype.throw()`
Non-standard

Lança um erro no generator. Isto corresponde ao método `throw() do ES6.`

### Exemplo do Legacy generator

```js
function\* fibonacci() {
  var a = yield 1;
  yield a \* 2;
}

var it = fibonacci();
console.log(it); // "Generator { }"
console.log(it.next()); // 1
console.log(it.send(10)); // 20
console.log(it.close()); // undefined
console.log(it.next()); // throws StopIteration (Como o generator está fechado)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-objects |

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

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

Veja Também
-----------

### Legacy generators

* The legacy generator function (en-US)
* The legacy generator function expression (en-US)
* `StopIteration`
* The legacy Iterator protocol (en-US)
### ES6 generators

* Functions
* `function`
* `function expression`
* `Function`
* `function*`
* `function* expression`
* `GeneratorFunction` (en-US)
* The Iterator protocol (en-US)


Math - JavaScript

Math
====

**Math** é um objeto embutido que tem propriedades e métodos para constantes e funções matemáticas. Não é um objeto de função.

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

Ao contrário de outros objetos globais, `Math` não é um construtor. Todas as propriedades e métodos de `Math` são estáticos. Você pode referenciar a constante PI como `Math.PI` e você pode chamar a função de seno como `Math.sin(x)`, onde `x` é o argumento do método. Constantes são definidas com a precisão total de números reais em JavaScript.

Propriedades
------------

`Math.E`

Constante de Euler e base dos logaritmos naturais, aproximadamente 2.718.

`Math.LN2`

Logaritmo natural de 2, aproximadamente 0.693.

`Math.LN10`

Logaritmo natural de 10, aproximadamente 2.303.

`Math.LOG2E`

Logaritmo de E na base 2, aproximadamente 1.443.

`Math.LOG10E`

Logaritmo de E na base 10, aproximadamente 0.434.

`Math.PI`

Relação entre a circunferência de um círculo e o seu diâmetro, aproximadamente 3.14159.

`Math.SQRT1_2`

Raiz quadrada de 1/2; Equivale a 1 dividido pela raiz quadrada de 2, aproximadamente 0.707.

`Math.SQRT2`

Raiz quadrada de 2, aproximadamente 1.414.

Métodos
-------

**Nota:** Note que as funções trigonométricas (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) recebem ou retornam ângulos em radianos. Divida por (`Math.PI/180`) para converter radianos em graus, ou multiplique por esse valor para fazer a conversão inversa.

`Math.abs(x)`

Retorna o módulo, ou valor absoluto, de um número (

|
x
|

|x|

).

`Math.acos(x)`

Retorna o arco-coseno de um número (

arccos
x

\arccos{x}

).

`Math.acosh(x)`
Experimental

Retorna o arco-coseno hiperbólico de um número.

`Math.asin(x)`

Retorna o arco-seno de um número (

arcsin
x

\arcsin{x}

).

`Math.asinh(x)`
Experimental

Retorna o arco-seno hiperbólico de um número.

`Math.atan(x)`

Retorna o arco-tangente de um número (

arctan
x

\arctan{x}

).

`Math.atanh(x)`
Experimental

Retorna o arco-tangente hiperbólico de um número (

arctan
x

\arctan{x}

).

`Math.atan2(x, y)`

Retorna o arco-tangente do quociente de seus argumentos.

`Math.cbrt(x)`
Experimental

Retorna a raiz cúbica de um número (

x
3

\root{3}{x}

).

`Math.ceil(x)`

Retorna o menor inteiro que é maior ou igual a um número.

`Math.cos(x)`

Retorna o coseno de um número (

cos
x

\cos{x}

).

`Math.cosh(x)`
Experimental

Retorna o coseno hiperbólico de um número .

`Math.exp(x)`

Retorna

e
x

e^x

, onde *x* é o argumento, e

e
e

é a constante de Euler (2.718...), a base do logaritmo natural.

`Math.expm1(x)`
Experimental

Retorna

e
x

-
1

e^x-1

.

`Math.floor(x)`

Retorna o maior inteiro que é menor ou igual a um número.

`Math.fround(x)` (en-US)
Experimental

Retorna a mais próxima representação de ponto flutuante de precisão-única de um número.

`Math.hypot([x[,y[,…]]])`
Experimental

Retorna a raiz quadrada da soma dos quadrados dos argumentos (

x
2

+

y
2

+
…

\sqrt{x^2 + y^2 + \dots}

).

`Math.imul(x)` (en-US)
Experimental

Retorna o resultado de uma multiplicação de inteiro de 32-bit.

`Math.log(x)`

Retorna o logaritmo natural (

log
e

x

\log\_ex

ou

ln
x

\ln{x}

) de um número.

`Math.log1p(x)`
Experimental

Retorna o logaritmo natural de 1 + x (

log
e

(
1
+
x
)

\log\_e(1+x)

ou

ln
(
1
+
x
)

\ln(1+x)

) de um número.

`Math.log10(x)`
Experimental

Retorna o logaritmo de x na base 10 (

log
10

x

\log\_{10}x

).

`Math.log2(x)`
Experimental

Retorna o logaritmo de x na base 2 (

log
2

x

\log\_2 x

).

`Math.max([x[,y[,…]]])`

Retorna o maior dentre os parâmetros recebidos.

`Math.min([x[,y[,…]]])`

Retorna o menor dentre os parâmetros recebidos.

`Math.pow(x,y)`

Retorna a base `x` elevada à potência `y` do expoente, ou seja,

x
y

x^y

.

`Math.random()`

Retorna um número pseudo-aleatório entre 0 e 1.

`Math.round(x)`

Retorna o valor arrendodado de `x`, para o valor inteiro mais próximo.

`Math.sign(x)`
Experimental

Retorna o sinal de `x`, indicando se é positivo, negativo ou zero.

`Math.sin(x)`

Retorna o seno de um número (

sin
x

\sin x

).

`Math.sinh(x)`
Experimental

Retorna o seno hiperbólico de um número (

sinh
x

\sinh x

).

`Math.sqrt(x)`

Retorna a raiz quadrada positiva de um número (

x

\sqrt x

).

`Math.tan(x)`

Retorna a tangente de um número (

tan
x

\tan x

).

`Math.tanh(x)`
Experimental

Retorna a tangente hiperbólica de um número (

tanh
x

\tanh x

).

`Math.toSource()`
Non-standard

Retorna a string `"Math"`.

`Math.trunc(x)`
Experimental

Retorna a parte inteira de `x`, removendo quaisquer dígitos fracionários.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math-object |

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

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

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

* `Number`


Int16Array - JavaScript

Int16Array
==========

A matriz do tipo **`Int16Array`** representa uma matriz de inteiros assinados de 16 bits com dois complementos na ordem de bytes da plataforma. Se o controle sobre a ordem de bytes for necessário, use `DataView`. O conteúdo é inicializado em 0. Uma vez estabelecido, você pode fazer referência a elementos na matriz usando os métodos do objeto ou usando a sintaxe de índice da matriz padrão (ou seja, usando a notação de colchetes).

Sintaxe
-------
```

new Int16Array(); // novo no ES2017
new Int16Array(length);
new Int16Array(typedArray);
new Int16Array(object);
new Int16Array(buffer [, byteOffset [, length]]);
```

Para obter mais informações sobre a sintaxe do construtor e os parâmetros, consulte *TypedArray (en-US)*.

Propriedades
------------

`Int16Array.BYTES_PER_ELEMENT` (en-US)

Retorna um valor numérico do tamanho do elemento. `2` no caso de um `Int16Array`.

Int16Array.length

Propriedade de comprimento estático cujo valor é 0. Para o comprimento real (número de elementos), consulte `Int16Array.prototype.length` (en-US).

`Int16Array.name` (en-US)

Retorna o valor da string do nome do construtor. No caso do tipo `Int16Array`: "Int16Array".

`Int16Array.prototype` (en-US)

Protótipo para os objetos TypedArray.

Métodos
-------

`Int16Array.from()` (en-US)

Cria um novo `Int16Array` de um objeto semelhante a uma matriz ou iterável. Veja também `Array.from()`.

`Int16Array.of()` (en-US)

Cria um novo `Int16Array` com um número variável de argumentos. Veja também `Array.of()`.

`Int16Array` prototype
----------------------

Todos `Int16Array` objetos herdam de `%TypedArray%.prototype` (en-US).

### Propriedades

`Int16Array.prototype.constructor`

Retorna a função que criou o protótipo de uma instância. Este é o construtor `Int16Array` por padrão.

`Int16Array.prototype.buffer` (en-US) Somente leitura

Retorna o `ArrayBuffer` referenciado pelo `Int16Array` Fixado em tempo de construção e **apenas leitura**.

`Int16Array.prototype.byteLength` (en-US) Somente leitura

Retorna o tamanho (em bytes) de um `Int16Array` desde o ínicio `ArrayBuffer`. Fixado em tempo de construção e **apenas leitura**.

`Int16Array.prototype.byteOffset` (en-US) Somente leitura

Retorna o deslocamento (em bytes) de um `Int16Array` desde o ínicio `ArrayBuffer`. Fixado em tempo de construção e **apenas leitura**.

`Int16Array.prototype.length` (en-US) Somente leitura

Retorna o número de elementos em um `Int16Array`. Fixado em tempo de construção e **apenas leitura**.

### Métodos

`Int16Array.prototype.copyWithin()` (en-US)

Copia uma sequência de elementos da matriz dentro da matriz. Veja também `Array.prototype.copyWithin()`.

`Int16Array.prototype.entries()` (en-US)

Retorna um novo `Array Iterator` objeto que contém os pares de chave / valor para cada índice na matriz. Veja também `Array.prototype.entries()`.

`Int16Array.prototype.every()` (en-US)

Testa se todos os elementos na matriz passam no teste fornecido por uma função. Veja também `Array.prototype.every()`.

`Int16Array.prototype.fill()` (en-US)

Preenche todos os elementos de uma matriz de um índice inicial para um índice final com um valor estático. Veja também `Array.prototype.fill()`.

`Int16Array.prototype.filter()` (en-US)

Cria uma nova matriz com todos os elementos dessa matriz para os quais a função de filtragem fornecida retorna true. Veja também `Array.prototype.filter()`.

`Int16Array.prototype.find()` (en-US)

Retorna o valor encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou `undefined` se não encontrado. Veja também `Array.prototype.find()`.

`Int16Array.prototype.findIndex()` (en-US)

Retorna o índice encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou -1, se não for encontrado. Veja também `Array.prototype.findIndex()`.

`Int16Array.prototype.forEach()` (en-US)

Chama uma função para cada elemento na matriz. Veja também `Array.prototype.forEach()`.

`Int16Array.prototype.includes()` (en-US)
Experimental

Determina se uma matriz tipificada inclui um determinado elemento, retornando `true` ou `false`. Veja também `Array.prototype.includes()`.

`Int16Array.prototype.indexOf()` (en-US)

Retorna o primeiro (menos) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também `Array.prototype.indexOf()`.

`Int16Array.prototype.join()` (en-US)

Junta todos os elementos de um array em uma string. Veja também `Array.prototype.join()`.

`Int16Array.prototype.keys()` (en-US)

Retorna um novo `Array Iterator` que contém uma chave para cada índice no array. Veja também `Array.prototype.keys()`.

`Int16Array.prototype.lastIndexOf()` (en-US)

Retorna o último (maior) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também `Array.prototype.lastIndexOf()`.

`Int16Array.prototype.map()` (en-US)

Cria uma nova matriz com os resultados da chamada de uma função fornecida em todos os elementos dessa matriz. Veja também `Array.prototype.map()`.

`Int16Array.prototype.move()`
Non-standard
 Unimplemented

Versão não-padrão anterior de `Int16Array.prototype.copyWithin()` (en-US).

`Int16Array.prototype.reduce()` (en-US)

Aplique uma função contra um acumulador e cada valor da matriz (da esquerda para a direita) para reduzi-lo a um único valor. Veja também `Array.prototype.reduce()`.

`Int16Array.prototype.reduceRight()` (en-US)

Aplique uma função contra um acumulador e cada valor da matriz (da direita para a esquerda) para reduzi-lo a um único valor. Veja também `Array.prototype.reduceRight()`.

`Int16Array.prototype.reverse()` (en-US)

Inverte a ordem dos elementos de um array - o primeiro torna-se o último e o último torna-se o primeiro. Veja também `Array.prototype.reverse()`.

`Int16Array.prototype.set()` (en-US)

Armazena vários valores na matriz tipada, lendo valores de entrada de uma matriz especificada.

`Int16Array.prototype.slice()` (en-US)

Extrai uma seção de uma matriz e retorna uma nova matriz. Veja também `Array.prototype.slice()`.

`Int16Array.prototype.some()` (en-US)

Retorna true se pelo menos um elemento nessa matriz satisfizer a função de teste fornecida. Veja também `Array.prototype.some()`.

`Int16Array.prototype.sort()`

Classifica os elementos de uma matriz e retorna a matriz. Veja também `Array.prototype.sort()`.

`Int16Array.prototype.subarray()` (en-US)

Retorna um novo `Int16Array` a partir do índice de elemento inicial e final fornecido.

`Int16Array.prototype.values()` (en-US)

Retorna um novo objeto `Array Iterator` que contém os valores para cada índice na matriz. Veja também `Array.prototype.values()`.

`Int16Array.prototype.toLocaleString()` (en-US)

Retorna uma string localizada representando a matriz e seus elementos. Veja também `Array.prototype.toLocaleString()`.

`Int16Array.prototype.toString()` (en-US)

Retorna uma string representando a matriz e seus elementos. Veja também `Array.prototype.toString()`.

`Int16Array.prototype[@@iterator]()` (en-US)

Retorna um novo objeto `Array Iterator` que contém os valores para cada índice na lista.

Exemplos
--------

Diferentes opções de criar um `Int16Array`:

```js
// De um tamanho
var int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
console.log(int16.length); // 2
console.log(int16.BYTES\_PER\_ELEMENT); // 2

// De uma array
var arr = new Int16Array([21, 31]);
console.log(arr[1]); // 31

// De um outro TypedArray
var x = new Int16Array([21, 31]);
var y = new Int16Array(x);
console.log(y[0]); // 21

// De um ArrayBuffer
var buffer = new ArrayBuffer(8);
var z = new Int16Array(buffer, 0, 4);

// De um interável
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int16 = new Int16Array(iterable);
// Int16Array[1, 2, 3]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

Notas de compatibilidade
------------------------

A partir do ECMAScript 2015, os construtores `Int16Array` precisam ser construídos com um operador `new`. Chamar um construtor `Int16Array` como uma função sem o `new`, irá resultar em `TypeError`.

```js
var dv = Int16Array([1, 2, 3]);
// TypeError: calling a builtin Int16Array constructor
// without new is forbidden
```

```js
var dv = new Int16Array([1, 2, 3]);
```

Ver também
----------

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`


Set.prototype.clear() - JavaScript

Set.prototype.clear()
=====================

O método **`clear()`** remove todos os elementos de um objeto `Set`.

Sintaxe
-------
```

mySet.clear();
```

Exemplos
--------

### Usando o método `clear`

```js
var mySet = new Set();
mySet.add(1);
mySet.add("foo");

mySet.size; // 2
mySet.has("foo"); // true

mySet.clear();

mySet.size; // 0
mySet.has("bar"); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

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

* `Set`
* `Set.prototype.delete()`


Set.prototype.entries() - JavaScript

Set.prototype.entries()
=======================

O método **`entries()`** retorna um novo objeto Iterador (`Iterator`) que contém **um array de [valor, valor]** para cada elemento de um objeto `Set`em ordem de inserção. Os objetos `Set` não possuem `chaves (key)` como objetos do tipo `Map`. Entretanto, para manter a API similar a objetos `Map`, cada entrada (*entry*) tem o mesmo valor para sua chave (`key`) e valor (`value`), então uma matriz `array [valor, valor]` é retornado.

Sintaxe
-------
```

mySet.entries()
```

Exemplos
--------

### Usando `entries()`

```js
var mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

var setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

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

* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`


Set.prototype.has() - JavaScript

Set.prototype.has()
===================

O método **`has()`** retorna um valor booleano indicando se um elemento com o valor especificado existe em um objecto `Set` ou não.

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

Sintaxe
-------
```

mySet.has(valor);
```

### Parâmetros

`valor`

O valor para testar a existência no objeto `Set`.

### Valor de retorno

Retorna `true` se um elemento com o valor especificado existe no objeto `Set`; `false` caso contrário.

>
> \*\*Nota:\*\*Tecnicamente falando, `has()` usa o algorítimo `sameValueZero` para determinar quando o elemento dado é encontrado.
>
>
>

Exemplos
--------

### Usando o método `has`

```js
var mySet = new Set();
mySet.add("foo");

mySet.has("foo"); // retorna true
mySet.has("bar"); // retorna false

var set1 = new Set();
var obj1 = { key1: 1 };
set1.add(obj1);

set1.has(obj1); // retorna true
set1.has({ key1: 1 }); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes.
set1.add({ key1: 1 }); // agora set1 contém 2 registros
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

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

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`


Set.prototype.add() - JavaScript

Set.prototype.add()
===================

O método **`add()`** acrescenta um novo elemento com o valor especificado no final de um objeto `Set`.

Sintaxe
-------
```

mySet.add(value);
```

### Parâmetros

value

Requerido. O valor de um elemento a ser adicionado ao objeto Set.

### Valor de retorno

O objeto `Set`.

Exemplos
--------

### Usando o método `add`

```js
var mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // pode ser encadeado

console.log(mySet);
// Set [1, 5, "some text"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

Compatilidade de Navegadores (Browser)
--------------------------------------

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

Notas específicas para Firefox
------------------------------

* Antes do Firefox 33, `Set.prototype.add retornava` `undefined` e não era possível encadear chamadas. Isto foi resolvido (Erro do Firefox 1031632). O comportamento pode ser encontrado no Chrome/v8 (issue).
Veja também
-----------

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`


Set.prototype.values() - JavaScript

Set.prototype.values()
======================

O método **`values()`** retorna um novo objeto `Iterator` que contem os valores para cada elemento dentro do objeto `Set` por ordem de inserção.

O método **`keys()`** é um alias desse método (por similaridade com os objetos `Map`); ele se comporta exatamente da mesma forma e retorna os **valores** dos elementos do `Set`.

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

Sintaxe
-------
```

mySet.values();
```

### Valor retornado

Um novo objeto **`Iterator`** condendo os valores de cada elemento contido no `Set`, por ordem de inserção.

Exemplos
--------

### Usando `values()`

```js
var mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

var setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

Browsers compatíveis
--------------------

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

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

* `Set.prototype.entries()`


Set.prototype.delete() - JavaScript

Set.prototype.delete()
======================

O método **`delete()`** remove o elemento especificado de um objeto `Set`.

Sintaxe
-------
```

mySet.delete(value);
```

### Parâmetros

value

Requerido. O valor do elemento a ser removido do objeto Set.

### Return value

Retorna `true` se um elemento contido no objeto Set foi removido com sucesso; caso contrário `false`.

Exemples
--------

### Uso do método `delete`

```js
var mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // Retorna false. Nenhum elemento "bar" foi encontrado para deletar.
mySet.delete("foo"); // Retorna true. remoção bem sucedida.

mySet.has("foo"); // Retorna false. O elemento "foo" não está mais presente.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

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

* `Set`
* `Set.prototype.clear()`


Symbol.iterator - JavaScript

Symbol.iterator
===============

O símbolo conhecido **`Symbol.iterator`** especifíca o iterador padrão para um objeto. Usado por `for...of`.

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

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

Sempre que um objeto precisa ser iterado (como um começo de um `for..of` loop), o método `@@iterator` é chamado sem argumentos, e o **iterador** retornado é usado para obter os valores para serem iterados.

Alguns tipos built-in tem um comportamento padrão de iteração, enquanto outros tipos (assim como `Object`) não tem. O tipo built-in com um método `@@iterator` são:

* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()` (en-US)

Veja também Iteration protocols para mais informação.

| Property attributes of `Symbol.iterator` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Iteráveis definidos pelo usuário

Podemos fazer nosso próprio iterável dessa forma:

```js
var myIterable = {};
myIterable[Symbol.iterator] = function\* () {
  yield 1;
  yield 2;
  yield 3;
};
[...myIterable]; // [1, 2, 3]
```

Ou iteráveis podem ser definidos diretamente dentro de uma classe ou um objeto usando computed property:

```js
class Foo {
  \*[Symbol.iterator] () {
    yield 1;
    yield 2;
    yield 3;
  }
}

const someObj = {
  \*[Symbol.iterator] () {
    yield 'a';
    yield 'b';
  }
}

[...new Foo] // [ 1, 2, 3 ]
[...someObj] // [ 'a', 'b' ]
```

### Iteráveis não bem formados

Se um método `@@iterator` não retornar um objeto iterador, então é um iterável não bem formado. Usando dessa forma é resultará em uma excessão de tempo ou comportamentos com erros:

```js
var nonWellFormedIterable = {}
nonWellFormedIterable[Symbol.iterator] = () => 1
[...nonWellFormedIterable] // TypeError: [] is not a function
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.iterator |

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

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

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

* Iteration protocols
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()` (en-US)


Symbol.matchAll - JavaScript

Symbol.matchAll
===============

O símbolo **`Symbol.matchAll`** é conhecido por retornar um iterador, que produz conrrespondências de uma expressão regular com uma string. Essa função é usada pelo método `String.prototype.matchAll()`.

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

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

Esse símbolo é usado pelo `String.prototype.matchAll()` e especificado no `RegExp.prototype[@@matchAll]()` (en-US). Os próximos dois exemplos retornam o mesmo resultado:

```js
"abc".matchAll(/a/);

/a/[Symbol.matchAll]("abc");
```

Esse método existe para costumizar o comportamento conrrespondente com as subclasses `RegExp`.

| Property attributes of `Symbol.matchAll` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Usuando Symbol.matchAll

```js
let re = /[0-9]+/g;
let str = "2016-01-02|2019-03-07";

const numbers = {
  \*[Symbol.matchAll](str) {
    for (const n of str.matchAll(/[0-9]+/g)) yield n[0];
  },
};

console.log(Array.from(str.matchAll(numbers)));
// Array ["2016", "01", "02", "2019", "03", "07"]
```

Veja `String.prototype.matchAll()` e `RegExp.prototype[@@matchAll]()` (en-US) para mais exemplos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.matchall |

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

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

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

* `String.prototype.matchAll()`
* `RegExp.prototype[@@matchAll]()` (en-US)


Symbol.asyncIterator - JavaScript

Symbol.asyncIterator
====================

O **`Symbol.asyncIterator`** é um símbolo conhecido que especifica o padrão AsyncIterator para um objeto. Se essa propriedade é configurada em um objeto, é um iterável assíncrono e pode ser usado in um `for await...of` loop.

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

O `Symbol.asyncIterator` é um símbolo built-in que é usado para um acessar o método `@@asyncIterator` de um objeto. Para que um objeto seja iterável assíncrono, ele deve ter uma chave `Symbol.asyncIterator`.

| Property attributes of `Symbol.asyncIterator` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Iteráveis assíncronos definidos pelo usuário

Você consegue definir seu próprio iterável assíncrono configurando a propriedade `[Symbol.asyncIterator]` em um objeto.

```js
const myAsyncIterable = {
  async \*[Symbol.asyncIterator]() {
    yield "hello";
    yield "async";
    yield "iteration!";
  },
};

(async () => {
  for await (const x of myAsyncIterable) {
    console.log(x);
    // resultado esperado:
    // "hello"
    // "async"
    // "iteration!"
  }
})();
```

Quando criando uma API, lembre que iteráveis assíncronos são programados para representar algum iterável — como um fluxo de dados ou uma lista —, não para substituir completamente chamadas e eventos na maioria das situações.

### Iteráveis assíncronos

Não há atualmente objetos Javascript built-in que tenha a chave `[Symbol.asyncIterator]` configurada por padrão. Entretanto, a WHATWG Streams estão configurando para que o primeiro objeto built-in seja um iterável assíncrono, com a recente chegada do `[Symbol.asyncIterator]` nas especificações.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.asynciterator |

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

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

Vejá também
-----------

* Iteration protocols
* for await... of