Array - JavaScript

Array
=====

Sumário
-------

O objeto `Array` do JavaScript é um objeto global usado na construção de 'arrays': objetos de alto nível semelhantes a listas.

Sintaxe
-------
```

[element0, element1, ..., elementN]
new Array(element0, element1, ..., elementN)
new Array(arrayLength)
```

`element0, element1, ..., elementN`

Um array JavaScript é inicializado com os elementos contém, exceto no caso onde um único argumento é passado para o construtor do `Array` e esse argumento é um número (veja o parâmetro arrayLength abaixo). Esse caso especial só se aplica para os arrays JavaScript criados com o construtor `Array` , e não para literais de array criados com a sintaxe de colchetes [].

`arrayLength`

Se o único argumento passado para o construtor do `Array` for um número inteiro entre 0 e 232-1 (inclusive), um novo array com o tamanho desse número é retornado. Se o argumento for qualquer outro número, uma exceção `RangeError` (en-US) é lançada.

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

Arrays são objetos semelhantes a listas que vêm com uma série de métodos embutidos para realizar operações de travessia e mutação. Nem o tamanho de um array JavaScript nem os tipos de elementos são fixos. Já que o tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não contíguas, arrays JavaScript não tem a garantia de serem densos; isso depende de como o programador escolhe usá-los. De uma maneira geral, essas são características convenientes, mas, se esses recursos não são desejáveis para o seu caso em particular, você pode considerar usar arrays tipados.

Arrays não podem usar strings como índices (como em um array associativo), devem ser usados números inteiros. Definir ou acessar não-inteiros usando notação de colchetes (ou notação de ponto) não vai definir ou recuperar um elemento do array em si, mas sim definir ou acessar uma variável associada com a coleção de propriedades de objeto daquele array. As propriedades de objeto do array e a lista de elementos do array são separados, e as operações de travessia e mutação não podem ser aplicadas a essas propriedades nomeadas.

### Accessando elementos de um array

Arrays JavaScript começam com índice zero: o primeiro elemento de um array está na posição `0` e o último elemento está na posição equivalente ao valor da propriedade `length` (en-US) (tamanho) menos 1.

```js
var arr = ["este é o primeiro elemento", "este é o segundo elemento"];
console.log(arr[0]); // exibe 'este é o primeiro elemento'
console.log(arr[1]); // exibe 'este é o segundo elemento'
console.log(arr[arr.length - 1]); // exibe 'este é o segundo elemento'
```

Elementos de um array são somente propriedades de objetos, da forma que `toString` (en-US) é uma propriedade. Contudo, note que tentando acessar o primeiro elemento de um array da seguinte forma causará um erro de sintaxe, pois o nome da propriedade é inválido:

```js
console.log(arr.0); // um erro de sintaxe
```

Não há nada de especial a respeito de arrays JavaScript e suas propriedades que causam isso. As propriedades JavaScript que começam com um dígito não podem ser referenciadas com notação de ponto. Elas necesitam usar notação de colchetes para poderem ser acessadas. Por exemplo, se você tivesse um objeto com a propriedade "3d", também teria que ser referenciá-la usando notação de colchetes. Por exemplo:

```js
var anos = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(anos.0); // um erro de sintaxe
console.log(anos[0]); // funciona corretamente
```

```js
renderer.3d.setTexture(model, 'personagem.png'); // um erro de sintaxe
renderer['3d'].setTexture(model, 'personagem.png'); //funciona corretamente
```

Note que no exemplo `3d`, `'3d'` teve de ser colocado entre aspas. É possivel também colocar entre aspas os índices de arrays JavaScript (ou seja, `years['2']` ao invés de `years[2]`), contudo isto não é necessário. O valor 2 em `years[2]` eventualmente será convertido a uma string pela engine do JavaScript através de uma conversão explicita com o método `toString`. E é por esta razão que `'2'` e `'02'` irão referenciar dois slots diferentes no objeto `anos` e o seguinte exemplo pode ser *`true`*:

```js
console.log(anos["2"] != anos["02"]);
```

De forma similar, propriedades de objeto que sejam palavras reservadas(!) só podem ser acessadas como strings em notação de colchetes:

```js
var promessa = {
  var: "texto",
  array: [1, 2, 3, 4],
};

console.log(promessa["var"]);
```

### Relação entre *`length`* e propriedades numéricas

As propriedades `length` (en-US) e numéricas de um array Javascript são conectadas. Varios dos métodos javascript pré-definidos (por exemplo, `join` (en-US), `slice` (en-US), `indexOf` (en-US) etc.) levam em conta o valor da propriedade `length` de um array quando eles são chamados. Outros métodos (por exemplo, `push` (en-US), `splice` etc.) também resultam em uma atualização na propriedade `length` do array.

```js
var frutas = [];
frutas.push("banana", "maça", "pêssego");

console.log(frutas.length); // 3
```

Quando configurar uma propriedade num array Javascript em que a propriedade é um índice valido do array e este índice está fora do atual limite do array, o array irá crescer para um tamanho grande o suficiente para acomodar o elemento neste índice, e a engine irá atualizar a propriedade *length* do array de acordo com isto:

```js
frutas[5] = "manga";
console.log(frutas[5]); // 'manga'
console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
console.log(frutas.length); // 6
```

Configurar a propriedade `length` diretamente, também resulta em um comportamento especial:

```js
frutas.length = 10;
console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
console.log(frutas.length); // 10
```

Diminuir o valor de `length`, entretanto, apaga elementos:

```js
frutas.length = 2;
console.log(Object.keys(frutas)); // ['0', '1']
console.log(frutas.length); // 2
```

### Criando um array usando o resultado de uma comparação

O resultado de uma comparação entre uma *expressão regular* e uma string pode criar um array Javascript. Este array tem propriedades e elementos que disponibilizam informações sobre a comparação. Esse array é o valor de retorno dos métodos `RegExp.exec`, `String.match`, e `String.replace`. Para explicar melhor sobre estas propriedades e elementos, veja o seguinte exemplo e então consulte a tabela abaixo:

```js
// Encontra um d seguido por um ou mais b's seguido por um d
// Salva os b's encontrados e o d seguinte
// Ignora caixa (maiúscula/minúscula)

var minhaRegex = /d(b+)(d)/i;
var meuArray = minhaRegex.exec("cdbBdbsbz");
```

As propriedades e elementos retornados desta comparação são os seguintes:

| Propriedade/Elemento | Descrição | Exemplo |
| --- | --- | --- |
| `input` | Uma propriedade somente-leitura que reflete a string original a qual a expressão regular foi comparada. | cdbBdbsbz |
| `index` | Uma propriedade somente-leitura que é o índice baseado em zero da comparação na string. | 1 |
| `[0]` | Um elemento somente-leitura que especifica os ultimos caracteres que foram encontrados. | dbBd |
| `[1], ...[n]` | Elementos somente-leitura que especificam as *substrings* de comparações entre parênteses encontradas, se incluidas na expressão regular. O número de possíveis *substrings* entre parenteses é ilimitado. | [1]: bB [2]: d |

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

`Array.length`

Propriedade comprimento do construtor `Array`, cujo valor é 1.

`get Array[@@species]` (en-US)

A função de construtor que é utilizada para criar objetos derivados.

`Array.prototype`

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

Métodos
-------

`Array.from()`

Cria uma nova instância de `Array` a partir de um objeto semelhante ou iterável.

`Array.isArray()`

Retorna `true` se a variável é um array e `false` caso contrário.

`Array.of()`

Cria uma nova instância de `Array` com um número variável de argumentos, independentemente do número ou tipo dos argumentos.

Instâncias de `Array`
---------------------

Todas as instâncias de `Array` herdam de `Array.prototype`. O protótipo do construtor `Array` pode ser modificado de forma a afetar todas as instâncias de `Array`.

### Propriedades

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

#### Métodos modificadores

{{ page('/pt-BR/docs/JavaScript/Reference/Global\_Objects/Array/prototype', 'Mutator\_methods') }}
#### Métodos de acesso

{{ page('/pt-BR/docs/JavaScript/Reference/Global\_Objects/Array/prototype', 'Accessor\_methods') }}
#### Métodos de iteração

{{ page('/pt-BR/docs/JavaScript/Reference/Global\_Objects/Array/prototype', 'Iteration\_methods') }}Métodos genéricos de `Array`
----------------------------

**Aviso:** **Métodos genéricos de arrays não seguem o padrão, são obsoletos e serão removidos em breve.**

Algumas vezes você poderá querer aplicar métodos de arrays para strings ou outros objetos parecidos com arrays (como em `argumentos` (en-US) de funções). Ao fazer isto, você trata uma string como um array de caracteres (ou em outros casos onde trata-se não-arrays como um array). Por exemplo, para checar se cada caractere em uma varivável *str* é uma letra, você poderia escrever:

```js
function isLetter(character) {
  return character >= "a" && character <= "z";
}

if (Array.prototype.every.call(str, isLetter))
  alert("A string '" + str + "' contém somente letras!");
```

Esta notação é um pouco despendiosa e o JavaScript 1.6 introduziu a seguinte abreviação genérica:

```js
if (Array.every(isLetter, str))
  alert("A string '" + str + "' contém somente letras!");
```

Generics também estão disponíveis em `String`.

Estes não são atualmente parte dos padrões ECMAScript (através do ES2015 `Array.from()` pode se conseguir isto). A seguir segue uma adaptação para permitir o uso em todos os navegadores:

```js
/\*globals define\*/
// Assumes Array extras already present (one may use shims for these as well)
(function () {
  "use strict";

  var i,
    // We could also build the array of methods with the following, but the
    // getOwnPropertyNames() method is non-shimable:
    // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'});
    methods = [
      "join",
      "reverse",
      "sort",
      "push",
      "pop",
      "shift",
      "unshift",
      "splice",
      "concat",
      "slice",
      "indexOf",
      "lastIndexOf",
      "forEach",
      "map",
      "reduce",
      "reduceRight",
      "filter",
      "some",
      "every",
      "isArray",
    ],
    methodCount = methods.length,
    assignArrayGeneric = function (methodName) {
      var method = Array.prototype[methodName];
      Array[methodName] = function (arg1) {
        return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
      };
    };

  for (i = 0; i < methodCount; i++) {
    assignArrayGeneric(methods[i]);
  }
})();
```

Exemplos
--------

### Exemplo: Criando um array

O exemplo a seguir cria um array, `msgArray`, com *length* 0, então atribui valores para `msgArray[0]` e `msgArray[99]`, trocando o *length* do array para 100.

```js
var msgArray = new Array();
msgArray[0] = "Hello";
msgArray[99] = "world";

if (msgArray.length == 100) console.log("O length é 100.");
```

### Criando um Array

```js
var frutas = ["Maçã", "Banana"];

console.log(frutas.length);
// 2
```

### Acessar um item (*index*) do Array

```js
var primeiro = frutas[0];
// Maçã

var ultimo = frutas[frutas.length - 1];
// Banana
```

### Iterar um Array

```js
frutas.forEach(function (item, indice, array) {
  console.log(item, indice);
});
// Maçã 0
// Banana 1
```

### Adicionar um item ao final do Array

```js
var adicionar = frutas.push("Laranja");
// ['Maçã', 'Banana', 'Laranja']
```

### Remover um item do final do Array

```js
var ultimo = frutas.pop(); // remove Laranja (do final)
// ['Maçã', 'Banana'];
```

### Remover do início do Array

```js
var primeiro = frutas.shift(); // remove Maçã do início
// ['Banana'];
```

### Adicionar ao início do Array

```js
var adicionar = frutas.unshift("Morango"); // adiciona ao início
// ['Morango', 'Banana'];
```

### Procurar o índice de um item na Array

```js
frutas.push("Manga");
// ['Morango', 'Banana', 'Manga']

var pos = frutas.indexOf("Banana");
// 1
```

### Remover um item pela posição do índice

```js
var removedItem = frutas.splice(pos, 1); // é assim que se remove um item
// ['Morango', 'Manga']
```

### Remover itens de uma posição de índice

```js
var vegetais = ["Repolho", "Nabo", "Rabanete", "Cenoura"];
console.log(vegetais);
// ['Repolho', 'Nabo', 'Rabanete', 'Cenoura']

var pos = 1,
  n = 2;

var itensRemovidos = vegetais.splice(pos, n);
// Isso é como se faz para remover itens, n define o número de itens a se remover,
// a partir da posição (pos) em direção ao fim da array.

console.log(vegetais);
// ['Repolho', 'Cenoura'] (o array original é alterado)

console.log(itensRemovidos);
// ['Nabo', 'Rabanete']
```

### Copiar um Array

```js
var copiar = frutas.slice(); // é assim que se copia
// ['Morango', 'Manga']
```

### Exemplo: Criando um array bi-dimensional

O exemplo a seguir cria um tabuleiro de xadrez usando dois arrays bi-dimensionais de string. A primeira jogada é feita copiando o 'p' em 6,4 para 4,4. A posição antiga de 6,4 é colocada em branco.

```js
var board = [
  ["R", "N", "B", "Q", "K", "B", "N", "R"],
  ["P", "P", "P", "P", "P", "P", "P", "P"],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  ["p", "p", "p", "p", "p", "p", "p", "p"],
  ["r", "n", "b", "q", "k", "b", "n", "r"],
];
console.log(board.join("\n") + "\n\n");

// Fazendo o King's Pawn avançar 2
board[4][4] = board[6][4];
board[6][4] = " ";
console.log(board.join("\n"));
```

Saída:
```

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , ,p, , ,
 , , , , , , ,
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r
```

### Utilizando um array para tabular um conjunto de valores

```js
values = [];
for (var x = 0; x < 10; x++) {
  values.push([2 \*\* x, 2 \* x \*\* 2]);
}
console.table(values);
```

Saída:
```

0  1  0
1  2  2
2  4  8
3  8  18
4  16  32
5  32  50
6  64  72
7  128  98
8  256  128
9  512  162
```

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

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

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

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

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

* "Indexing object properties" in JavaScript Guide: "Working with objects" (en-US)
* New in JavaScript 1.7: Array comprehensions
* New in JavaScript 1.6: Array extras
* Draft: Typed Arrays (en-US)


Map - JavaScript

Map
===

O objeto **`Map`** contém pares de chave-valor e lembra a ordem original da inserção das chaves. Qualquer valor (objetos e valores primitivos) podem ser usados como chave ou valor.

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

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

Um objeto `Map` itera seus elementos na order da inserção - um loop `for...of` retorna um array de `[key, value]` para cada iteração

### Igualdade de chaves

* A igualdade de chaves é baseada no algoritimo `sameValueZero`.
* O `NaN` é considerado o mesmo que o `NaN` (apesar de `NaN !== NaN`) e todos os outros valores são considerados de acordo com a semântica do operador `===`.
* Na especificação atual do ECMAScript, `-0` e `+0` são considerados iguais, embora não tenha sido nos esboços anteriores. Veja *"Equivalência de valor entre -0 e 0"* em Compatibilidade com navegadores para mais detalhes;
### Objetos vs. Maps

Um `Object` é similar o `Map` - ambos permitem que valores sejam definidos a chaves, retornar esses valores, remover as chaves, e detectar se algo está armazenado na chave. Por esta razão (e porque não existem outras alternativas construídas), o `Objeto` tem sido usado como `Map` historicamente.

Porém, existem diferenças importantes que fazem o `Map` ser preferido em alguns casos:

|  | Map | Objeto |
| --- | --- | --- |
| Chaves acidentais | O `Map` não contém nenhuma chave por padrão. Ele só contém o que é definido explicitamente nele. | Um `Objeto` tem um prototype, então ele contém por padrão algumas chaves que podem conflitar com suas próprias chaves se você não for cuidadoso.

**Nota:** Apartir do ES5, isso pode ser ignorado com o `Object.create(null)`, mas isso raramente é feito.
 |
| Tipos das chaves | As chaves do `Map` podem ser qualquer valor (incluindo funções, objetos, ou qualquer outro tipo primitivo). | A chave de um `Objeto` deve ser uma `String` ou um `Symbol`. |
| Ordem das chaves | As chaves dentro do `Map` são ordenadas de forma simples, de maneira direta: O objeto `Map` itera suas entradas, chaves, e valor na ordem em que foram inseridas. | Embora as chaves de um `Objeto` comum hoje sejam ordenadas, nem sempre esse foi o caso, e a ordem é complexa. Como resultado é melhor não confiar na ordem das propriedades.

 A ordem foi definida primeiramente para suas próprias propriedades apenas no ECMAScript 2015; no ECMAScript 2020 a ordem definida é por propriedades herdadas também.
 Veja o
 OrdinaryOwnPropertyKeys
 e
 numerateObjectPropertiesoperações de especificações abstraídas. Mas note que nenhum mecanismo itera **todas** as propriedades do objeto; cada um dos vários mecanismos incluem diferentes subconjuntos de propriedades.
 (`for-in`
 incluí apenas propriedades enumeráveis com chaves do tipo string
 `Object.keys` inclui apenas chaves próprias e enumeráveis do tipo string;
 `Object.getOwnPropertyNames` incluí o próprio, e propriedades com chaves do tipo string, mesmo que não enumeráveis
 `Object.getOwnPropertySymbols` faz o mesmo só que para
 propriedades `Símbolos` como chave, etc.)
  |
| Tamanho |
 O número de items dentro de um `Map`
 é facilmente retornado pela propriedade `size` | O número de items dentro de um `Objeto` deve ser determinado manualmente |
| Iteração | Um `Map` é `iterável`, então ele pode ser diretamente iterável | O `Objeto` não implementa o protocolo de iteração, e os objetos não podem ser iterados diretamente usando o for...of (por padrão).

**Nota:**
* Um objeto pode implementar o protocolo de iteração, ou pode ser iterado usando o `Object.keys`ou`Object.entries`.
* A declaração for...in
 permite que você itere pela propriedades enumeráveis de um objeto.

 |
| Performance | Perfoma melhor em cenários envolvendo adições e remoções frequentes em pares chave-valor. | Não é otimizado para adições e remoções frequentes de pares chave-valor. |
| Serialização e análise sintática | Não há suporte nativo para a serialização ou análise sintática.

 (Mas você pode construir sua própria serialização e conversão para o `Map` usando o
 `JSON.stringify()` como o argumento *replacer*,
 e usando o `JSON.parse()` com o argumento *reviver*.
 Veja a questão no Stack Overflow How do you JSON.stringify an ES6 Map?).
  | Suporte nativo para serialização de `Objeto` para JSON, usando `JSON.stringify()`.
Suporte nativo para conversão de JSON para `Objeto` usando `JSON.parse()`. |

### Definindo propriedades no objeto

Definir propriedades no objeto também funciona em objetos `Map`, e pode causar um confusão considerável.

Portanto, isso aparenta funcionar de certa forma:

```js
const wrongMap = new Map();
wrongMap["bla"] = "blaa";
wrongMap["bla2"] = "blaaa2";

console.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }
```

Mas esse jeito de definir propriedades não interage com a estrura de dados do `Map`. Dessa forma é usada a implementação genérica do objeto. O valor 'bla' não é armazenado no `Map` para queries. Outras operaçãoes nos dados irão falhar.

```js
wrongMap.has("bla"); // false
wrongMap.delete("bla"); // false
console.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }
```

A maneira correta para armazenar dados dentro do `Map` é através do `set(key,value)`

```js
const contacts = new Map();
contacts.set("Jessie", { phone: "213-555-1234", address: "123 N 1st Ave" });
contacts.has("Jessie"); // true
contacts.get("Hilary"); // undefined
contacts.set("Hilary", { phone: "617-555-4321", address: "321 S 2nd St" });
contacts.get("Jessie"); // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete("Raymond"); // false
contacts.delete("Jessie"); // true
console.log(contacts.size); // 1
```

Construtor
----------

`Map()`

Cria um novo objeto `Map`.

propriedades estáticas
----------------------

`get Map[@@species]`

A função do construtor que é usada para criar apartir de objetos.

propriedades da instância
-------------------------

`Map.prototype.size`

Retorna o número de pares chave/valor no objeto `Map`.

Métodos da instância
--------------------

`Map.prototype.clear()`

Remove todos os pares chave/valor do objeto `Map`.

`Map.prototype.delete(key)`

 Retorna `true` se o elemento no objeto `Map` existia e tenha sido removido, ou `false`
 se o elemento não existia. `Map.prototype.has(key)` irá retornar `false` após isso.

`Map.prototype.get(key)`

Retorna o valor associado à chave, ou `undefined` se não há nada.

`Map.prototype.has(key)`

Retorna uma asserção booleana se o valor tenha sido associado à chave no objeto `Map` ou não.

`Map.prototype.set(key, value)`

Define o `valor` para a `chave` no objeto `Map`. Retorna o objeto `Map`

### Métodos iterativos

`Map.prototype[@@iterator]()`

Retorna um novo objeto iterador que contèm **um array de `[chave, valor]`** para cada elemento do objeto `Map` na ordem em que foram inseridos.

`Map.prototype.keys()`

Retorna um novo objeto iterador que contèm as **chaves** de cada elemento do objeto `Map` na ordem em que foram inseridos.

`Map.prototype.values()`

Retorna um novo objeto iterador que contém os **valores** para cada elemento do objeto `Map` na ordem em que foram inseridos.

`Map.prototype.entries()`

 Retorna um novo objeto iterador que contèm **um array de `[chave, valor]`**
 para cada elemento no objeto `Map` na ordem em que foram inseridos.

`Map.prototype.forEach(callbackFn[,
 thisArg])`

Invoca o `callbackFn` uma vez para cada par chave-valor presente no objeto `Map`, na ordem em que foram inseridos. Se um parâmetro `thisArg` é provido para o `forEach`, será usado o valor de `this` para cada callback.

Exemplos
--------

### Usando o objeto Map

```js
const myMap = new Map();

const keyString = "a string";
const keyObj = {};
const keyFunc = function () {};

// setting the values
myMap.set(keyString, "value associated with 'a string'");
myMap.set(keyObj, "value associated with keyObj");
myMap.set(keyFunc, "value associated with keyFunc");

myMap.size; // 3

// getting the values
myMap.get(keyString); // "valor associado a 'a string'"
myMap.get(keyObj); // "valor associado a keyObj"
myMap.get(keyFunc); // "valor associado a keyFunc"

myMap.get("a string"); // "valor associado a 'a string'"
// porque keyString === 'a string'
myMap.get({}); // undefined, porque keyObj !== {}
myMap.get(function () {}); // undefined, porque keyFunc !== function () {}
```

### Usando NaN como chaves de Map

`NaN` também pode ser usado como chave. Apesar de todo o `NaN` não ser igual a ele mesmo (`NaN !== NaN`), o exemplo a seguir funciona porque não é possível distinguir um `NaN` de outros.

```js
const myMap = new Map();
myMap.set(NaN, "not a number");

myMap.get(NaN);
// "not a number"

const otherNaN = Number("foo");
myMap.get(otherNaN);
// "not a number"
```

### Iterando o Map com for..of

`Maps` podem ser iterados usando um loop `for..of`:

```js
const myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");

for (const [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero
// 1 = um

for (const key of myMap.keys()) {
  console.log(key);
}
// 0
// 1

for (const value of myMap.values()) {
  console.log(value);
}
// zero
// one

for (const [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
// 0 = zero
// 1 = one
```

### Iterando o Map com forEach()

`Maps` podem ser iterados usando o
 método `forEach()`:

```js
myMap.forEach(function (value, key) {
  console.log(key + " = " + value);
});
// 0 = zero
// 1 = um
```

### Relação com Arrays

```js
const kvArray = [
  ["key1", "value1"],
  ["key2", "value2"],
];

// Use o construtor padrão do Map para transformar um array 2D chave-valor em um map
const myMap = new Map(kvArray);

myMap.get("key1"); // retorna "value1"

// Use o Array.from() para transformar um map em um Array bidimensional de chaves e valores
console.log(Array.from(myMap)); // Irá exibir para você o mesmo Array como um Array chave-valor

// Uma forma sucinta de fazer o mesmo, utilizando a sintaxe spread
console.log([...myMap]);

// Ou use os iteradores keys() ou values(), e os converta para um array
console.log(Array.from(myMap.keys())); // ["key1", "key2"]
```

### Clonando e mesclando Maps

Assim como `Arrays`, o map também pode ser clonado:

```js
const original = new Map([[1, "um"]]);

const clone = new Map(original);

console.log(clone.get(1)); // um
console.log(original === clone); // false (Útil para comparações superficiais)
```

**Nota:** Tenha em mente que *o dado em si* não é clonado.

Maps podem ser mesclados, mantendo as chaves únicas:

```js
const first = new Map([
  [1, "one"],
  [2, "two"],
  [3, "three"],
]);

const second = new Map([
  [1, "uno"],
  [2, "dos"],
]);

// Mescla dois maps. A última chave a se repetir vence.
// O operador spread essenciamente converte um Map para um Array
const merged = new Map([...first, ...second]);

console.log(merged.get(1)); // uno
console.log(merged.get(2)); // dos
console.log(merged.get(3)); // three
```

Maps podem ser mesclados com array também:

```js
const first = new Map([
  [1, "one"],
  [2, "two"],
  [3, "three"],
]);

const second = new Map([
  [1, "uno"],
  [2, "dos"],
]);

// Mescla maps com um array. A última chave a se repetir vence.
const merged = new Map([...first, ...second, [1, "eins"]]);

console.log(merged.get(1)); // eins
console.log(merged.get(2)); // dos
console.log(merged.get(3)); // three
```

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

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

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

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

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

* Um polyfill do `Map` está disponível em
 `core-js`
* `Set`
* `WeakMap`
* `WeakSet`


AsyncFunction - JavaScript

AsyncFunction
=============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
O **construtor `AsyncFunction`** cria um novo objeto `async function`. Em JavaScript cada função assíncrona é atualmente um objeto do tipo `AsyncFunction`.

Note que`AsyncFunction` não é um objeto global. Ele poderia ser obtido analisando o seguinte código:

```js
Object.getPrototypeOf(async function () {}).constructor;
```

Sintaxe
-------
```

new AsyncFunction([arg1[, arg2[, ...argN]],] functionBody)
```

### Parameters

`arg1, arg2, ... argN`

Nomes que vão ser usados pela função como argumentos formais. Cada um deve ser uma string que corresponde a um indentificador JavaScript válido ou uma lista das strings separadas com uma vírgula; por exemplo "`x`", "`oValor`", or "`a,b`".

`functionBody`

Uma string contendo as declarações JavaScript que compõem a definição da função.

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

Objetos `async function` criados com o construtor `AsyncFunction` são tratados quando a função é criada. Isso é menos eficiente que declarar uma função async com a `expression async function` e chama-la com seu código, porque essas funções são tratadas com o resto do código.

Todos os argumentos passado para a função são tratados como nomes dos identificadores dos parâmetros na função que vai ser criada, na ordem que eles são passados.

**Nota:** `async functions` criadas com o construtor `AsyncFunction` não cria closures para seus contextos de criação; elas sempre criadas no escopo global. Quando rodar eles, eles só poderão acessar suas variáveis local e as globais, mas não as que estão no escopo que o construtor foi `AsyncFunction` chamado. Isso é diferente de usar `eval` com código para uma expressão async function.

Invocar o construtor `AsyncFunction` como uma função (sem usar o operador `new`) tem o mesmo efeito de invocá-lo como um construtor.

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

**`AsyncFunction.length`**

A propriedade tamanho do construtor da `AsyncFunction` cujo valor é 1.

`AsyncFunction.prototype`

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

`AsyncFunction` prototype object
--------------------------------

### Propriedades

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/AsyncFunction/prototype', 'Propriedades')}}`AsyncFunction` instances
-------------------------

Instância `AsyncFunction` herdam métodos e propriedades do `AsyncFunction.prototype`. Com todos os contrutores, que podem mudar o prototype do objeto construtor para fazer mudanças em todas as instâncias do `AsyncFunction`.

Exemplos
--------

### Criando uma async function a partir do construtor de uma `AsyncFunction`

```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

var AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;

var a = new AsyncFunction(
  "a",
  "b",
  "return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);",
);

a(10, 20).then((v) => {
  console.log(v); // imprime 30 após 4 seconds
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-objects |

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

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

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

* `async function function`
* `async function expression`
* `Function`
* `function statement`
* `function expression`
* Funções e escopo de função (en-US)


globalThis - JavaScript

globalThis
==========

A propriedade global **`globalThis`** retorna um objeto global de nível superior.

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

Sintaxe
-------
```

globalThis
```

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

 Historicamente, o acesso ao escopo global exigiu uma sintaxe diferente em diferentes ambientes JavaScript. Na web você pode usar `window` (en-US), `self` (en-US) ou `frames` (en-US) - porém em Web Workers somente `self` funcionará. Em Node.js nada disso funciona e você deve usar `global`.
 A palavra-chave `this` poderia ser usada dentro de funções em execução no modo *sloppy*, mas `this` será `undefined` em módulos, e dentro de funções em execução no *strict mode*.

A propriedade `globalThis` fornece uma maneira padrão de acessar o objeto global entre ambientes. Ao contrário de propriedades semelhantes, como `window` (en-US) e `self` (en-US), é garantido que funcione em contextos *window* e *non-window*. Dessa forma, você pode acessar o objeto global de maneira consistente sem precisar saber em qual ambiente o código está sendo executado.

Para ajudá-lo a lembrar o nome, lembre-se que no escopo global, o valor de `this` é `globalThis`.

### Nome

Várias outras opções de nomes populares, como `self` e `global` foram removidas da discussão devido ao seu potencial em quebrar a compatibilidade com o código existente.

Exemplos
--------

Antes de `globalThis`, a única maneira confiável de obter o objeto global para um ambiente era `Function('return this')()`. No entanto, isso causa violações CSP em algumas configurações, então es6-shim usa uma verificação como essa, por exemplo:

```js
var getGlobal = function () {
  if (typeof self !== "undefined") {
    return self;
  }
  if (typeof window !== "undefined") {
    return window;
  }
  if (typeof global !== "undefined") {
    return global;
  }
  throw new Error("unable to locate global object");
};

var globals = getGlobal();

if (typeof globals.setTimeout !== "function") {
  // sem setTimeout neste ambiente!
}
```

Com `globalThis` disponível, a busca global adicional entre ambientes não é mais necessária:

```js
if (typeof globalThis.setTimeout !== "function") {
  // sem setTimeout neste ambiente!
}
```

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

| Especificação | Status | Comentário |
| --- | --- | --- |
| globalThis proposal | Stage 3 |  |

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

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


Atomics - JavaScript

Atomics
=======

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O objeto **`Atomics`** fornece operações atômicas como metodos estáticos. Eles são usados com objetos `SharedArrayBuffer` (en-US).

As operações atômicas estão localizadas no modulo `Atomics`. Diferente de outros *global objects*, `Atomics` não é um construtor. Você não deve usa-lo com o `new` operator ou invocar objetos `Atomics` como funções. Todas as propriedades e método do `Atomics` são estáticos (como é o caso com o objeto `Math`, por exemplo).

Métodos
-------

### Operações Atômicas

Quando a memória é compartilhada, multiplas threads podem ser lidas e escritas no mesmo dado da memória. Operações atômicas garantem que os valores previstos sejam lidos e escritos, estas operações são finalizadas antes da próxima operação iniciar e que as mesmas não sejam interrompidas.

`Atomics.add()`

Adiciona o valor recebido na posiçao recebida no array. Retorna o valor anterior nesta posição.

`Atomics.and()` (en-US)

Calcula um bit a bit AND na posição recebida no array. Retorna o valor anterior nesta posição.

`Atomics.compareExchange()` (en-US)

Armazena o valor recebido na posição recebida no array, se este foi igual ao valor recebido. Retorna o valor anterior nesta posição.

`Atomics.exchange()` (en-US)

Armazena o valor recebido na posição recebida no array. Retorna o valor anterior.

`Atomics.load()` (en-US)

Retorna o valor na posição recebida no array.

`Atomics.or()` (en-US)

Calcula um bit a bit OR na posição recebida no array. Retorna o valor anterior nesta posição.

`Atomics.store()` (en-US)

Armazena o valor recebido na posição recebida no array. Retorna o valor.

`Atomics.sub()` (en-US)

Subtrai o valor recebido na posição recebida no array. Retorna o valor anterior nesta posição.

`Atomics.xor()` (en-US)

Calcula um bit a bit XOR na posição recebida no array. Retorna o valor anterior nesta posição.

### Wait e wake

Os métodos `wait()` e `wake()` são modelados no Linux futexes ("fast user-space mutex") e fornece formas de aguardar até que certas condições se tornem `true` e são tipicamente usadas como construtores de bloco.

`Atomics.wait()` (en-US)

Verifica se a posição informada no array ainda contém a valor recebido e dorme à espera ou até o tempo limite. Retorna `"ok"`, `"not-equal"`, ou `"timed-out"`. Se a espera não for permitida no agente de chamada ele irá lançar uma exceção de erro (muitos navegadores não permitem `wait()` na thread main do navegador).

`Atomics.wake()` (en-US)

"Acorda" alguns agentes que estavam "dormindo" na lista de espera na posição recebida do array. Retorna o número de agentes que estão sendo "acordados".

`Atomics.isLockFree(size)` (en-US)

Uma otimização primitiva que pode ser usada para determinar se deve ser usado lock ou operações atômicas. Retorna `true`, se uma operação atômica em matrizes de um dado tamanho do elemento vai ser implementado utilizando uma operação atômica de hardware (como oposição a lock). Só para experientes.

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

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

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

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

Observações de compatibilidade
------------------------------

[3] A especificação de compartilhamento de memória está sendo estabilizada. Anterior ao SpiderMonkey 48, a última API e semântica não foram implementadas ainda. As alterações entre as versões 46 e 48 do Firefox são:

* Os métodos `Atomics.futexWakeOrRequeue()` e `Atomics.fence()` foram totalmente removidos (Erro do Firefox 1259544 e Erro do Firefox 1225028).
* O método `Atomics.wait()` (en-US) e `Atomics.wake()` (en-US) foram nomeados como `Atomics.futexWait()` e `Atomics.futexWake()` (Erro do Firefox 1260910). Os nomes antigos foram mantidos como alias, e serão removidos na versão 49 (Erro do Firefox 1262062).
* As propriedades `Atomics.OK`, `Atomics.TIMEDOUT`, `Atomics.NOTEQUAL` foram removidas. O método `Atomics.wait()` (en-US) agora retorna "ok", "timed-out" e "not-equal" (Erro do Firefox 1260835).
* O parâmetro `count` do método `Atomics.wake()` (en-US) foi alterado: este agora possui o valor padrão `+Infinity`, e não `0` (Erro do Firefox 1253350).
Veja Também
-----------

* `ArrayBuffer`
* JavaScript typed arrays
* Web Workers
* parlib-simple – a simple library providing synchronization and work distribution abstractions.
* Shared Memory – a brief tutorial


undefined - JavaScript

undefined
=========

Resumo
------

O valor global `undefined` representa um valor indefinido. Trata-se de um dos tipos primitivos do JavaScript.

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

Sintaxe
-------
```

undefined
```

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

O `undefined` é uma propriedade do objeto `global`, ou seja, é uma variável no escopo global. O valor inicial de `undefined` é o valor primitivo `undefined`.

Nos browsers modernos (JavaScript 1.8.5 / Firefox 4+), a especificação ECMAScript 5 define que o `undefined` é uma propriedade não configurável e somente leitura. Mesmo quando esse não for o caso, evite sobrescrevê-lo.

Uma variável que não teve um valor atribuído é do tipo `undefined`. Um método ou sentença também retorna `undefined` se a variável que está sendo avaliada não tem um valor atribuído. Uma função retorna `undefined` se um valor não for `retornado`.

Uma vez que undefined não é uma `palavra reservada` (en-US), ele pode ser usado como um identificador (nome de variável) em qualquer escopo que não seja o escopo global.

```js
// escreve no console "foo string"
(function () {
  var undefined = "foo";
  console.log(undefined, typeof undefined);
})();

// escreve no console "foo string"
(function (undefined) {
  console.log(undefined, typeof undefined);
})("foo");
```

Exemplos
--------

### Igualdade estrita (===) e `undefined`

Voce pode utilizar `undefined` com os operadores de igualdade e desigualdade estritas para determinar se a variável possui um valor. No código a seguir, a variável `x` não foi definida, e o resultado do `if` é verdadeiro.

```js
var x;
if (x === undefined) {
  // sentenças aqui são executadas
} else {
  // o código aqui não é executado
}
```

**Nota:** Observação: O operador de igualdade estrita (`===`) tem que ser utilizado aqui uma vez que `x == undefined` também checa se `x` é nulo, enquanto o operador não o faz. `null` não é equivalente à `undefined`. Veja `operadores de comparação` (en-US) (em inglês) para maiores detalhes.

### `Operador Typeof` e `undefined`

Alternativamente, `typeof` pode ser usado:

```js
var x;
if (typeof x === "undefined") {
  // esse código é executado
}
```

Uma das principais razões para usar o `typeof` é que ele não lança erros caso a variável não tenha sido inicializada.

```js
// x não foi atribuída anteriormente
if (typeof x === "undefined") {
  // retorna verdadeiro sem lançar erros
  // esse código executa
}

if (x === undefined) {
  // lança um ReferenceError para x
}
```

No entanto, esse tipo de técnica deveria ser evitada. A linguagem JavaScript é uma linguagem com escopo estático, portanto o conhecimento sobre se uma variável está definida pode ser adquirido pela verificação de sua definição dentro do contexto à qual ela pertence. A única exceção é para o escopo global. No entanto, o escopo global é anexado ao objeto global, portanto a verificação da existência de uma variável no contexto global pode ser feita através de uma checagem na propriedade do objeto global usando o operador `in`, por exemplo.

### `Operador Void` e `undefined`

O operador `void` é a terceira alternativa.

```js
var x;
if (x === void 0) {
  // esse código executa
}

// y não foi definido antes
if (y === void 0) {
  // lança uma ReferenceError (ao contrário de `typeof`)
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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


decodeURIComponent() - JavaScript

decodeURIComponent()
====================

O método **`decodeURIComponent()`** decodifica um componente Identificador Uniforme de Recursos (URI) criado anteriormente por um `encodeURIComponent` ou por uma rotina semelhante.

Sintaxe
-------
```

decodeURIComponent(encodedURI)
```

### Parâmetros

`encodedURI`

Um componente codificado de um Identificador Uniforme de Recursos.

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

Substitui cada sequência escapada no componente URI codificado com o caractere que a representa.

Exemplos
--------

### Decodificando um componente URL Cirílico

```js
decodeURIComponent("JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript\_шеллы"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuricomponent-encodeduricomponent |

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

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

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

* `decodeURI`
* `encodeURI`
* `encodeURIComponent`


Function - JavaScript

Function
========

Resumo
------

O **`construtor Function`** cria um novo objeto `Function`. Chamar o construtor diretamente pode criar funções dinamicamente, mas sofre com problemas de segurança e desempenho semelhante (mas muito menos significativo) a `eval` (en-US). No entanto, diferentemente de eval, a Função construtora cria funções que executam somente no escopo global.

Sintaxe
-------
```

new Function ([arg1[, arg2[, ...argN]],] functionBody)
```

### Parâmetros

`arg1, arg2, ... argN`

Nomes para serem usados pela função como nomes formais de argumentos. Cada um deve ser uma string que corresponde para uma válida identidade JavaScript ou uma lista de certas strings separadas com uma vírgula; por exemplo "x", "theValue". our "a,b".

`functionBody`

Uma string que contém as instruções JavaScript que compõem a definição da função.

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

Objetos `Function` criados com o construtor `Function` são *parseados* quando a função é criada. Isto é menos eficiente que criar com uma expressão de função ou um declaração de função e chamando-a dentro do seu código, porque tais funções são *parseadas* com o resto do código.

Todos os argumentos passados para a função são tratados como os nomes dos indetificadores dos parâmetros na função a ser criada, na mesma ordem na qual eles foram passados.

**Nota:** Funções criadas com o construtor `Function não criam closures` para o seu contexto de criação; elas sempre são criadas no escopo global. Quando executadas, elas terão acesso apenas às suas variáveis locais ou globais, não terão acesso às variáveis do escopo na qual o construtor `Function` foi chamado. Isto é diferente de usar `eval` com o código de uma expressão de função.

Invocar o construtor `Function` como uma função (sem usar o operador `new`) tem o mesmo efeito de chamá-la como um construtor.

Propriedades e Métodos da `Function`
------------------------------------

O objeto global `Function` não tem métodos ou propriedades próprias, no entanto, como ela é uma função, ela herda alguns métodos e propriedades através do prototype chain do `Function.prototype` (en-US).

`Function` prototype object
---------------------------

### Propriedades

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

{{page('/pt-BR/docs/JavaScript/Reference/Global\_Objects/Function/prototype', 'Methods')}}`Function` instances
--------------------

`Function` instances inherit methods and properties from `Function.prototype` (en-US). As with all constructors, you can change the constructor's prototype object to make changes to all `Function` instances.

Exemplos
--------

### Exemplos: Especificando argumentos com o construtor `Function`

O código a seguir cria um objeto `Function` que recebe dois argumentos.

```js
// O exemplo pode ser executado direto no seu console JavaScript

// Cria uma função que recebe 2 argumentos e retorna a soma entre os dois:
var adder = new Function("a", "b", "return a + b");

// Chamada da função
adder(2, 6);
// > 8
```

Os argumentos "`a`" e "`b`" são os argumentos que serão usados no corpo da função, "`return a + b`".

### Exemplo: Um atalho recursivo para modificar o DOM em massa

Creating functions with the `Function` constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the `Function` constructor for each new query if you want to avoid closures.

```html
<!doctype html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>
      MDN Example - a recursive shortcut to massively modify the DOM
    </title>
    <script type="text/javascript">
 var domQuery = (function () {
 var aDOMFunc = [
 Element.prototype.removeAttribute,
 Element.prototype.setAttribute,
 CSSStyleDeclaration.prototype.removeProperty,
 CSSStyleDeclaration.prototype.setProperty,
 ];

 function setSomething(bStyle, sProp, sVal) {
 var bSet = Boolean(sVal),
 fAction = aDOMFunc[bSet | (bStyle << 1)],
 aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2),
 aNodeList = bStyle ? this.cssNodes : this.nodes;

 if (bSet && bStyle) {
 aArgs.push("");
 }
 for (
 var nItem = 0, nLen = this.nodes.length;
 nItem < nLen;
 fAction.apply(aNodeList[nItem++], aArgs)
 );
 this.follow = setSomething.caller;
 return this;
 }

 function setStyles(sProp, sVal) {
 return setSomething.call(this, true, sProp, sVal);
 }
 function setAttribs(sProp, sVal) {
 return setSomething.call(this, false, sProp, sVal);
 }
 function getSelectors() {
 return this.selectors;
 }
 function getNodes() {
 return this.nodes;
 }

 return function (sSelectors) {
 var oQuery = new Function(
 "return arguments.callee.follow.apply(arguments.callee, arguments);",
 );
 oQuery.selectors = sSelectors;
 oQuery.nodes = document.querySelectorAll(sSelectors);
 oQuery.cssNodes = Array.prototype.map.call(
 oQuery.nodes,
 function (oInlineCSS) {
 return oInlineCSS.style;
 },
 );
 oQuery.attributes = setAttribs;
 oQuery.inlineStyle = setStyles;
 oQuery.follow = getNodes;
 oQuery.toString = getSelectors;
 oQuery.valueOf = getNodes;
 return oQuery;
 };
 })();
 </script>
  </head>

  <body>
    <div class="testClass">Lorem ipsum</div>
    <p>Some text</p>
    <div class="testClass">dolor sit amet</div>

    <script type="text/javascript">
 domQuery(".testClass")
 .attributes("lang", "en")("title", "Risus abundat in ore stultorum")
 .inlineStyle("background-color", "black")("color", "white")(
 "width",
 "100px",
 )("height", "50px");
 </script>
  </body>
</html>
```

Especificação
-------------

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

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

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

See also
--------

* function Expression
* function Statement
* Functions and function scope (en-US)


parseFloat() - JavaScript

parseFloat()
============

A função `parseFloat` analisa um argumento (convertendo-o para uma string primeiro caso necessário) e retorna um número de ponto flutuante (número decimal).

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

Sintaxe
-------

```js
parseFloat(string);
```

### Parâmetros

`string`

O valor para analisar. Se este argumento não é uma string, então ele é convertido para uma, usando a operação abstrata `ToString`. Espaços em branco são ignorados.

### Retorna

Um número de ponto flutuante da `string` dada. Ou `NaN` quando o primeiro carácter, diferente de um espaço em branco, não pôde ser convertido para um número

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

`parseFloat` é uma função top-level e não está associada a nenhum objeto.

`parseFloat` analisa um argumento string, e retorna um numero de ponto flutuante. Se ele encontrar um carácter diferente de um sinal (+ ou -), numeral (0-9), um ponto decimal, ou um expoente, ele retorna o valor até esse ponto e ignora esse caractere e todos os caracteres seguintes. Espaços a direita e a esquerda são permitidos.

Se o primeiro carácter não puder ser convertido para um número, `parseFloat` retorna `NaN`.

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

`parseFloat` também pode analisar e retornar o valor `Infinity`. Você pode usar a função `isFinite` para determinar se a função é um número finito (not `Infinity`, `-Infinity`, ou `NaN`).

Exemplos
--------

### `parseFloat` retornando um número

O exemplo a seguir sempre retorna `3.14`:

```js
parseFloat("3.14");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14more non-digit characters");
```

### `parseFloat` retornando `NaN`

O exemplo a seguir retorna `NaN`

```js
parseFloat("FF2");
```

### Uma função de análise estrita

As vezes é útil ter uma maneira mais rigorosa para analisar valores float, expressões regulares podem ajudar:

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

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

Observe que este código é somente um exemplo; ele não aceita números válidos, tais como 1. ou 0,5.

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

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

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

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

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

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`


TypeError - JavaScript

TypeError
=========

O objeto **`TypeError`** representa um erro de quando um valor não é do tipo esperado.

Sintaxe
-------
```

new TypeError([message[, fileName[, lineNumber]]])
```

### Parâmetros

`message`

Opcional. Mensagem, descrição do erro

`fileName`
Non-standard

Opcional. O nome do arquivo contendo o código que causou a exceção

`lineNumber`
Non-standard

Opcional. O número da linha do código que causou a exeção

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

O `TypeError` é ativado quando um operador ou argumento passado para uma função é incompativel com o tipo esperado por esse operador ou função.

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

`TypeError.prototype` (en-US)

Permite a adição de propriedades para o objeto `TypeError`.

Métodos
-------

O TypeError global não contém métodos por si só, no entanto, ele herda alguns métodos através da cadeia prototype.

`Instâncias TypeError`
----------------------

### Propriedades

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

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

### Capturando um `TypeError`

```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### Criando um `TypeError`

```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-typeerror |

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

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

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

* `Error`
* `TypeError.prototype` (en-US)


Set - JavaScript

Set
===

Sumário
-------

O objeto **`Set`** permite que você armazene valores *únicos* de qualquer tipo, desde valores primitivos a referências a objetos.

Sintaxe
-------
```

 new Set([iterable]);
```

### Parâmetros

iterable

Se um objeto iterável é passado, todos os seus elementos serão adicionados ao novo Set. Se tal parâmetro não for específicado, ou se seu valor for `null`, o novo `Set` estará vazio.

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

Objetos `Set` são coleções de valores nas quais é possível iterar os elementos em ordem de inserção. Um valor no `Set` **pode ocorrer apenas uma vez**; ele é único na coleção do `Set`.

### Igualdade de valores

Como cada valor no Set deve ser único, a igualdade será checada e não é baseada no mesmo algoritmo que aquele usado no operador ===. Especificamente, para `Set`s, `+0` (que é exatamente igual a - 0) e `- 0` são valores diferentes. No entanto, isto foi modificado na última especificação ECMAScript 2015. Iniciado com o Gecko 29.0 (Erro do Firefox 952870) e pelo recent nightly Chrome, +0 e -0 são tratados com sendo o mesmo valor em objetos conjunto (Set). Também, `NaN` e `undefined` podem ser armazenados em um conjunto Set.

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

`Set.length`

O valor da propriedade comprimento é 0.

Para contar o número de elementos de um `Set`, use `Set.prototype.size` (en-US).

`get Set[@@species]` (en-US)

A função construtora usada para criar objetos derivados.

`Set.prototype` (en-US)

Representa o prototype do constructor do `Set`. Permite a adição de propriedades para todos os objetos do tipo `Set`.

Instâncias `Set`
----------------

Todas as instâncias de `Set` herdam de `Set.prototype` (en-US).

### Propriedades

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

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

### Utilizando o objeto `Set`

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

meuSet.add(1); // meuSet [1]
meuSet.add(5); // meuSet [1, 5]
meuSet.add(5); // 5 já foi adicionando, portanto, meuSet [1, 5]
meuSet.add("texto");
var o = { a: 1, b: 2 };
meuSet.add(o);

meuSet.add({ a: 1, b: 2 }); // o está referenciando outro objeto

meuSet.has(1); // true
meuSet.has(3); // false, 3 não foi adicionado ao set (Conjunto)
meuSet.has(5); // true
meuSet.has(Math.sqrt(25)); // true
meuSet.has("Texto".toLowerCase()); // true
meuSet.has(o); // true

meuSet.size; // 5

meuSet.delete(5); // remove 5 do set
meuSet.has(5); // false, 5 já foi removido

meuSet.size; // 4, nós simplesmente removemos um valor

console.log(meuSet); // Set { 1, 'texto', { a: 1, b: 2 }, { a: 1, b: 2 } }
```

### Iterando objetos `Set`

```js
// iterar sobre os itens em set
// loga os itens na ordem: 1, "texto"
for (let item of meuSet) console.log(item);

// loga os itens na ordem: 1, "texto"
for (let item of meuSet.keys()) console.log(item);

// loga os itens na ordem: 1, "texto"
for (let item of meuSet.values()) console.log(item);

// loga os itens na ordem: 1, "texto"
//(key e value são os mesmos aqui)
for (let [key, value] of meuSet.entries()) console.log(key);

// converte Set para um Array
var meuArr = [v for (v of mySet)]; // [1, "some text"]

// o seguinte também funcionará se for executado em um documento HTML
mySet.add(document.body);
mySet.has(document.querySelector("body")); // true

// a conversão entre Set e Array
mySet2 = Set([1,2,3,4]);
mySet2.size; // 4
[...mySet2]; // [1,2,3,4]

// intersecção pode ser simulado via
var intersection = new Set([...set1].filter(x => set2.has(x)));

// Iterar entradas set com forEach
meuSet.forEach(function(value) {
  console.log(value);
});

// 1
// 2
// 3
// 4
```

### Implementando operações básicas entre conjuntos

```js
function isSuperset(set, subset) {
  for (var elem of subset) {
    if (!set.has(elem)) {
      return false;
    }
  }
  return true;
}

function uniao(setA, setB) {
  var _uniao = new Set(setA);
  for (var elem of setB) {
    _uniao.add(elem);
  }
  return _uniao;
}

function interseccao(setA, setB) {
  var _interseccao = new Set();
  for (var elem of setB) {
    if (setA.has(elem)) {
      _interseccao.add(elem);
    }
  }
  return _interseccao;
}

function diferencaSimetrica(setA, setB) {
  var _diferenca = new Set(setA);
  for (var elem of setB) {
    if (_diferenca.has(elem)) {
      _diferenca.delete(elem);
    } else {
      _diferenca.add(elem);
    }
  }
  return _diferenca;
}

function diferenca(setA, setB) {
  var _diferenca = new Set(setA);
  for (var elem of setB) {
    _diferenca.delete(elem);
  }
  return _diferenca;
}

//Exemplos
var setA = new Set([1, 2, 3, 4]),
  setB = new Set([2, 3]),
  setC = new Set([3, 4, 5, 6]);

isSuperset(setA, setB); // => true
uniao(setA, setC); // => Set [1, 2, 3, 4, 5, 6]
interseccao(setA, setC); // => Set [3, 4]
diferencaSimetrica(setA, setC); // => Set [1, 2, 5, 6]
diferenca(setA, setC); // => Set [1, 2]
```

### Relação com objetos `Array`

```js
var myArray = ["value1", "value2", "value3"];

// Use o construtor regular de Set para transformar um array dentro de um Set
var mySet = new Set(myArray);

mySet.has("value1"); // retorna true

// Use o operador de propagação para transformar um Set em um Array.
alert(uneval([...mySet])); // Irá mostrar-lhe exatamente o mesmo Array como myArray
```

### Removendo elementos duplicados de um `Array`

```js
// Use para remover elementos duplicados de um Array

const numeros = [2, 3, 4, 4, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 5, 32, 3, 4, 5];

console.log([...new Set(numeros)]);

// [2, 3, 4, 5, 6, 7, 32]
```

### Relação com objetos `String`

```js
var texto = "India";

var meuSet = new Set(texto); // Set ['I', 'n', 'd', 'i', 'a']
meuSet.size; // 5
```

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

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

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

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

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

* `Map`
* `WeakMap`
* `WeakSet`


Número - JavaScript

Número
======

Sumário
-------

O objeto JavaScript **`Number`** é um objeto encapsulado que permite você trabalhar com valores numéricos. Um objeto `Number` é criado utilizando o construtor `Number()`.

Construtor
----------
```

new Number(value);
```

### Parâmetros

`value`

O valor numérico do objeto sendo criado.

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

Os principais usos para o objeto `Number` são:

* Se o objeto não pode ser convertido para um número, é retornado `NaN`.
* Fora do contexo de um construtor (Ex., Sem o operador `new`, `Number` pode ser utilizador para realizar uma conversão de tipo.
Propriedades
------------

`Number.EPSILON`
Experimental

O menor intervalo entre dois números representáveis.

`Number.MAX_SAFE_INTEGER`
Experimental

O inteiro máximo seguro em JavaScript (253 -1).

`Number.MAX_VALUE`

O maior número representável positivo.

`Number.MIN_SAFE_INTEGER`
Experimental

O inteiro mínimo seguro em JavaScript (-(253 -1)).

`Number.MIN_VALUE`

O número mínimo representável positivo - isto é, o número positivo mais próximo de zero (sem ser zero na verdade).

`Number.NaN`

Valor especial que não é número.

`Number.NEGATIVE_INFINITY`

Valor especial representando infinito negativo; retornado no "overflow".

`Number.POSITIVE_INFINITY`

Valor especial representando infinito; retornado no "overflow".

`Number.prototype` (en-US)

Permite a adição de propriedades a um objeto Number.

Methods
-------

`Number.isNaN()`
Experimental

Determina se o valor passado é NaN.

`Number.isFinite()`
Experimental

Determina se o tipo e o valor passado é um número finito.

`Number.isInteger()`
Experimental

Determina se o tipo do valor passado é inteiro.

`Number.isSafeInteger()`
Experimental

Determina se o tipo do valor passado é um inteiro seguro (número entre -(253 -1) e 253 -1).

~~`Number.toInteger()`~~

~~Usado para avaliar o valor passado e convertê-lo a um inteiro (ou infinito), mas foi removido.~~

`Number.parseFloat()`
Experimental

O valor é o mesmo que `parseFloat` do objeto global.

`Number.parseInt()`
Experimental

O valor é o mesmo que `parseInt` do objeto global.

Instâncias `Number`
-------------------

Toda instância `Number` herdam de `Number.prototype` (en-US). O objeto 'prototype' do construtor `Number` pode ser modificado para afetar todas as instâncias `Number`.

### Métodos

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

### Exemplo: Usando o objeto `Number` para atribuir valores a variáveis numéricas

O seguinte exemplo usa as propriedades do objeto `Number` para atribuir valores a várias variáveis numéricas:

```js
var biggestNum = Number.MAX\_VALUE;
var smallestNum = Number.MIN\_VALUE;
var infiniteNum = Number.POSITIVE\_INFINITY;
var negInfiniteNum = Number.NEGATIVE\_INFINITY;
var notANum = Number.NaN;
```

### Exemplo: Intervalo inteiro para `Number`

O seguinte exemplo mostra os valores inteiros mínimo e máximo que podem ser representados como objeto `Number` (para mais detalhes, referir-se ao padrão EcmaScript standard (EcmaScript standard), capítulo *8.5 O tipo de número (The Number Type*):

```js
var maxInt = 9007199254740992;
var minInt = -9007199254740992;
```

Ao analisar dados que foram serializados para JSON, valores inteiros que caem fora desse intervalo podem ser corrompidos quando o analisador JSON os converte ao tipo `Number`. Usando `String` em vez disso é uma possível alternativa para se evitar um resultado indesejado.

### Exemplo: Usando `Number para converter um objeto Date`

O exemplo a seguir converte o objeto `Date` para um valor numérico usando `Number como uma função`:

```js
var d = new Date("December 17, 1995 03:24:00");
print(Number(d));
```

Isto resulta em "819199440000".

### Converte 'string' numérica em números

```js
Number("123"); // 123
Number("12.3"); // 12.3
Number(""); // 0
Number("0x11"); // 17
Number("0b11"); // 3
Number("0o11"); // 9
Number("foo"); // NaN
Number("100a"); // NaN
```

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

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

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

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

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

* `NaN`
* O objeto global `Math`


NaN - JavaScript

NaN
===

Resumo
------

A propriedade global **`NaN`** é um valor especial que significa *Not-A-Number* (não é um número).

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

Sintaxe
-------
```

NaN
```

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

`NaN` é uma propriedade do *objeto global*.

O valor inicial de `NaN` é Not-A-Number - o mesmo valor de `Number.NaN`. Nos navegadores modernos, o `NaN` é uma propriedade somente leitura e não configurável. Mesmo quando não for este o caso, evite sobrescrevê-lo.

Não é usual a utilização do `NaN`. Ele é retornado quando uma operação matemática falha (Math.sqrt(-1)) ou quando uma função tenta transformar uma string em inteiro (parseInt("blabla")).

### Testando um valor `NaN`

Os operadores de igualdade (`==` e `===`) não podem ser usados para testar um valor NaN. Ao invés disso, utilize `Number.isNaN()` ou `isNaN()`.

```js
NaN === NaN; // falso
Number.NaN === NaN; // falso
isNaN(NaN); // verdadeiro
isNaN(Number.NaN); // verdadeiro
```

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

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

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

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

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

* `Number.NaN`
* `Number.isNaN()`
* `isNaN()`


DataView - JavaScript

DataView
========

O **`DataView`** provê uma interface de baixo nível para leitura e escrita de múltiplos tipos de número em um `ArrayBuffer`, independentemente da extremidade (*endianness*) da plataforma.

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

Sintaxe
-------
```

new DataView(buffer [, byteOffset [, byteLength]])
```

### Parâmetros

`buffer`

`ArrayBuffer` ou `SharedArrayBuffer` (en-US)
Experimental
 existente para usar como armazenamento de um novo objeto `DataView`.

`byteOffset` Optional

A mudança, em bytes, do primeiro byte determinado em um buffer, que será referenciado pela nova view. Se não for especificado, a view do buffer começará no primeiro byte.

`byteLength` Optional

O número de elementos no array de bytes. Se não especificado, o tamanho da view será do mesmo tamanho do buffer.

### Retorno

Um novo objeto `DataView` que representa o buffer de dados especificado. (Provavelmente não foi uma descrição muito útil.)

Você pode pensar nesse objeto retornado como um "intérprete" de um array buffer de bytes - ele sabe como converter números para inserir em um buffer corretamente, tanto ao ler quanto ao gravar. Isso significa lidar com conversões *integer,* *float,* *endianness* e outros detalhes da representação de números em formato binário.

### Exceções

``RangeError` (en-US)`

Lançado se o `byteOffset` ou `byteLength` especificados ultrapassarem o final do buffer.

Por exemplo, se o buffer tem 16 bytes de comprimento, o `byteOffset` é 8 e o `byteLength` é 10, esse erro será lançado porque a view resultante tenta estender 2 bytes acima do comprimento total do buffer.

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

### *Endianness*

Formatos de números *Multi-byte* são representados de maneira diferente na memória, dependendo da arquitetura da máquina, veja Endianness para mais informações. Assessores de `DataView` fornecem controle explícito de como o dado será acessado, independente do *endianness* da arquitetura em execução.

```js
var littleEndian = (function () {
  var buffer = new ArrayBuffer(2);
  new DataView(buffer).setInt16(0, 256, true /\* littleEndian \*/);
  // Int16Array uses the platform's endianness.
  return new Int16Array(buffer)[0] === 256;
})();
console.log(littleEndian); // true or false
```

### Valores inteiros de 64 bits

Como JavaScript atualmente não inclui suporte padrão para valores inteiros de 64 bits, `DataView` não oferece operações nativas de 64 bits. Como solução alternativa, você poderia implementar sua própria função getUint64() para obter um valor com a precisão de `Number.MAX_SAFE_INTEGER`, o que pode ser bom para determinados casos.

```js
function getUint64(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // combine the two 32-bit values
  const combined = littleEndian
    ? left + 2 \*\* 32 \* right
    : 2 \*\* 32 \* left + right;

  if (!Number.isSafeInteger(combined))
    console.warn(combined, "exceeds MAX\_SAFE\_INTEGER. Precision may be lost");

  return combined;
}
```

Como alternativa, se você precisar de um intervalo completo de 64 bits, poderá criar um `BigInt`.

```js
function getUint64BigInt(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // combine the two 32-bit values as their hex string representations
  const combined = littleEndian
    ? right.toString(16) + left.toString(16).padStart(8, "0")
    : left.toString(16) + right.toString(16).padStart(8, "0");

  return BigInt(`0x${combined}`);
}
```

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

Todas as instâncias de `DataView` herdam `DataView.prototype` (en-US) e permitem a adição de propriedades a todos os objetos DataView.

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

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

```js
var buffer = new ArrayBuffer(16);
var dv = new DataView(buffer, 0);

dv.setInt16(1, 42);
dv.getInt16(1); //42
```

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

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

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

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

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

Começando com o Firefox 40, `DataView` deve ser construído com o operador `new` . Chamando `DataView()` como uma função sem o `new`, irá lançar um `TypeError` de agora em diante.

```js
var dv = DataView(buffer, 0);
// TypeError: calling a builtin DataView constructor without new is forbidden
```

```js
var dv = new DataView(buffer, 0);
```

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

* jDataView: Biblioteca javascript que faz o polyfill e extende a API do `DataView` para todos os browsers e para o Node.js.
* `ArrayBuffer`
* `SharedArrayBuffer` (en-US)


Float32Array - JavaScript

Float32Array
============

A array tipada **`Float32Array`** representa uma array de 32-bits contendo floats (correspondendo ao tipo de dados `float` em C) na ordem dos bytes da plataforma. Se o controle sobre a ordem dos bytes for precisa, use `DataView`. Os conteúdos iniciam em `0`. Uma vez estabelecido, você pode referenciar os elementos na array usando os métodos do objeto ou usando a síntaxe padrão das arrays (Isto é, usando colchetes)

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

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

Para mais informações sobre a síntaxe de construção e os parâmetros, veja *TypedArray (en-US)*.

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

`Float32Array.BYTES_PER_ELEMENT` (en-US)

Retorna um número valor do tamanho do elemento. `4` no caso de uma `Float32Array`.

Float32Array.length

Método estático cujo o valor é `0`. Para o tamanho atual (número de elementos), veja `Float32Array.prototype.length` (en-US).

`Float32Array.name` (en-US)

Retorna o valor em string do nome do constructor. No caso de `Float32Array` é "Float32Array".

`Float32Array.prototype` (en-US)

Prototype para os objetos *TypedArray*.

Métodos
-------

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

Cria uma nova `Float32Array` de um array-like ou um objeto iterável. Veja também `Array.from()`.

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

Cria uma nova `Float32Array` with um número variável de argumentos. Veja também `Array.of()`.

`Float32Array` prototype
------------------------

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

### Propriedades

`Float32Array.prototype.constructor`

Retorna a função cujo criou o protótipo da instância. Este é o construtor padrão da Array `Float32Array`.

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

Retorna os `ArrayBuffer` referenciado pela Array `Float32Array` fixada na hora de sua construção e é **somente leitura**.

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

Retorna o tamanho (em bytes) da Array `Float32Array` do começo de seu `ArrayBuffer`. Fixado na hora de sua construção e é **somente leitura**.

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

Retorna o deslocamento (em bytes) da Array `Float32Array` do começo de seu `ArrayBuffer`. Fixado na hora de sua construção e é **somente leitura**.

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

Retorna o número de elementos na Array `Float32Array` do começo de seu `ArrayBuffer`. Fixado na hora de sua construção e é **somente leitura**.

### Métodos

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

Copia a sequência dos elementos dentro da Array. Veja também `Array.prototype.copyWithin()`.

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

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

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

Testa quando todos os elementos na array passam no teste proveniente de uma função. Veja também `Array.prototype.every()`.

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

Preenche todos os elementos de uma array do índex inicial ao índex final com um valor estático. Veja também `Array.prototype.fill()`.

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

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

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

Retorna o valor na array encontrado, se um elemento na array satizfaz o teste proveniente de uma função de teste ou `undefined` se não for encontrado. Veja também `Array.prototype.find()`.

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

Retorna o index encontrado na array, se um elemento na array satizfaz o teste proveniente de uma função de teste ou -1 se não for encontrado. Veja também `Array.prototype.findIndex()`.

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

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

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

Determina quando a array tipada inclui um certo elemento, retornando `true` ou `false` como apropriado. Veja também `Array.prototype.includes()`.

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

Retorna o primeiro (menor) index de um elemento dentro de uma array igual ao valor expecificado, ou -1 se nenhum for encontrado. Veja também `Array.prototype.indexOf()`.

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

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

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

Retorna um novo `Array Iterator` cujo contem as chaves para cada index na array. Veja também `Array.prototype.keys()`.

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

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

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

Cria uma nova array com os resultados da função chamada em cada elemento nesta array. Veja também `Array.prototype.map()`.

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

Versão antiga não padrão de `Float32Array.prototype.copyWithin()` (en-US).

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

Aplica uma função contra um acumulador e cada valor na array (da esquerda para a direita) com o intuito de reduzí-la a um único valor. Veja também `Array.prototype.reduce()`.

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

Aplica uma função contra um acumulador e cada valor na array (da direita para a esquerda) como o intuito de reduzí-la a um único valor. See also `Array.prototype.reduceRight()`.

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

Reverte a ordem se todos os elementos em uma array - o primeiro se torna o último, e o último de torna o primeiro. Veja também `Array.prototype.reverse()`.

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

Armazena múltiplos valores na array tipada, lendo os valores de entrada de uma array especificada.

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

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

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

Retorna true se pelo menos um elemento nesta array satisfazer a função de teste proveniente de uma função de teste. Veja também `Array.prototype.some()`.

`Float32Array.prototype.sort()`

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

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

Retorna uma nova Array `Float32Array` a partir de um ponto inicial e um fim pelo índex do elemento.

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

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

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

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

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

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

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

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

Exemplos
--------

Diferentes modos de criar uma Array `Float32Array`:

```js
// Pelo seu tamanho
var float32 = new Float32Array(2);
float32[0] = 42;
console.log(float32[0]); // 42
console.log(float32.length); // 2
console.log(float32.BYTES\_PER\_ELEMENT); // 4

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

// Por uma outra TypedArray
var x = new Float32Array([21, 31]);
var y = new Float32Array(x);
console.log(y[0]); // 21

// Por um ArrayBuffer
var buffer = new ArrayBuffer(16);
var z = new Float32Array(buffer, 0, 4);

// Por um iterável
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float32 = new Float32Array(iterable);
// Float32Array[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
------------------------

Começando com o ECMAScript 2015, construtores da Array `Float32Array` requerem o uso do operador `new`. Chamando o construtor da Array `Float32Array` como uma função, sem o `new`, irá gerar um erro `TypeError` de agora em diante.

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

// TypeError: chamando o construtor da função interna Float32Array
// sem o new é proibido
```

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

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

* JavaScript arrays tipadas
* `ArrayBuffer`
* `DataView`


JSON - JavaScript

JSON
====

Resumo
------

O Objeto **`JSON`** contém métodos para parsing JavaScript Object Notation (JSON) e conversão de valores para JSON. Ele não pode ser chamado ou construído e, além de suas propriedades de dois métodos, ele não possui uma funcionalidade interessante.

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

### JavaScript Object Notation

JSON é uma sintaxe para serialização de objetos, matrizes, números, strings, booleanos, e `null`. Baseia-se em sintaxe Javascript, mas é distinta desta: alguns Javascript não são JSON, e alguns JSON não são Javascript.

| JavaScript tipo | JSON diferenças |
| --- | --- |
| Objetos e Arrays | Os nomes das propriedades devem ser strings com aspas duplas; as vírgulas à direita são proibidas. |
| Números | Zeros à esquerda são proibidos; um ponto decimal deve ser seguido por pelo menos um dígito. |
| Strings | Apenas um conjunto limitado de caracteres pode ser escapado; certos caracteres de controle são proibidos; o separador de linha Unicode (U+2028) e o separador de parágrafo (U+2029) caracteres são permitidos; strings devem ter aspas duplas.Veja o exemplo a seguir, onde `JSON.parse()` funciona bem e um `SyntaxError` (en-US) é lançado ao avaliar o código como JavaScript: var code = '"\u2028\u2029"'; JSON.parse(code); // works fine eval(code); // fails |

A sintaxe completa do JSON é a seguinte:
```

JSON = null
    or true or false
    or JSONNumber
    or JSONString
    or JSONObject
    or JSONArray

JSONNumber = - PositiveNumber
          or PositiveNumber
PositiveNumber = DecimalNumber
              or DecimalNumber . Digits
              or DecimalNumber . Digits ExponentPart
              or DecimalNumber ExponentPart
DecimalNumber = 0
             or OneToNine Digits
ExponentPart = e Exponent
            or E Exponent
Exponent = Digits
        or + Digits
        or - Digits
Digits = Digit
      or Digits Digit
Digit = 0 through 9
OneToNine = 1 through 9

JSONString = ""
          or " StringCharacters "
StringCharacters = StringCharacter
                or StringCharacters StringCharacter
StringCharacter = any character
                  except " or \ or U+0000 through U+001F
               or EscapeSequence
EscapeSequence = \" or \/ or \\ or \b or \f or \n or \r or \t
              or \u HexDigit HexDigit HexDigit HexDigit
HexDigit = 0 through 9
        or A through F
        or a through f

JSONObject = { }
          or { Members }
Members = JSONString : JSON
       or Members , JSONString : JSON

JSONArray = [ ]
         or [ ArrayElements ]
ArrayElements = JSON
             or ArrayElements , JSON
```

Espaços em branco podem estar presentes em qualquer lugar, exceto dentro de um JSONNumber (números não devem conter espaço em branco) ou JSONString (onde ele é interpretado como o caractere correspondente na string, ou causaria um erro). O caractere de tabulação (U+0009), retorno de carro (U+000D), retorno de linha (U+000A), e espaço (U+0020) são os únicos caracteres em branco válidos.

Métodos
-------

`JSON.parse()`

Analisar uma seqüência como JSON, opcionalmente transformar o valor produzido e suas propriedades, e retornar o valor.

`JSON.stringify()`

Retorna uma string JSON correspondente ao valor especificado, opcionalmente, pode incluir apenas determinados propriedades ou substituir valores de propriedade de acordo com a definição feita pelo usuário.

Polyfill
--------

O objeto JSON não é suportado em navegadores mais antigos. Você pode contornar este problema inserindo o seguinte código no início de seus scripts, permitindo o uso de JSON e navegadores sem suporte (como Internet Explorer 6).

O algoritmo a seguir é uma imitação do objeto nativo JSON:

```js
if (!window.JSON) {
  window.JSON = {
    parse: function (sJSON) {
      return eval("(" + sJSON + ")");
    },
    stringify: (function () {
      var toString = Object.prototype.toString;
      var isArray =
        Array.isArray ||
        function (a) {
          return toString.call(a) === "[object Array]";
        };
      var escMap = {
        '"': '\\"',
        "\\": "\\\\",
        "\b": "\\b",
        "\f": "\\f",
        "\n": "\\n",
        "\r": "\\r",
        "\t": "\\t",
      };
      var escFunc = function (m) {
        return (
          escMap[m] ||
          "\\u" + (m.charCodeAt(0) + 0x10000).toString(16).substr(1)
        );
      };
      var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g;
      return function stringify(value) {
        if (value == null) {
          return "null";
        } else if (typeof value === "number") {
          return isFinite(value) ? value.toString() : "null";
        } else if (typeof value === "boolean") {
          return value.toString();
        } else if (typeof value === "object") {
          if (typeof value.toJSON === "function") {
            return stringify(value.toJSON());
          } else if (isArray(value)) {
            var res = "[";
            for (var i = 0; i < value.length; i++)
              res += (i ? ", " : "") + stringify(value[i]);
            return res + "]";
          } else if (toString.call(value) === "[object Object]") {
            var tmp = [];
            for (var k in value) {
              if (value.hasOwnProperty(k))
                tmp.push(stringify(k) + ": " + stringify(value[k]));
            }
            return "{" + tmp.join(", ") + "}";
          }
        }
        return '"' + value.toString().replace(escRE, escFunc) + '"';
      };
    })(),
  };
}
```

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

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

Navegador compatível
--------------------

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

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

* `Date.prototype.toJSON()`


Intl - JavaScript

Intl
====

O objeto **`Intl`** é o namespace para a API de Internacionalização do ECMAScript , que fornece comparação de string sensível à línguagem, formatação de números, e formatação de data e hora. Os construtores para os objetos `Collator` (en-US), `NumberFormat`, e `DateTimeFormat` (en-US) são propriedades do objecto `Intl`. Esta página documenta essas propriedades, bem como funcionalidades comuns aos construtores de internacionalização e outras funções sensíveis de linguagem.

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

`Intl.Collator` (en-US)

Construtor para *collators*, objetos que permitem comparação de string sensível a linguagem.

`Intl.DateTimeFormat` (en-US)

Construtor para objetos que permitem formatação de data e hora sensível a linguagem.

`Intl.NumberFormat`

Construtor para objetos que permitem formatação de número sensível a linguagem.

Métodos
-------

`Intl.getCanonicalLocales()` (en-US)

Retorna os nomes canônicos de local (ex.: en-US, pt-BR).

Identificação e negociação de local
-----------------------------------

Os construtores de internacionalização, assim como diversos métodos de outros construtores que são sensíveis a idioma (listados em Veja também) usam um padrão comum para identificar locais e determinar qual será utilizado: todos aceitam argumentos `locales` e `options` e negociam o(s) local(is) requisitado entre os locais suportados usando um algoritmo especificado na propriedade `options.localeMatcher`.

### Argumento `locales`

O argumento `locales` deve ser uma string contendo uma tag de linguagem BCP 47 ou um array dessas tags. Se o argumento `locales` não for passado ou estiver indefinido, será utilizado o local padrão do runtime.

Uma tag de linguagem BCP 47 identifica um idioma ou local (a diferença entre ambos neste caso é difusa). Em sua forma mais comum, ela pode conter, nesta ordem: um código de idioma, um código de escrita e um código de país, todos eparados por hífen. Exemplos:

* `"hi"`: Hindi.
* `"de-AT"`: Alemão como usado na Áustria.
* `"zh-Hans-CN"`: Chinês com escrita simplificada como usado na China.

As subtags identificando idiomas, escritas, países (regiões) e (raramente utilizadas) variantes nas tags de linguagem BCP 47 podem ser consultadas no Registro de Subtags de Linguagem da IANA.

BCP 47 também permite extensões, e uma delas é relevante para as funções JavaScript de internacionalização: a extensão `"u"` (Unicode). Ela pode ser utilizada para requisitar uma customização do comportamento específico local de um objeto `Collator` (en-US), `NumberFormat`, ou `DateTimeFormat` (en-US). Exemplos:

* `"de-DE-u-co-phonebk"`: Use the phonebook variant of the German sort order, which expands umlauted vowels to character pairs: ä → ae, ö → oe, ü → ue.
* `"th-TH-u-nu-thai"`: Use Thai digits (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) in number formatting.
* `"ja-JP-u-ca-japanese"`: Use the Japanese calendar in date and time formatting, so that 2013 is expressed as the year 25 of the Heisei period, or 平成 25.
### Locale negotiation

The `locales` argument, after stripping off all Unicode extensions, is interpreted as a prioritized request from the application. The runtime compares it against the locales it has available and picks the best one available. Two matching algorithms exist: the `"lookup"` matcher follows the Lookup algorithm specified in BCP 47; the `"best fit"` matcher lets the runtime provide a locale that's at least, but possibly more, suited for the request than the result of the Lookup algorithm. If the application doesn't provide a `locales` argument, or the runtime doesn't have a locale that matches the request, then the runtime's default locale is used. The matcher can be selected using a property of the `options` argument (see below).

If the selected language tag had a Unicode extension substring, that extension is now used to customize the constructed object or the behavior of the function. Each constructor or function supports only a subset of the keys defined for the Unicode extension, and the supported values often depend on the language tag. For example, the `"co"` key (collation) is only supported by `Collator` (en-US), and its `"phonebk"` value is only supported for German.

### `options` argument

The `options` argument must be an object with properties that vary between constructors and functions. If the `options` argument is not provided or is undefined, default values are used for all properties.

One property is supported by all language sensitive constructors and functions: The `localeMatcher` property, whose value must be a string `"lookup"` or `"best fit"` and which selects one of the locale matching algorithms described above.

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # intl-object |

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

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

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

* Introduction: The ECMAScript Internationalization API
* Constructors
    + `Intl.Collator` (en-US)
    + `Intl.DateTimeFormat` (en-US)
    + `Intl.NumberFormat`
* Methods
    + `String.prototype.localeCompare()`
    + `Number.prototype.toLocaleString()`
    + `Date.prototype.toLocaleString()` (en-US)
    + `Date.prototype.toLocaleDateString()`
    + `Date.prototype.toLocaleTimeString()`


Símbolo - JavaScript

Símbolo
=======

Sumário
-------

A função `Symbol()` retorna um valor do tipo **símbolo (symbol)**, tem propriedades estáticas que expõem vários membros dos objetos nativos, possuem métodos estáticos que expõem o registro de símbolos globais e se parecem com uma classe de objeto nativo, mas estão incompletos como construtor porque não suportam a sintaxe "`new Symbol()`".

Cada valor símbolo retornado de `Symbol()` é único. Um símbolo pode ser usado como o identificador para propriedades de objetos; esse é o único propósito do tipo de dado. Algumas explicações sobre propósito e uso podem ser encontradas no verbete do glossário para Symbol.

O tipo de dado **símbolo** é um tipo de dado primitivo.

Sintaxe
-------
```

Symbol([descrição])
```

### Parâmetros

`descrição` Optional

String opcional. Uma descrição de símbolo no qual pode ser usado para debugar, mas não para acessar o próprio símbolo.

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

Para criar um novo símbolo primitivo, simplesmente escreva `Symbol()` com uma string opcional para sua descrição:

```js
var sym1 = Symbol();
var sym2 = Symbol("foo");
var sym3 = Symbol("foo");
```

O código acima cria três símbolos novos. Note que a função ***Symbol("foo")*** não faz a string ***"foo"*** ser um símbolo. Ela cria um novo símbolo a cada vez que é chamada:

```js
Symbol("foo") === Symbol("foo"); // false
```

A sintaxe a seguir com o operador `new` vai resultar em um `TypeError`:

```js
var sym = new Symbol(); // TypeError
```

Isso evita que os autores criem um objeto empacotador explícito de `Symbol` em vez de um novo valor de símbolo. O que pode surpreender, pois, geralmente é possível criar objetos empacotadores explícitos em torno de tipos de dados primitivos (por exemplo, `new Boolean`, `new String` e `new Number`).

Se você realmente quiser criar um objeto empacotador de `Symbol`, você pode usar a função `Object()`:

```js
var sym = Symbol("foo");
typeof sym; // "symbol"
var symObj = Object(sym);
typeof symObj; // "object"
```

### Símbolos compartilhados no registro global de símbolo

A sintaxe acima usando a função `Symbol()` não criará um símbolo global que estará disponível em todo o seu código. Para criar símbolos disponíveis em vários arquivos em um escopo como se fosse global, use os métodos `Symbol.for()` (en-US) e `Symbol.keyFor()` (en-US) para definir e configurar símbolos no registro global de símbolo.

### Encontrando propriedades de símbolos em objetos

O método `Object.getOwnPropertySymbols()` retorna um array de símbolos e permite que você encontre propriedades de símbolos em um determinado objeto. Observe que cada objeto é inicializado sem suas próprias propriedades de símbolo, de modo que este array estará vazio, a menos que você estabeleça propriedades de símbolo no objeto.

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

`Symbol.length`

Propriedade de tamanho cujo valor é 1.

`Symbol.prototype` (en-US)

Representa o protótipo do `Symbol` construtor.

### Símbolos conhecidos

Em adição para seus próprios símbolos, JavaScript possui alguns símbolos built-in que representa os comportamentos internos da linguagem que não foram revelados para os desenvolvedores no ECMAScript 5 e anterior. Esses símbolos podem ser acessados usando as seguintes propriedades:

Symbol.hasInstance

Especificado como @@hasInstance. Um método que determina se um construtor de um objeto é reconhecido como a instância de um objeto. Usado por `instanceof`.

Symbol.isConcatSpreadable

Especificado como @@isConcatSpreadable. Um valor Booleano indicando se um objeto deve ser adicionado como elemento de uma array. Usado por `Array.prototype.concat()`.

Symbol.isRegExp

Especificado como @@isRegExp. Um valor Booleano indicando se um objeto pode ser usado como uma expressão regular.

Symbol.iterator

Especificado como @@iterator. Um método retornando o iterador padrão para um objeto. Usado por `for...of`.

Symbol.toPrimitive

Especificado como @@toPrimitive. Um método convertendo um objeto para um valor primitivo.

Symbol.toStringTag

Especificado como @@toStringTag. Um valor string usado para descrição padrão de um objeto. Usado por `Object.prototype.toString()`

Symbol.unscopables

Especificado como @@unscopables. Uma Array com valores string que são valores propriedade. Esses são excluídos das ligações com o objeto associado.

Métodos
-------

`Symbol.for(key)` (en-US)

Procura por símbolos existentes com as chaves dada e retorna as chaves se forem encontradas. Caso contrário um novo símbolo será criado no registro de símbolo global com essa chave.

`Symbol.keyFor(sym)` (en-US)

Retorna um símbolo compartilhado do registro global de símbolo para o símbolo dado.

`Symbol` protótipo
------------------

Todos os símbolos herdados de `Symbol.prototype` (en-US).

### Propriedades

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

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

### Usando o operador `typeof` com símbolos

O operador `typeof` pode ajudar a identificar os símbolos.

```js
typeof Symbol() === "symbol";
typeof Symbol("foo") === "symbol";
typeof Symbol.iterator === "symbol";
```

### Conversões de tipos de símbolos

Algumas anotações quando trabalhando com conversão de tipo de símbolos.

* Quando estiver tentando converter um símbolo para um número, um `TypeError` será retornado.
 (e.g. `+sym` or `sym | 0`).
* Quando usando operador de igualdade, `Object(sym) == sym` retorna `true`.
* `Symbol("foo") + "bar"` lança um `TypeError` (não pode converter um símbolo para string). Isso previne você de silenciosamente criar um novo nome de propriedade string a partir de um símbolo, por exemplo.
* A "safer" `String(sym)` conversion funciona como uma chamada para `Symbol.prototype.toString()` (en-US) com símbolos, mas note que uma `new String(sym)` será lançada.
### Símbolos e `for...in` iteração

Símbolos não são visíveis em `for...in` iterações. Além de, `Object.getOwnPropertyNames()` não retornará propriedades do objeto símbolo, entretanto, você pode fazer uso do `Object.getOwnPropertySymbols()` para conseguir esses resultados.

```js
var obj = {};

obj[Symbol("a")] = "a";
obj[Symbol.for("b")] = "b";
obj["c"] = "c";
obj.d = "d";

for (var i in obj) {
  console.log(i); // logs "c" and "d"
}
```

### Símbolos e `JSON.stringify()`

Propriedade com chave de símbolo vão ser completamente ignoradas quando usando `JSON.stringify()`:

```js
JSON.stringify({ [Symbol("foo")]: "foo" });
// '{}'
```

Para mais detalhes, veja `JSON.stringify()`.

### Objeto wrapper de símbolo como chave de propriedade

Quando um objeto wrapper de um símbolo é usado como uma chave de propriedade, esse objeto será coerced para o seu símbolo wrapper:

```js
var sym = Symbol("foo");
var obj = { [sym]: 1 };
obj[sym]; // 1
obj[Object(sym)]; // still 1
```

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

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

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

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

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

* Glossary: Symbol data type
* `typeof`
* Data types and data structures