Array.prototype.every() - JavaScript

Array.prototype.every()
=======================

O método `every()` testa se todos os elementos do array passam pelo teste implementado pela função fornecida. Este método retorna um valor booleano.

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

Sintaxe
-------
```

arr.every(callback[, thisArg])
```

### Parâmetros

`callback`

Função que testa cada elemento, recebe três parametros:

`currentValue` (obrigatório)

O elemento atual sendo processado na array.

`index` (opcional)

O índice do elemento atual sendo processado na array.

`array` (opcional)

O array de origem.

`thisArg`

Opcional. Valor a ser usado como `this` quando o `callback` é executado.

### Valor de retorno

**true** se a função de callback retorna um valor truthy para cada um dos elementos do array; caso contrário, **false**.

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

O método `every` executa a função `callback` fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor false (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o método `every` imediatamente retorna false. Caso contrário, se a função `callback` retornar true para todos elementos, o método retorna true. A função `callback` é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.

A função `callback` é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.

Se o parâmetro `thisArg` foi passado para o método `every`, ele será repassado para a função `callback` no momento da chamada para ser utilizado como o `this`. Caso contrário, o valor `undefined` será repassado para uso como o *`this`*. O valor do `this` a ser repassado para o `callback` é determinado de acordo com as regras usuais para determinar o this visto por uma função.

O método `every`não modifica o array original.

A lista de elementos que serão processados pelo `every` é montada antes da primeira chamada da função `callback`. Se um elemento for acrescentado ao array original após a chamada ao `every` , ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método `every` chamar o `callback`. Elementos removidos não serão considerados.

`every` funciona como o qualificador "for all" em matemática. Particularmente, para um vetor vazio, é retornado true. (É verdade por vacuidade que todos os elementos do conjunto vazio satisfazem qualquer condição.)

Exemplos
--------

### Testando tamanho de todos os elementos do vetor

O exemplo a seguir testa se todos elementos no array são maiores que 10.

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough); // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
```

### Usando arrow functions

Arrow functions fornecem sintaxe mais curta para o mesmo teste.

```js
[12, 5, 8, 130, 44].every((elem) => elem >= 10); // false
[12, 54, 18, 130, 44].every((elem) => elem >= 10); // true
```

Polyfill
--------

`every` foi adicionado ao padrão ECMA-262 na 5ª edição; como tal, pode não estar presente em outras implementações do padrão. Você pode contornar isso adicionando o seguinte código no começo dos seus scripts, permitindo o uso de every em implementações que não o suportam nativamente. Esse algoritimo é exatamente o mesmo especificado no ECMA-262, 5ª edição, assumindo que `Object` e `TypeError` tem os seus valores originais e que `callbackfn.call` retorna o valor original de `Function.prototype.call`

```js
if (!Array.prototype.every) {
  Array.prototype.every = function (callbackfn, thisArg) {
    "use strict";
    var T, k;

    if (this == null) {
      throw new TypeError("this is null or not defined");
    }

    // 1. Let O be the result of calling ToObject passing the this
    // value as the argument.
    var O = Object(this);

    // 2. Let lenValue be the result of calling the Get internal method
    // of O with the argument "length".
    // 3. Let len be ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
    if (typeof callbackfn !== "function") {
      throw new TypeError();
    }

    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
    if (arguments.length > 1) {
      T = thisArg;
    }

    // 6. Let k be 0.
    k = 0;

    // 7. Repeat, while k < len
    while (k < len) {
      var kValue;

      // a. Let Pk be ToString(k).
      // This is implicit for LHS operands of the in operator
      // b. Let kPresent be the result of calling the HasProperty internal
      // method of O with argument Pk.
      // This step can be combined with c
      // c. If kPresent is true, then
      if (k in O) {
        // i. Let kValue be the result of calling the Get internal method
        // of O with argument Pk.
        kValue = O[k];

        // ii. Let testResult be the result of calling the Call internal method
        // of callbackfn with T as the this value and argument list
        // containing kValue, k, and O.
        var testResult = callbackfn.call(T, kValue, k, O);

        // iii. If ToBoolean(testResult) is false, return false.
        if (!testResult) {
          return false;
        }
      }
      k++;
    }
    return true;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.every |

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

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

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

* `Array.prototype.forEach()`
* `Array.prototype.some()`
* `TypedArray.prototype.every()` (en-US)


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

Array.prototype[@@iterator]()
=============================

O valor inicial da propriedade **`@@iterator`** é o mesmo objeto função que o valor inicial da propriedade `values()`.

Sintaxe
-------
```

arr[Symbol.iterator]()
```

Exemplos
--------

### Iteração usando laço `for...of`

```js
var arr = ["w", "y", "k", "o", "p"];
// seu navegador deve suportar laço for..of
// e variáveis de escopo let em laços for
for (let letter of arr) {
  console.log(letter);
}
```

### Iteração alternativa

```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

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

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

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

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

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

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.values()`


Array.prototype.lastIndexOf() - JavaScript

Array.prototype.lastIndexOf()
=============================

O método **`lastIndexOf()`** retorna o ultimo índice que um certo elemento pode ser encontrado no array, ou -1 se o elemento não estiver presente. O array é pesquisado de trás para frente, começando pelo `fromIndex`.

Sintaxe
-------
```

arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
```

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

`searchElement`

Elemento para ser localizado no array.

`fromIndex`

Opcional. O índice ao qual a busca será iniciada de traz para frente. O valor padrão é o tamanho total do array menos um (array.length -1), ou seja, todo o array será pesquisado. Se o índice for maior ou igual ao tamanho do array, o array inteiro será pesquisado. Se for negativo, ele é tomado como deslocamento no final do array. Note que mesmo se o índice for negativo, o array ainda será pesquisado de traz para frente. Se o índice calculado for menor que 0, -1 será retornado, ou seja, o array não será pesquisado.

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

`lastIndexOf` compara `searchElement` a elementos do Array usando igualdade rigorosa (en-US) (o mesmo método usado pelo operador ===, ou "igual triplo").

Exemplos
--------

### Exemplo: Usando `lastIndexOf`

O seguinte exemplo utiliza `lastIndexOf` para localizar elementos em um array.

```js
var array = [2, 5, 9, 2];
array.lastIndexOf(2); // 3
array.lastIndexOf(7); // -1
array.lastIndexOf(2, 3); // 3
array.lastIndexOf(2, 2); // 0
array.lastIndexOf(2, -2); // 0
array.lastIndexOf(2, -1); // 3
```

### Exemplo: Encontrando todas as ocorrências de um elemento

O seguinte exemplo utiliza `lastIndexOf` para encontrar todos os índices de um elemento em um dado array, utilizando `push` para adicioná-los em outro array quando são encontrados.

```js
var indices = [];
var array = ["a", "b", "a", "c", "a", "d"];
var element = "a";
var idx = array.lastIndexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = idx > 0 ? array.lastIndexOf(element, idx - 1) : -1;
}

console.log(indices);
// [4, 2, 0]
```

Note que devemos tratar o caso `idx == 0` separadamente aqui pois o elemento será sempre encontrado independente do parâmetro `fromIndex` se ele for o primeiro elemento do array. Isso é diferente do método `indexOf`.

Polyfill
--------

`lastIndexOf` foi adicionado ao padrão ECMA-262 na 5ª edição; devido a isso, não deve estar presente em outras implementações do padrão. Você pode contornar isso inserindo o seguinte código no início dos seus scripts, permitindo o uso de `lastIndexOf` em implementações que não o suportam nativamente. Esse algorítimo é exatamente o mesmo especificado no padrão ECMA-262, 5ª edição, assumindo que `Object`, `TypeError`, `Number`, `Math.floor`, `Math.abs`, e `Math.min` possuem seus valores originais.

```js
// Production steps of ECMA-262, Edition 5, 15.4.4.15
// Reference: http://es5.github.io/#x15.4.4.15
if (!Array.prototype.lastIndexOf) {
  Array.prototype.lastIndexOf = function (searchElement /\*, fromIndex\*/) {
    "use strict";

    if (this === void 0 || this === null) {
      throw new TypeError();
    }

    var n,
      k,
      t = Object(this),
      len = t.length >>> 0;
    if (len === 0) {
      return -1;
    }

    n = len - 1;
    if (arguments.length > 1) {
      n = Number(arguments[1]);
      if (n != n) {
        n = 0;
      } else if (n != 0 && n != 1 / 0 && n != -(1 / 0)) {
        n = (n > 0 || -1) \* Math.floor(Math.abs(n));
      }
    }

    for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {
      if (k in t && t[k] === searchElement) {
        return k;
      }
    }
    return -1;
  };
}
```

Novamente, perceba que essa implementação foca na absoluta compatibilidade com `lastIndexOf` no Firefox e no motor JavaScript SpiderMonkey, incluíndo vários casos que são, indiscutivelmente, extremos. Se você pretende usar isso em aplicações reais, é possível calcular `from` com um código menos complicado se você ignorar esses casos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.lastindexof |

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

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

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

* `Array.prototype.indexOf()`
* `TypedArray.prototype.lastIndexOf()` (en-US)


Array.prototype.reverse() - JavaScript

Array.prototype.reverse()
=========================

Resumo
------

O método **`reverse()`** inverte os itens de um array. O primeiro elemento do array se torna o último e o último torna-se o primeiro.

Sintaxe
-------
```

arr.reverse()
```

### Parâmetros

Nenhum.

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

O método `reverse` transpõe os elementos do objeto array no mesmo lugar, mutando o array, e retornando uma referência para o mesmo.

Exemplos
--------

### Exemplo: Invertendo os elementos em um array

O seguinte exemplo cria um array `myArray`, contendo três elementos, em seguida inverte-o.

```js
var myArray = ["one", "two", "three"];
myArray.reverse();

console.log(myArray); // ['three', 'two', 'one']
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reverse |

Compatibilidade com navegador
-----------------------------

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

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

* `Array.prototype.join()`
* `Array.prototype.sort()`
* `TypedArray.prototype.reverse()` (en-US)


Array.prototype.sort() - JavaScript

Array.prototype.sort()
======================

O método **`sort()`** ordena os elementos do próprio array e retorna o array. A ordenação não é necessariamente estável. A ordenação padrão é de acordo com a pontuação de código unicode.

A complexidade do tempo de execução ou a quantidade de memória utilizada pela ordenação não pode ser garantido e depende da implementação realizada.

Sintaxe
-------
```

arr.sort([funcaoDeComparacao])
```

### Parâmetros

`funcaoDeComparacao` Optional

Especifica uma função que define a ordenação. Se omitido, o array é ordenado de acordo com a pontuação de código Unicode de cada um dos caracteres, de acordo com a conversão de cada elemento para string.

`primeiroElemento`

O primeiro elemento para a comparação.

`segundoElemento`

O segundo elemento para comparação.

### Valor de Retorno

O array ordenado. Note que o array é ordenado de acordo com a pontuação de código Unicode de cada um dos caracteres, e nenhuma cópia é feita.

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

Se **`funcaoDeComparacao`** não for informado, os elementos serão ordenados de acordo com a sua conversão para texto e o texto comparado na pontuação unicode do texto convertido. Por exemplo, "banana" vem antes de "cherry". Em uma ordenação numérica, 9 vem antes de 80, mas porque os números são convertidos para texto e, "80" vem antes de "9" na ordenação Unicode.

```js
var fruit = ["cherries", "apples", "bananas"];
fruit.sort(); // ['apples', 'bananas', 'cherries']

var scores = [1, 10, 2, 21];
scores.sort(); // [1, 10, 2, 21]
// Observe que 10 vem antes do 2,
// porque '10' vem antes de '2' em ponto de código Unicode.

var things = ["word", "Word", "1 Word", "2 Words"];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// Em Unicode, números vêem antes de letras maiúsculas,
// as quais vêem antes das minúsculas.
```

Se o parametro `funcaoDeComparacao` é fornecido, o array será ordenado de acordo com o valor de retorno da `funcaoDeComparacao`. Considerando que `a` e `b` são dois elementos sendo comparados, então:

* Se `funcaoDeComparacao(a, b)` for menor que 0, ordena `a` para um índice anterior a `b`, i.e. a vem primeiro.
* Se `funcaoDeComparacao(a, b)` retornar 0, deixa `a` e `b` inalterados em relação um ao outro, mas ordenado em relação a todos os outros elementos. Nota: O padrão ECMAscript não garante este comportamento, e, portanto, nem todos os navegadores (e.g. Versões do Mozilla anteriores a 2003) respeitarão isto.
* Se `funcaoDeComparacao(a, b)` é maior que 0, ordena b para um índice anterior que a.
* `funcaoDeComparacao(a, b)` sempre deve retornar o mesmo valor dado um par específico de elementos a e b como seus dois parametros. Se resultados inconsistentes são retornados, então a ordenação é indefinida.

Então, a função de comparação tem a seguinte forma:

```js
function comparar(a, b) {
  if (a é menor que b em algum critério de ordenação) {
    return -1;
  }
  if (a é maior que b em algum critério de ordenação) {
    return 1;
  }
  // a deve ser igual a b
  return 0;
}
```

Para comparar números ao invés de texto, a função de comparação pode simplesmente subtrair b de a. A função abaixo irá ordenar o array em ordem crescente:

```js
function compararNumeros(a, b) {
  return a - b;
}
```

O método de ordenação pode convenientemente ser usada com funções anônimas (e closures):

```js
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function (a, b) {
  return a - b;
});
console.log(numbers);
```

Objetos podem ser ordenados de acordo com o valor de uma de suas propriedades.

```js
var items = [
  { name: "Edward", value: 21 },
  { name: "Sharpe", value: 37 },
  { name: "And", value: 45 },
  { name: "The", value: -12 },
  { name: "Magnetic" },
  { name: "Zeros", value: 37 },
];
items.sort(function (a, b) {
  if (a.name > b.name) {
    return 1;
  }
  if (a.name < b.name) {
    return -1;
  }
  // a must be equal to b
  return 0;
});
```

Exemplos
--------

### Criando, exibindo, e ordenando um array

O exemplo abaixo cria quatro arrays e mostra seu conteúdo original, então o conteúdo dos arrays ordenado. Os arrays numéricos são ordenados sem a função de comparação, e então, com a função.

```js
var stringArray = ["Blue", "Humpback", "Beluga"];
var numericStringArray = ["80", "9", "700"];
var numberArray = [40, 1, 5, 200];
var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];

function compararNumeros(a, b) {
  return a - b;
}

console.log("stringArray:", stringArray.join());
console.log("Ordenada:", stringArray.sort());

console.log("numberArray:", numberArray.join());
console.log("Ordenada sem função de comparação:", numberArray.sort());
console.log("Ordenada com compararNumeros:", numberArray.sort(compararNumeros));

console.log("numericStringArray:", numericStringArray.join());
console.log("Ordenada sem função de comparação:", numericStringArray.sort());
console.log(
  "Ordenada com compararNumeros:",
  numericStringArray.sort(compararNumeros),
);

console.log("mixedNumericArray:", mixedNumericArray.join());
console.log("Ordenada sem função de comparação:", mixedNumericArray.sort());
console.log(
  "Ordenada com compararNumeros:",
  mixedNumericArray.sort(compararNumeros),
);
```

Este exemplo gera a saída abaixo. Como as saídas mostram, quando a função de comparação é usada, os números são ordenados corretamente, sejam eles números ou strings numéricas.
```

stringArray: Blue,Humpback,Beluga
Ordenada: Beluga,Blue,Humpback

numberArray: 40,1,5,200
Ordenada sem função de comparação: 1,200,40,5
Ordenada com compararNumeros: 1,5,40,200

numericStringArray: 80,9,700
Ordenada sem função de comparação: 700,80,9
Ordenada com compararNumeros: 9,80,700

mixedNumericArray: 80,9,700,40,1,5,200
Ordenada sem função de comparação: 1,200,40,5,700,80,9
Ordenada com compararNumeros: 1,5,9,40,80,200,700
```

### Ordenando caracteres não-ASCII

Para ordenar strings com caracteres não-ASCII, i.e. strings com caracteres acentuados (e, é, è, a, ä, etc.), strings de línguas diferentes do Inglês: use `String.localeCompare`. Esta função pode comparar estes caracteres, então eles aparecerão na ordem correta.

```js
var items = ["réservé", "premier", "cliché", "communiqué", "café", "adieu"];
items.sort(function (a, b) {
  return a.localeCompare(b);
});

// items é ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
```

### Ordenando com mapa

A `funcaoDeComparacao` pode ser invocada múltiplas vezes por elemento do array. Dependendo da natureza da `funcaoDeComparacao`, isto pode causar um excesso processamento. Quanto mais trabalho a `funcaoDeComparacao` fizer, e quanto mais elementos houverem para ordenar, seria mais inteligente considerar o uso de um mapa para a ordenação. A idéia é percorrer o array uma vez para extrair os valores já processados para a ordenação e armazenar em um array temporário, ordenar o array temporário e então percorrer o array temporário para conseguir a ordenação correta.

```js
// o array a ser ordenado
var list = ["Delta", "alpha", "CHARLIE", "bravo"];

// array temporário que armazena os objetos com o índice e o valor para ordenação
var mapped = list.map(function (el, i) {
  return { index: i, value: el.toLowerCase() };
});

// ordenando o array mapeado contendo os dados resumidos
mapped.sort(function (a, b) {
  return +(a.value > b.value) || +(a.value === b.value) - 1;
});

// container para o resultado ordenado
var result = mapped.map(function (el) {
  return list[el.index];
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.sort |

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

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

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

* `Array.prototype.reverse()`
* `String.prototype.localeCompare()`


Intl.Collator - JavaScript

Intl.Collator
=============

O objeto **`Intl.Collator`** permite uma comparação de strings sensível à linguagem.

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

Construtor
----------

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

Cria um novo objeto `Collator`.

Métodos estáticos
-----------------

`Intl.Collator.supportedLocalesOf()` (en-US)

Retorna um array contendo as localizações (`locales`) providas que são suportados sem a necessidade de depender da localização padrão do runtime.

Métodos de instância
--------------------

`Intl.Collator.prototype.compare` (en-US)

Função Getter que compara duas strings conforme a ordenação deste objeto `Intl.Collator`.

`Intl.Collator.prototype.resolvedOptions()` (en-US)

Retorna um novo objeto com as propriedades que refletem as opções de localização (`locale`) e agrupamento (`collation`) computadas durante a inicialização do objeto.

Exemplos
--------

### Usando Collator

O exemplo a seguir demonstra os diferentes potenciais resultados para uma string que aparece antes, depois, ou no mesmo nível que outra:

```js
console.log(new Intl.Collator().compare("a", "c")); // -1, ou algum outro valor negativo
console.log(new Intl.Collator().compare("c", "a")); // 1, ou algum outro valor positivo
console.log(new Intl.Collator().compare("a", "a")); // 0
```

É importante notar que os resultados mostrados no código acima podem variar entre navegadores e versões de navegadores. Isso por os valores serem específicos a implementação. Isso ocorre, pois a implementação define somente que os valores para antes e depois sejam negativo e positivo.

### Usando localizações

Os resultados retornados por `Intl.Collator.prototype.compare()` (en-US) variam entre linguagens. Para obter a sequência de ordenação da linguagem usada na interface da sua aplicação, garanta a especificação desta linguagem (e possivelmente algumas linguagens reserva) usando o argumento `locales`:

```js
// Em alemão, ä está no mesmo nível de a
console.log(new Intl.Collator("de").compare("ä", "z"));
// -1, ou algum outro valor negativo

// Em Sueco, ä vem depois de z
console.log(new Intl.Collator("sv").compare("ä", "z"));
// 1, ou algum outro valor positivo
```

### Usando opções

Os resultados retornados por `Intl.Collator.prototype.compare()` (en-US) podem ser customizados usando o argumento `options`:

```js
// Em Alemão, ä tem a como sua letra base
console.log(new Intl.Collator("de", { sensitivity: "base" }).compare("ä", "a"));
// 0

// Em Sueco, ä e a são letras base separadas
console.log(new Intl.Collator("sv", { sensitivity: "base" }).compare("ä", "a"));
// 1, ou algum outro valor positivo
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # collator-objects |

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

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

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

* `Intl`


Intl.NumberFormat - JavaScript

Intl.NumberFormat
=================

#####

O objeto **`Intl.NumberFormat`** é um construtor para objetos que habilita formatação de número sensível a linguagem.

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

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Sintaxe
-------
```

new Intl.NumberFormat([locales[, options]])
Intl.NumberFormat.call(this[, locales[, options]])
```

### Parâmetros

`locales`

Opcional. Uma string com uma tag de linguagem BCP 47 ou uma matriz delas. Para a forma geral e interpretação do argumento `locales`, veja Intl page. A seguinte chave extendida Unicode é permitida:

`nu`

O sistema de numeração que será usado. Os valores permitidos são: `"arab"`, `"arabext"`, `"bali"`, `"beng"`, `"deva"`, `"fullwide"`, `"gujr"`, `"guru"`, `"hanidec"`, `"khmr"`, `"knda"`, `"laoo"`, `"latn"`, `"limb"`, `"mlym"`, `"mong"`, `"mymr"`, `"orya"`, `"tamldec"`, `"telu"`, `"thai"`, `"tibt"`.

`options`

Opcional. Um objeto com alguns ou todas as seguintes propriedades:

`localeMatcher`

O algoritmo de comparação de localização para utilizar. Os valores permitidos são `"lookup"` e `"best fit"`; o padrão é `"best fit"`. Para mais informações sobre esta opção, veja Intl page.

`style`

O estilo do formato a ser utilizado. Os valores permitidos são `"decimal"` para formato de número simples, `"currency"` para formato monetário e `"percent"` para formato percentual; o padrão é `"decimal"`.

`currency`

A moeda para usar na formatação monetária. Os valores permitidos são os códigos de moedas da ISO 4217, como `"USD"` para dólar estadunidense, `"EUR"` para euro, ou `"CNY"` para RMB chinês — veja a Lista de códigos de moedas e fundos atuais. Não há valor padrão; se o `style` for `"currency"`, a propriedade `currency` deverá ser informada.

`currencyDisplay`

Como será mostrada a moeda na formatação monetária. Os valores permitidos são `"symbol"` para usar um símbolo de moeda localizado como €, `"code"` para usar o código de moeda ISO, `"name"` para usar o nome da moeda localizado como `"dollar"`; o padrão é `"symbol"`.

`useGrouping`

Se usar separadores de agrupamento, como separadores de milhares ou milhares/cem mil/dez milhões. Os valores permitidos são `true` e `false`; o padrão é `true`.

As próximas propriedades se dividem em dois grupos: `minimumIntegerDigits`, `minimumFractionDigits`, e `maximumFractionDigits` no primeiro grupo, `minimumSignificantDigits` and `maximumSignificantDigits` em outro. Se pelo menos uma propriedade do segundo grupo for informado, então o primeiro grupo é ignorado.

`minimumIntegerDigits`

A quantidade mínima de dígitos inteiros para utilizar. É possível usar valores de 1 a 21; o padrão é 1.

`minimumFractionDigits`

A quantidade mínima de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para formatos de números simples e percentuais é 0; o padrão para formatos monetários é a menor unidade de dígitos fornecidos pela lista de códigos de moedas ISO 4217 (2 se a lista não fornecer a informação).

`maximumFractionDigits`

O número máximo de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para a formatação de número simples é o maior entre `minimumFractionDigits` e 3; o padrão para formatos monetários é o maior número de dígitos entre `minimumFractionDigits` e o fornecido pela lista de códigos de moedas ISO 4217 (2 se a lista não fornecer a informação); o padrão para a formatação percentual é o maior número entre `minimumFractionDigits` e 0.

`minimumSignificantDigits`

A quantidade mínima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é 1.

`maximumSignificantDigits`

A quantidade máxima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é `minimumSignificantDigits`.

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

### Propriedades

`Intl.NumberFormat.prototype` (en-US)

Pertime a inclusão de propriedades a todos os objetos.

### Métodos

`Intl.NumberFormat.supportedLocalesOf()` (en-US)

Retorna uma matriz contendo as localizações fornecidas que são suportadas sem retornar a localização padrão em tempo de execução.

Instâncias `NumberFormat`
-------------------------

### Propriedades

As instâncias de `NumberFormat` herdam as seguntes propriedades de seu protótipo:

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

As instâncias de `NumberFormat` herdam os seguintes métodos de seu protótipo:

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

### Uso básico

No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.

```js
var numero = 3500;

console.log(new Intl.NumberFormat().format(numero));
// → '3,500' se a localização for U.S. English
```

### Usando `locales`

Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento `locales`:

```js
var numero = 123456.789;

// O alemão usa vírgula como separador de decimal e ponto para milhares
console.log(new Intl.NumberFormat("de-DE").format(numero));
// → 123.456,789

// O árabe usa dígitos reais árabes em muitos países que falam árabe
console.log(new Intl.NumberFormat("ar-EG").format(numero));
// → ١٢٣٤٥٦٫٧٨٩

// A Índia usa separadores de milhares/cem mil/dez milhões
console.log(new Intl.NumberFormat("en-IN").format(numero));
// → 1,23,456.789

// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês
console.log(new Intl.NumberFormat("zh-Hans-CN-u-nu-hanidec").format(numero));
// → 一二三,四五六.七八九

// Quando informada uma língua sem suporte, como balinês,
// inclua uma língua reseva, neste caso indonésio
console.log(new Intl.NumberFormat(["ban", "id"]).format(numero));
// → 123.456,789
```

### Usando `options`

Os resultados podem ser personalizados usando o argumento `options`:

```js
var numero = 123456.789;

// informando um formato de moeda
console.log(
  new Intl.NumberFormat("de-DE", { style: "currency", currency: "EUR" }).format(
    numero,
  ),
);
// → 123.456,79 €

// o yen japonês não tem uma unidade menor
console.log(
  new Intl.NumberFormat("ja-JP", { style: "currency", currency: "JPY" }).format(
    numero,
  ),
);
// → ￥123,457

// limitando a três dígitos significativos
console.log(
  new Intl.NumberFormat("en-IN", { maximumSignificantDigits: 3 }).format(
    numero,
  ),
);
// → 1,23,000
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # numberformat-objects |

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

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

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

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Intl', 'Veja\_tambem')}}


Intl.RelativeTimeFormat - JavaScript

Intl.RelativeTimeFormat
=======================

O objeto **`Intl.RelativeTimeFormat`** é um construtor de objetos que permitem uma formatação de tempo relativa sensível ao idioma.

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

Sintaxe
-------
```

new Intl.RelativeTimeFormat([locales[, options]])
```

### Parâmetros

`locales`

Opcional. Uma string com uma tag da linguagem BCP 47, ou um array dessas strings. Para a forma geral e interpretação do argumento `locales` , acesse: Página Intl.

`options`

Opcional. Um objeto com algumas ou todas as seguintes propriedades:

* `localeMatcher`
 O algoritmo para comparação de local a ser usado. Os valores possíveis são `"lookup"` e `"best fit"`; o padrão é `"best fit"`. Para informações sobre esta opção, veja `Intl`.
* `numeric`
 O formato de saída da mensagem. Valores possíveis são:
    + `"always"` (padrão, e.g., `há 1 dia`),
    + ou `"auto"` (e.g., `ontem`). O valor`"auto"` permite que não seja sempre necessário o uso de valores númericos na saída.
* `style`
 O comprimento da mensagem internacionalizada. Valores possíveis são:
    + `"long"` (padrão, e.g., `in 1 month`)
    + `"short"` (e.g., `in 1 mo.`),
    + ou `"narrow"` (e.g., `in 1 mo.`). O estilo narrow pode ser similar ao short em alguns locais.

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

### Propriedades

`Intl.RelativeTimeFormat.prototype` (en-US)

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

### Métodos

`Intl.RelativeTimeFormat.supportedLocalesOf()` (en-US)

Retorna um array contendo os valores disponíveis dentre os que foram passados como parâmetro sem ter de recorrer ao local padrão do ambiente.

Instâncias `RelativeTimeFormat`
-------------------------------

### Propriedades

Instâncias `RelativeTimeFormat` herdam as seguintes propriedades do seu protótipo:

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

Instâncias `RelativeTimeFormat` herdam as seguintes propriedades do seu protótipo:

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

### Uso básico do `format`

O exemplo a seguir mostra como criar um formatador de tempo relativo usando a língua portuguesa.

```js
// Crie um formatador de tempo relativo no seu local
// com os valores padrão sendo passados explicitamente.
const rtf = new Intl.RelativeTimeFormat("pt", {
  localeMatcher: "best fit", // outros valores: "lookup"
  numeric: "always", // outros valores: "auto"
  style: "long", // outros valores: "short" ou "narrow"
});

// Formatação de tempo relativa usando valor negativo (-1).
rtf.format(-1, "day");
// > "há 1 dia"

// Formatação de tempo relativa usando valor positivo (1).
rtf.format(1, "day");
// > "em 1 dia"
```

### Usando a opção `auto`

Se a opção `numeric:auto` é passada, serão produzidas as strings `ontem` ou `amanhã` ao invés de `há 1 dia` ou `em 1 dia`. Isso permite que não seja necessário sempre utilizar valores numéricos na saída.

```js
// Crie um formatador de tempo relativo no seu local
// com o valor "auto" passado para a propriedade numeric.
const rtf = new Intl.RelativeTimeFormat("pt", { numeric: "auto" });

// Formatação de tempo relativa usando valor negativo (-1).
rtf.format(-1, "day");
// > "ontem"

// Formatação de tempo relativa usando valor positivo (1).
rtf.format(1, "day");
// > "amanhã"
```

### Usando `formatToParts`

O exemplo a seguir mostra como criar um formatador de tempo relativo que retorna partes formatadas

```js
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });

// Formatação de tempo relativa usando a unidade day.
rtf.formatToParts(-1, "day");
// > [{type: "literal", value: "ontem"}]

rtf.formatToParts(100, "day");
// > [{type: "literal", value: "em "},
// > { type: "integer", value: "100", unit: "day" },
// > {type: "literal", value: " dias"]
```

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

| Especificação | Estágio | Comentário |
| --- | --- | --- |
| Intl.RelativeTime proposal | Stage 3 |  |

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

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

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

* The Intl.RelativeTimeFormat API


Intl.ListFormat - JavaScript

Intl.ListFormat
===============

O objeto **`Intl.ListFormat`** habilita a formatação de lista de acordo com o idioma.

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

Construtor
----------

`Intl.ListFormat()`

Criar um novo objeto `Intl.ListFormat`.

Métodos estáticos
-----------------

`Intl.ListFormat.supportedLocalesOf()` (en-US)

Retorna um array com as localidades fornecidas com suporte sem precisar depender da localidade padrão do tempo de execução.

Métodos de instância
--------------------

`Intl.ListFormat.prototype.format()` (en-US)

Retorna uma string formatada especifica do idioma representando os elementos da lista.

`Intl.ListFormat.prototype.formatToParts()` (en-US)

Retorna um array de objetos representando os diferentes componentes que podem ser usados para formatar uma lista de valores com reconhecimento de localidade.

Exemplos
--------

### Utilizando format

O exemplo a seguir mostra como criar o List formatter utilizando o idioma Português.

```js
const list = ["Moto", "Ônibus", "Carro"];

console.log(
  new Intl.ListFormat("pt-BR", { style: "long", type: "conjunction" }).format(
    list,
  ),
);
// > Moto, Ônibus e Carro

console.log(
  new Intl.ListFormat("pt-BR", { style: "short", type: "disjunction" }).format(
    list,
  ),
);
// > Moto, Ônibus ou Carro

console.log(
  new Intl.ListFormat("pt-BR", { style: "narrow", type: "unit" }).format(list),
);
// > Moto Ônibus Carro
```

### Utilizando formatToParts

O exemplo a seguir mostra como criar o List formatter retornando as partes formatadas.

```js
const list = ["Moto", "Ônibus", "Carro"];
console.log(
  new Intl.ListFormat("pt-BR", {
    style: "long",
    type: "conjunction",
  }).formatToParts(list),
);

// [ { "type": "element", "value": "Moto" },
// { "type": "literal", "value": ", " },
// { "type": "element", "value": "Ônibus" },
// { "type": "literal", "value": ", e " },
// { "type": "element", "value": "Carro" } ];
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # listformat-objects |

Compatibilidade de browser
--------------------------

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

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

* `Intl`
* Um polyfill para `Intl.ListFormat` no FormatJS


Construtor Intl.ListFormat() - JavaScript

Construtor Intl.ListFormat()
============================

 O construtor **`Intl.ListFormat()`** cria objetos
 `Intl.ListFormat` que habilitam a formatação de lista de acordo com o idioma.

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

Sintaxe
-------

```js
new Intl.ListFormat();
new Intl.ListFormat(locales);
new Intl.ListFormat(locales, options);
```

### Parâmetros

`locales` Optional

 Uma string com a tag de idioma BCP 47, ou um array de tais string. Veja de forma geral a interpretação do argumento `locales`, na página
 Intl.

`options` Optional

Um objeto com algumas ou todas as seguintes propriedades:

`localeMatcher`

 O algoritmo de correspondência de localidade para ser utilizado. Os possíveis valores são "`lookup`"
 e "`best fit`"; o valor padrão é "`best fit`". Para mais informações sobre esta opção, veja a página Intl.

`type`

 O formato de saída da mensagem. Os possíveis valores são "`conjunction`"
 que representa listas com "e" (padrão, e.g., "`A, B, e C`"), ou
 "`disjunction`" que representa listas com "ou" (e.g.,
 "`A, B, ou C`"). "`unit`" que representa listas com valores de unidade (e.g., "`5 libras, 12 onças`").

`style`

 O tamanho da lista formatada. Os possíveis valores são: "`long`"
 (padrão, e.g., "`A, B, e C`"); "`short`" (e.g.,
 "`A, B, C`"), ou "`narrow`" (e.g., "`A B C`").
 quando `style` é "`short`" ou "`narrow`",
 "`unit`" é o único valor de tipo permitido.

Exemplos
--------

### Utilizando format

O exemplo a seguir mostra como criar um List formatter utilizando o idioma Português.

```js
const list = ["Moto", "Ônibus", "Carro"];

console.log(
  new Intl.ListFormat("pt-BR", { style: "long", type: "conjunction" }).format(
    list,
  ),
);
// > Moto, Ônibus e Carro

console.log(
  new Intl.ListFormat("pt-BR", { style: "short", type: "disjunction" }).format(
    list,
  ),
);
// > Moto, Ônibus ou Carro

console.log(
  new Intl.ListFormat("pt-BR", { style: "narrow", type: "unit" }).format(list),
);
// > Moto Ônibus Carro
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-listformat-constructor |

Compatibilidade de browsers
---------------------------

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

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

* `Intl.ListFormat`
* `Intl`


Promise.prototype.catch() - JavaScript

Promise.prototype.catch()
=========================

O método **catch()** retorna uma Promise e lida apenas com casos rejeitados. Ele possui o mesmo comportamento de quando chamamos `Promise.prototype.then(undefined, onRejected)` (de fato, chamando `obj.catch(onRejected)` internamente é chamado `obj.then(undefined, onRejected)`).Sintaxe
-------
```

p.catch(onRejected);

p.catch(function(motivo) {
   // rejeição
});
```

### Parâmetros

onRejected

 Uma `Function` chamada quando a `Promise` é rejeitada. Esta função possui um argumento:
 **reason** da rejeição.
 O motivo da rejeição.

A Promise retornada pelo `catch()` é rejeitada apenas se `onRejected` cospe um erro ou se o o retorno da Promise foi rejeitada por si mesmo, ou seja, foi resolvida.

### Valor de retorno

Internamente chamamos `Promise.prototype.then` sobre o objeto que é chamando passando parâmetros como `undefined` e `onRejected` no manipulador de eventos. Então retornamos o valor da chamada que é `Promise`.

**Aviso:** O exemplo abaixo está cuspindo uma string. Isso é considerado uma má prática. Sempre cuspir uma instance de erro (Error). Em todo caso, a parte que faz a captura deve fazer verificaçoes sobre os argumentos para saber se é uma string ou um erro e você poderá perder informações valiosas como stack traces.

**Demonstração de uma camada interna:**

```js
// Sobrescrevendo o techo original de Promise.prototype.then/catch adicionando alguns logs
(function (Promise) {
  var originalThen = Promise.prototype.then;
  var originalCatch = Promise.prototype.catch;

  Promise.prototype.then = function () {
    console.log(
      "> > > > > > chamando .then em %o com argumentos: %o",
      this,
      arguments,
    );
    return originalThen.apply(this, arguments);
  };
  Promise.prototype.catch = function () {
    console.log(
      "> > > > > > chamando .catch em %o com argumentos: %o",
      this,
      arguments,
    );
    return originalCatch.apply(this, arguments);
  };
})(this.Promise);

// chamando um catch em uma Promise já resolvida.
Promise.resolve().catch(function XXX() {});

// logs:
// > > > > > > chamando .catch na Promise{} com os argumentos: Arguments{1} [0: function XXX()]
// > > > > > > chamando .then na Promise{} com os argumentos: Arguments{2} [0: undefined, 1: function XXX()]
```

Description
-----------

O método `catch` pode ser útil para manipulação de erros na composição da sua promise.

Exemplos
--------

### Usando o método `catch`

```js
var p1 = new Promise(function (resolve, reject) {
  resolve("Sucesso");
});

p1.then(function (value) {
  console.log(value); // "Sucesso!"
  throw "Ah, não!";
})
  .catch(function (e) {
    console.log(e); // "Ah, não!"
  })
  .then(
    function () {
      console.log("Após um catch, a sequencia é restaurada");
    },
    function () {
      console.log("Não engatilhado devido ao catch");
    },
  );

// O seguinte se comporta da mesma maneira que o anterior
p1.then(function (value) {
  console.log(value); // "Sucesso!"
  return Promise.reject("Ah, não!");
})
  .catch(function (e) {
    console.log(e); // "Ah, não!"
  })
  .then(
    function () {
      console.log("Após um catch, a sequencia é restaurada");
    },
    function () {
      console.log("Não engatilhado devido ao catch");
    },
  );
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.catch |

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

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

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

* `Promise`
* `Promise.prototype.then()`


Promise.reject() - JavaScript

Promise.reject()
================

O método **`Promise.reject(motivo)`** retorna um objeto Promise que é rejeitada com um dado motivo.

Sintaxe
-------
```

Promise.reject(motivo);
```

### Parâmetros

motivo

Motivo pelo qual este Promise foi rejeitado.

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

O método estático `Promise.reject` retorna uma `Promise` que é rejeitada. Para fins de debug e captura de erros seletiva, é útil que o motivo seja uma `instanceof` `Error`.

Exemplos
--------

### Usando o método estático Promise.reject()

```js
Promise.reject("Testando reject estático").then(
  function (motivo) {
    // não executado
  },
  function (motivo) {
    console.log(motivo); // "Testando reject estático"
  },
);

Promise.reject(new Error("falha")).then(
  function (erro) {
    // não executado
  },
  function (erro) {
    console.log(erro); // Stacktrace
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

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

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

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

* `Promise`
* Captura de erros seletiva com a biblioteca de Promise BlueBird


Promise.race() - JavaScript

Promise.race()
==============

O método **`Promise.race(iterable)`** retorna uma promise que resolve ou rejeita assim que uma das promises no iterável resolver ou rejeitar, com o valor ou razão daquela promise.

Sintaxe
-------
```

Promise.race(iterable);
```

### Parâmetros

iterable

Um objeto iterável, como um `Array`. Veja iterável (en-US).

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

A função `race` retorna uma `Promise` que é estabelecida da mesma forma que a primeira promise passada estabelecer. Ela resolve ou rejeita, o que acontecer primeiro.

Exemplos
--------

### Usando `Promise.race` – exemplos com `setTimeout`

```js
var p1 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 500, "one");
});
var p2 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 100, "two");
});

Promise.race([p1, p2]).then(function (value) {
  console.log(value); // "two"
  // Ambos resolvem, mas p2 é mais rápido
});

var p3 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 100, "three");
});
var p4 = new Promise(function (resolve, reject) {
  setTimeout(reject, 500, "four");
});

Promise.race([p3, p4]).then(
  function (value) {
    console.log(value); // "three"
    // p3 é mais rápido, então ela resolve
  },
  function (reason) {
    // Não é chamado
  },
);

var p5 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 500, "five");
});
var p6 = new Promise(function (resolve, reject) {
  setTimeout(reject, 100, "six");
});

Promise.race([p5, p6]).then(
  function (value) {
    // Não é chamado
  },
  function (reason) {
    console.log(reason); // "six"
    // p6 é mais rápido, então ela rejeita
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.race |

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

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

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

* `Promise`


Promise.prototype.then() - JavaScript

Promise.prototype.then()
========================

Resumo
------

O método **then()** retorna uma **Promise**. Possui dois argumentos, ambos são "**call back functions**", sendo uma para o sucesso e outra para o fracasso da promessa.

Sintaxe
-------
```

p.then(quandoRealizada, quandoRejeitada);

p.then(function(valor) {
   // sucesso
  }, function(motivo) {
  // rejeitada
});
```

### Parametros

quandoRealizada

Uma `Function` chamada quando a **Promise** é cumprida (Sucesso). Essa função tem um argumento, o valor do cumprimento.

quandoRejeitada

Uma `Function` chamada quando a Promise é rejeitada. Essa função tem um argumento, o motivo da recusa.

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

Assim como o método .then() e `Promise.prototype.catch()` retornam uma **Promise**, eles podem ser encadeados - uma operação chamada ***composition**.*

Exemplos
--------

### Usando o método then

```js
var p1 = new Promise(function (resolve, reject) {
  resolve("Success!");
  // or
  // reject ("Error!");
});

p1.then(
  function (value) {
    console.log(value); // Success!
  },
  function (reason) {
    console.log(reason); // Error!
  },
);
```

### Encadeando

Já que o método then() devolve uma **Promise**, você pode facilmente encadeá-los.

```js
var p2 = new Promise(function (resolve, reject) {
  resolve(1);
});

p2.then(function (value) {
  console.log(value); // 1
  return value + 1;
}).then(function (value) {
  console.log(value); // 2
});
```

No exemplo acima, o último **.then()** recebeu a soma value + 1, que resultou em 2, porém se o retorno de value + 1 fosse uma **Promise** que também retornasse value + 1, o resultado seria o mesmo. Note, no exemplo abaixo, que leva 1000ms para a impressão de 2 ocorrer.

```js
var p2 = new Promise(function (resolve, reject) {
  resolve(1);
});

p2.then(function (value) {
  console.log(value); // 1
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve(value + 1);
    }, 1000);
  });
}).then(function (value) {
  console.log(value); // 2
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.then |

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

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

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

* `Promise`
* `Promise.prototype.catch()`


Promise.resolve() - JavaScript

Promise.resolve()
=================

O método **`Promise.resolve(value)`** retorna um objeto `Promise` que é resolvido com o valor passado. Se o valor for *thenable* (ex: tiver um método `then`), a promise retornada irá "seguir" esse *thenable*, adotando seu estado final; se o valor for uma promise, o objeto será o resultado da chamada Promise.resolve; do contrário a promise será realizada com o valor.

Sintaxe
-------
```

Promise.resolve(value);
Promise.resolve(promise);
Promise.resolve(thenable);
```

### Parametros

value

Argumento a ser resolvido pela `Promise`. Pode também ser uma `Promise` ou um thenable a resolver.

### Valor retornado

A `Promise` que será resolvida com o valor passado ou com a `Promise` passada como valor, caso o valor seja um objeto `Promise`

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

A função estática `Promise.resolve` retorna uma `Promise` de que será resolvida.

Examples
--------

### Usando o método estático `Promise.resolve`

```js
Promise.resolve("Success").then(
  function (value) {
    console.log(value); // "Success"
  },
  function (value) {
    // not called
  },
);
```

### Resolvendo um array

```js
var p = Promise.resolve([1, 2, 3]);
p.then(function (v) {
  console.log(v[0]); // 1
});
```

### Resolvendo outra `Promise`

```js
var original = Promise.resolve(true);
var cast = Promise.resolve(original);
cast.then(function (v) {
  console.log(v); // true
});
```

A ordem invertida dos logs acontece devido ao fato de que os handlers são chamados assincronamente. Veja como o `then` funciona aqui.

### Resolvendo thenables e disparando Errors

```js
// Resolving a thenable object
var p1 = Promise.resolve({
  then: function (onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true, object casted to a Promise

p1.then(
  function (v) {
    console.log(v); // "fulfilled!"
  },
  function (e) {
    // not called
  },
);

// Thenable throws before callback
// Promise rejects
var thenable = {
  then: function (resolve) {
    throw new TypeError("Throwing");
    resolve("Resolving");
  },
};

var p2 = Promise.resolve(thenable);
p2.then(
  function (v) {
    // not called
  },
  function (e) {
    console.log(e); // TypeError: Throwing
  },
);

// Thenable throws after callback
// Promise resolves
var thenable = {
  then: function (resolve) {
    resolve("Resolving");
    throw new TypeError("Throwing");
  },
};

var p3 = Promise.resolve(thenable);
p3.then(
  function (v) {
    console.log(v); // "Resolving"
  },
  function (e) {
    // not called
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.resolve |

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

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

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

* `Promise`


Promise.all() - JavaScript

Promise.all()
=============

O método **`Promise.all(iterable)`** retorna uma única `Promise` que resolve quando todas as promises no argumento iterável forem resolvidas ou quando o iterável passado como argumento não contém promises. É rejeitado com o motivo da primeira promise que foi rejeitada.

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

Sintaxe
-------
```

Promise.all(iterable);
```

### Parâmetros

iterable

Um objeto iterável, como um `Array` ou `String`.

### Retorno

* Uma `Promise` **já resolvida** se o iterável passado for vazio.
* Uma `Promise` **resolvida assíncronamente** se o iterável passado não conter promises. Nota, Google Chrome 58 retorna uma promise **já resolvida** nesse caso.
* Uma `Promise` **pendente** em todos os outros casos. Essa promise retornada é então resolvida/rejeitada **assíncronamente** (tão logo a pilha esteja vazia) quando todas as promises no dado iterável forem resolvidas, ou se alguma das promises for rejeitada. Veja o exemplo sobre "Assincronia ou sincronia da Promise.all" abaixo. Os valores retornados estarão na ordem em que as promises foram passadas. independentemente da ordem em que forem concluídas.
Descrição
---------

Esse método pode ser usado para agregar resultados de várias promises.

### Resolução

A promise retornada é resolvida com um array contendo **todos** os valores dos iteráveis passados como argumento (como valores que não são promises).

* Se um iterável vazio é passado, então esse método retorna (sincronamente) uma promise já resolvida.
* Se todas as promises passadas forem resolvidas, ou não forem promises, a promise retornada por `Promise.all` é resolvida assincronamente.
### Rejeição

Se qualquer uma das promises passadas for rejeitada, `Promise.all` assíncronamente é rejeitada com o valor da promise rejeitada, independentemente se outras promises foram resolvidas.

Exemplos
--------

### Utilizando Promise.all

`Promise.all` espera que todas as promises sejam resolvidas (ou a primeira rejeição).

```js
var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("foo");
  }, 100);
});

Promise.all([p1, p2, p3]).then((valores) => {
  console.log(valores); // [3, 1337, "foo"]
});
```

Se o iterável conter valores que não são promises, eles serão ignorados, mas ainda serão contados no array da promise retornada (se a promise for resolvida):

```js
// Essa será considerada como se o iterável passado fosse vazio, logo ela será resolvido
var p = Promise.all([1, 2, 3]);
// Essa será considerada como se o iterável passado contém apenas a promise resolvida com o valor "444", logo ela é resolvida
var p2 = Promise.all([1, 2, 3, Promise.resolve(444)]);
// Esse será considerada como se o iterável passado contém apenas o valor de rejeição "555" da promise, logo ela é rejeitada
var p3 = Promise.all([1, 2, 3, Promise.reject(555)]);

// Utilizando setTimeout para executar código depois que a pilha estiver vazia
setTimeout(function () {
  console.log(p);
  console.log(p2);
  console.log(p3);
});

// logs
// Promise { <estado>: "resolvida", <valor>: Array[3] }
// Promise { <estado>: "resolvida", <valor>: Array[4] }
// Promise { <estado>: "rejeitada", <razão>: 555 }
```

### Assincronia ou sincronia da Promise.all

O exemplo a seguir demonstra a assincronia (ou sincronia, se o iterável passado for fazio) de `Promise.all`:

```js
// Passamos o argumento como um array de promises que já estão resolvidas para disparar Promise.all a mais rápido possível
var arrayPromisesResolvidas = [Promise.resolve(33), Promise.resolve(44)];

var p = Promise.all(arrayPromisesResolvidas);
// Logando imediatamente o valor de p
console.log(p);

// Utilizando setTimeout para executar código depois que a pilha estiver vazia
setTimeout(function () {
  console.log("a pilha está vazia agora");
  console.log(p);
});

// logs, em ordem:
// Promise { <estado>: "pendente" }
// a pilha está vazia agora
// Promise { <estado>: "resolvida", <valor>: Array[2] }
```

A mesma coisa acontece se `Promise.all` for rejeitada:

```js
var arrayPromisesMisturadas = [Promise.resolve(33), Promise.reject(44)];
var p = Promise.all(arrayPromisesMisturadas);
console.log(p);
setTimeout(function () {
  console.log("a pilha está vazia agora");
  console.log(p);
});

// logs
// Promise { <estado>: "pendente" }
// a pilha está vazia agora
// Promise { <estado>: "rejeitada", <razão>: 44 }
```

Mas, `Promise.all` resolve sincromamente **se e somente se** o iterável passado for vazio:

```js
var p = Promise.all([]); // será resolvida imediatamente
var p2 = Promise.all([1337, "oi"]); // um valor que não é uma promise será ignorado, mas a avaliação será feita assíncronamente
console.log(p);
console.log(p2);
setTimeout(function () {
  console.log("a pilha está vazia agora");
  console.log(p2);
});

// logs
// Promise { <estado>: "resolvida", <valor>: Array[0] }
// Promise { <estado>: "pendente" }
// a pilha está vazia agora
// Promise { <estado>: "resolvida", <valor>: Array[2] }
```

### Comportamente de falhar rapidamente de Promise.all

`Promise.all` é rejeitada se qualquer um dos elementos for rejeitado. Por exemplo, se você passar quartro promises que resolvem após um intervalo de tempo e uma promise que rejeita imediatamente, então `Promise.all` será rejeitada imediatamente.

```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("um"), 1000);
});
var p2 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("dois"), 2000);
});
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("três"), 3000);
});
var p4 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("quatro"), 4000);
});
var p5 = new Promise((resolve, reject) => {
  reject(new Error("rejeitada"));
});

// Usando .catch:
Promise.all([p1, p2, p3, p4, p5])
  .then((valores) => {
    console.log(valores);
  })
  .catch((erro) => {
    console.log(erro.message);
  });

// No console:
// "rejeitada"
```

É possível mudar esse comportamente lidando com possíveis rejeições:

```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("p1\_resolução\_atrasada"), 1000);
});

var p2 = new Promise((resolve, reject) => {
  reject(new Error("p2\_rejeição\_imediata"));
});

Promise.all([
  p1.catch((erro) => {
    return erro;
  }),
  p2.catch((erro) => {
    return erro;
  }),
]).then((valores) => {
  console.log(valores[0]); // "p1\_resolução\_atrasada"
  console.log(valores[1]); // "Erro: p2\_rejeição\_imediata"
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.all |

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

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

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

* `Promise`
* `Promise.race()`


Promise.prototype.finally() - JavaScript

Promise.prototype.finally()
===========================

O método **`finally()`** retorna uma `Promise`. Quando a promise for estabelecida, tenha ela sido realizada ou rejeitada, executa-se a função callback especificada. Isso permite a execução de um código que acontecerá independentemente da `Promise` ter sido realizada (com sucesso) ou rejeitada (com falha).

Assim, você pode evitar a duplicação do código em ambos os handlers `then()` e `catch()` da `Promise`.

Sintaxe
-------
```

p.finally(quandoEstabelecida);

p.finally(function() {
   // concluída (realizada ou rejeitada)
});
```

### Parâmetros

`quandoEstabelecida`

Uma `Function` chamada quando a `Promise` é concluída.

### Valor de retorno

Retorna uma `Promise` onde o manipulador `finally` é definido como a função especificada, `quandoEstabelecida`.

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

O método `finally()` pode ser útil quando você deseja realizar algum tipo de processamento ou limpeza quando a promise for estabelecida, independentemente de seu resultado (sucesso ou falha).

O método `finally()` é bastante similar a chamar `.then(quandoEstabelecida, quandoEstabelecida)`. Porém, existem algumas diferenças:

* Ao passar a função na linha (entre os parênteses do método), você precisa passá-la apenas uma vez, ao invés de ser forçado a declará-la duas vezes ou a definir em uma variável.
* O callback de `finally` não poderá receber nenhum argumento, já que não existem meios confiáveis de determinar se a promise foi realizada ou rejeitada. Seu uso é para quando você realmente *não se importa* com os possíveis motivos de uma falha ou possíveis valores retornados de um sucesso, não tendo, portanto, razão para fornecê-los.
* Diferentemente de `Promise.resolve(2).then(() => {}, () => {})` (será resolvido como `undefined`), `Promise.resolve(2).finally(() => {})` será resolvido como `2`.
* De maneira semelhante, diferentemente de `Promise.reject(3).then(() => {}, () => {})` (que será resolvido como `undefined`), `Promise.reject(3).finally(() => {})` será rejeitado como `3`.

**Nota:** Um `throw` (ou retorno de uma promise rejeitada) no callback de `finally` rejeitará a nova promise com a razão de rejeição especificada na chamada de `throw()`.

Exemplos
--------

```js
let carregando = true;

fetch(minhaRequisicao)
  .then(function (resposta) {
    var tipoConteudo = response.headers.get("content-type");
    if (tipoConteudo && tipoConteudo.includes("application/json")) {
      return resposta.json();
    }
    throw new TypeError("Opa, isso não é JSON!");
  })
  .then(function (json) {
    /\* processamento do seu JSON \*/
  })
  .catch(function (erro) {
    console.log(erro);
  })
  .finally(function () {
    carregando = false;
  });
```

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

| Specification | Status | Comment |
| --- | --- | --- |
| TC39 proposal | Stage 4 |  |

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

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

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

* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()`


Promise.allSettled() - JavaScript

Promise.allSettled()
====================

O método **`Promise.allSettled()`** retorna uma promessa que é resolvida após todas as promessas dadas serem resolvidas ou rejeitadas, com um array de objetos que descrevem o resultado de cada promessa.

É tipicamente usado quando você tem múltiplas tarefas assíncronas que não são dependentes das conclusões umas das outras, ou quando você sempre quer ter o resultado de cada promessa.

Para comparação, a promessa retornada por `Promise.all()` pode ser mais apropriada para tarefas que dependem umas das outras, ou se você precisa que todas as tarefas sejam rejeitadas quando apenas uma é.

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

Sintaxe
-------
```

promise.allSettled(iterable);
```

### Parâmetros

`iterable`

Um objeto iterável (en-US), como um `Array`, onde cada membro é uma `Promise`.

### Valor retornado

Uma `Promise` **pendente** que vai ser **preenchida assíncronamente** quando todas as promessas na coleção fornecida forem completas, sendo aceitas ou rejeitadas. Quando isso acontecer, é retornado um array contendo um resultado para cada promessa passada como entrada.

Para cada objeto no array retornado, existe uma string `status`. Se o status for `fulfilled`, então o campo `value` estará presente. Se o status for `rejected`, então o campo `reason` estará presente. O valor (value) ou o motivo da falha (reason) refletem o valor com que cada promessa foi completada (ou rejeitada).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.allsettled |

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

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

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

* Promessas
* Usando promessas
* Programando assincronamente de maneira elegante usando promessas
* `Promise`
* `Promise.all()`


Map.prototype.entries() - JavaScript

Map.prototype.entries()
=======================

O método **`entries()`** retorna um novo objeto **iterador** que contém os pares `[key, value]` de cada elemento no objeto `Map` na ordem em que foram inseridos. Nesse caso em particular, esse objeto iterador também é iterativo. então o loop for-of pode ser usado. Quando o protocolo `[Symbol.iterator]` é usado, ele retorna uma função que, quando invocada, retorna o própio iterador.

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

Sintaxe
-------

```js
entries();
```

### Valor retornado

Um novo objeto iterador `Map`.

Exemplos
--------

### Usando o entries()]

```js
let myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");

let mapIter = myMap.entries();

console.log(mapIter.next().value); // ["0", "foo"]
console.log(mapIter.next().value); // [1, "bar"]
console.log(mapIter.next().value); // [Object, "baz"]
```

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

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

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

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

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

* `Map.prototype.keys()`
* `Map.prototype.values()`


get Map[@@species] - JavaScript

get Map[@@species]
==================

O Acessor de propriedade **`Map[@@species]`** retorna o construtor do `Map`.

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

 O acessor `species` retorna o valor padrão do construtor dos objetos `Map`
 Subclasses de construtores podem sobrescrever isso para mudar o construtor atribuído.

Exemplos
--------

### Species em objetos ordinários

A propriedade *species* retorna a função padrão do construtor, que é o construtor `Map` para objetos `Map`.

```js
Map[Symbol.species]; // function Map()
```

### Species em objetos derivados

 Em uma objeto derivado (e.g. seu custom map `MyMap`), a `specie` do `MyMap` é o construtor do `MyMap`.
 Porém, você deve querer sobrescrever isso, para retornar o objeto `Map` pai nos métodos derivados de sua classe.

```js
class MyMap extends Map {
  // Overwrite MyMap species to the parent Map constructor
  static get [Symbol.species]() {
    return Map;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-map-@@species |

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

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

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

* `Map`
* `Symbol.species`


Map.prototype.clear() - JavaScript

Map.prototype.clear()
=====================

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

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

Sintaxe
-------

```js
clear();
```

### Valor retornado

`undefined`.

Exemplos
--------

### Usando o clear()

```js
var myMap = new Map();
myMap.set("bar", "baz");
myMap.set(1, "foo");

myMap.size; // 2
myMap.has("bar"); // true

myMap.clear();

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

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

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

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

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

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

* `Map`


Map.prototype.delete() - JavaScript

Map.prototype.delete()
======================

O método **`delete()`** remove o elemento específico do objeto `Map` através de sua chave.

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

Sintaxe
-------

```js
delete key;
```

### Parâmetros

`key`

A chave do elemento que será removido do objeto `Map`.

### Valor retornado

`true` se o elemento do `Map` existia e foi removido, ou
 `false` se o elemento não existe.

Exemplos
--------

### Usando o delete()

```js
var myMap = new Map();
myMap.set("bar", "foo");

myMap.delete("bar"); // Retorna true. Removido com sucesso.
myMap.has("bar"); // Retorna false. O elemento "bar" não está mais presente
```

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

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

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

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

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

* `Map`


Map.prototype.set() - JavaScript

Map.prototype.set()
===================

O método **`set()`** adiciona ou atualiza um elemento com a chave especificada e um valor do objeto `Map`.

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

Sintaxe
-------

```js
set(key, value);
```

### Parâmetros

`key`

A chave do elemento que será adicionado ao objeto `Map`.

`value`

O valor do elemento que será adicionado ao objeto `Map`.

### Valor retornado

O objeto `Map`.

Exemplos
--------

### Usando o set()

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

// Adiciona um elemento ao map
myMap.set("bar", "foo");
myMap.set(1, "foobar");

// Atualiza um elemento no map
myMap.set("bar", "baz");
```

### Usando o `set` de forma encadeada

Já que o método `set()` retorna o mesmo objeto `Map`, você pode encadear a chamada do método como abaixo:

```js
// Adiciona novos elementos ao map de forma encadeada.
myMap.set("bar", "foo").set(1, "foobar").set(2, "baz");
```

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

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

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

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

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

* `Map`
* `Map.prototype.get()`
* `Map.prototype.has()`


Map() constructor - JavaScript

Map() constructor
=================

O **construtor `Map()`** cria objetos `Map`.

Sintaxe
-------

```js
new Map();
new Map(iterable);
```

### Parâmetros

`iterable` Optional

 Um `Array` ou outro
 objeto iterável
 dos quais os elementos são pares chave-valor. (Por exemplo, arrays com dois elementos como `[[ 1, 'one' ],[ 2, 'two' ]]`.).
 Cada par chave-valor é adicionado ao novo `Map`.

Exemplos
--------

### Criando um novo Map

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

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

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

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

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

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

* Um polyfill de `Map` esta disponível em
 `core-js`
* `Set`
* `WeakMap`
* `WeakSet`


Map.prototype.has() - JavaScript

Map.prototype.has()
===================

O método **`has()`** retorna um booleano indicando se o elemento com a chave especificada existe ou não.

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

Sintaxe
-------

```js
has(key);
```

### Parâmetros

`key`

A chave do elemento que será testado no objeto `Map`.

### Valor retornado

`true` se o elemento com a chave especificada existe no objeto `Map`, de outra forma será retornado `false`.

Exemplos
--------

### Usando has()

```js
let myMap = new Map();
myMap.set("bar", "foo");

myMap.has("bar"); // retorna true
myMap.has("baz"); // retorna false
```

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

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

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

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

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

* `Map`
* `Map.prototype.set()`
* `Map.prototype.get()`


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

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

 O valor inicial da propriedade **`@@iterator`**
 é o mesmo objeto função que o valor inicial do método `entries`

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

Sintaxe
-------

```js
myMap[Symbol.iterator];
```

### Valor retornado

A função iterativa do map, que é a `entries()` por padrão

Exemplos
--------

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

```js
const myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");

const mapIter = myMap[Symbol.iterator]();

console.log(mapIter.next().value); // ["0", "foo"]
console.log(mapIter.next().value); // [1, "bar"]
console.log(mapIter.next().value); // [Object, "baz"]
```

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

```js
const myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");

for (const entry of myMap) {
  console.log(entry);
}
// ["0", "foo"]
// [1, "bar"]
// [{}, "baz"]

for (const [key, value] of myMap) {
  console.log(`${key}: ${value}`);
}
// 0: foo
// 1: bar
// [Object]: baz
```

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

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

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

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

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

* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`


Map.prototype.keys() - JavaScript

Map.prototype.keys()
====================

 O método **`keys()`** retorna um novo objeto **iterador** que contém
 as chaves de cada elemento dentro do objeto `Map` na ordem em que foram inseridos.

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

Sintaxe
-------

```js
keys();
```

### Valor retornado

Um novo objeto `Map` iterador.

Exemplos
--------

### Usando keys()

```js
var myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");

var mapIter = myMap.keys();

console.log(mapIter.next().value); // "0"
console.log(mapIter.next().value); // 1
console.log(mapIter.next().value); // Object
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-map.prototype.keys |

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

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

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

* `Map.prototype.entries()`
* `Map.prototype.values()`


Map.prototype.get() - JavaScript

Map.prototype.get()
===================

 O método **`get()`** retorna um elemento específico do objeto `Map`. Se o valor
 associado à chave for um objeto, será retornado a referência do objeto e qualquer mudança no mesmo
 irá afetar o valor que está dentro do objeto `Map`.

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

Sintaxe
-------

```js
get(key);
```

### Parâmetros

`key`

A chave do elemento que será retornado do objeto `Map`.

### Valor retornado

 O elemento associado à chave especificada, ou `undefined` se
 a chave não puder ser encontrada no objeto `Map`.

Exemplos
--------

### Usando o get()

```js
let myMap = new Map();
myMap.set("bar", "foo");

myMap.get("bar"); // Returns "foo"
myMap.get("baz"); // Returns undefined
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-map.prototype.get |

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

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

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

* `Map`
* `Map.prototype.set()`
* `Map.prototype.has()`


Map.prototype.size - JavaScript

Map.prototype.size
==================

A propriedade acessora **`size`** retorna o número de elementos que estão dentro do objeto `Map`

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

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

 O valor de `size` é um inteiro que representa a quantidade de entradas que o objeto `Map` possui.
 A função acessora set para `size` é `undefined`; você não poderá alterar essa propriedade.

Exemplos
--------

### Usando o size

```js
var myMap = new Map();
myMap.set("a", "alpha");
myMap.set("b", "beta");
myMap.set("g", "gamma");

myMap.size; // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-map.prototype.size |

Compatibilidade com browsers
----------------------------

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

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

* `Map`


Map.prototype.values() - JavaScript

Map.prototype.values()
======================

 O método **`values()`** retorna um novo objeto **iterador** que contém o valor
 de cada elemento dentro do objeto `Map` na ordem em que foram inseridos.

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

Sintaxe
-------

```js
values();
```

### Valor retornado

Um novo objeto `Map` iterador.

Exemplos
--------

### Usando values()

```js
var myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");

var mapIter = myMap.values();

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

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

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

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

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

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

* `Map.prototype.entries()`
* `Map.prototype.keys()`


Map.prototype.forEach() - JavaScript

Map.prototype.forEach()
=======================

O método **`forEach()`** executa a função que foi provida uma vez para cada par de chave-valor no objeto `Map`, na order em que foram inseridos.

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

Sintaxe
-------

```js
// Arrow function
forEach(() => { ... } )
forEach((value) => { ... } )
forEach((value, key) => { ... } )
forEach((value, key, map) => { ... } )

// função de Callback
forEach(callbackFn)
forEach(callbackFn, thisArg)

// função de callback inline
forEach(function callbackFn() { ... })
forEach(function callbackFn(value) { ... })
forEach(function callbackFn(value, key) { ... })
forEach(function callbackFn(value, key, map) { ... })
forEach(function callbackFn(value, key, map) { ... }, thisArg)
```

### Parâmetros

`callbackFn`

A função que será executada em cada entrada do map. Ela receberá os seguintes argumentos:

`value` Optional

O valor de cada iteração.

`key` Optional

A chave de cada iteração.

`map` Optional

O map que está sendo iterado.

`thisArg` Optional

O valor para usar como `this` quando o callback for executado.

### Valor retornado

`undefined`.

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

 O método `forEach` executa o `callback` fornecido uma vez para cada chave do map
 que realmente existe.
 Ele não é invocado para chaves que foram deletadas.
 Porém, é executado para valores que estão presentes mesmo tendo o valor `undefined`.

O `callback` é invocado com **três argumentos**:

* O `value` de entrada
* A `key` de entrada
* o **objeto `Map`** que está sendo percorrido

 Se o parâmetro `thisArg` for fornecido para o `forEach`, ele será passado para o
 `callback` quando for invocado, para ser usado como o valor de `this`. De outra forma,
 o valor `undefined` será usado como valor de `this`. O valor de `this` será
 observado pelo `callback` em última análise e será determinado de acordo com
 as regras usuais para a determinação do `this` visto por uma função.

 Cada valor será visitado uma vez, exceto no caso em que foram deletados e adicionados novamente
 antes do `forEach` ser finalizado. O `callback` não é invocado para valores que foram removidos antes de
 terem sidos visitados. Novos valores adicionados antes do `forEach` terminar serão visitados.

Exemplos
--------

### Exibindo o conteúdo de um objeto Map

O código a seguir imprime uma linha para cada elemento do objeto `Map`:

```js
function logMapElements(value, key, map) {
  console.log(`map.get('${key}') = ${value}`);
}
new Map([
  ["foo", 3],
  ["bar", {}],
  ["baz", undefined],
]).forEach(logMapElements);
// logs:
// "map.get('foo') = 3"
// "map.get('bar') = [object Object]"
// "map.get('baz') = undefined"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-map.prototype.foreach |

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

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

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

* `Array.prototype.forEach()`
* `Set.prototype.forEach()` (en-US)


Function.prototype.call() - JavaScript

Function.prototype.call()
=========================

Introdução
----------

O método **`call()`** invoca uma função com um dado valor `this` e argumentos passados individualmente.

**Nota:** Apesar de a sintaxe desta função ser quase idêntica à de `apply()`, a principal diferença é que `call()` aceita uma **lista de argumentos**, enquanto `apply()` aceita **um único array de argumentos.**

Sintaxe
-------
```

fun.call(thisArg[, arg1[, arg2[, ...]]])
```

### Parâmetros

`thisArg`

O valor de `this` proveu a chamada para *`fun`*. Note que `this` pode não ser o valor atual visto pelo método: se esse método é uma função em non-strict mode (en-US) code, `null` e `undefined` serão reescritos com o objeto global, e valores primitivos serão encaixados.

`arg1, arg2, ...`

Argumentos para o objeto.

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

Você pode atribuir um objeto `this` diferente quando executar uma função existente. `this` refere-se ao objeto atual, o objeto em execução. Com `call`, você pode escrever um método uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.

Exemplos
--------

### Exemplo: Usando `call` para encadear construtores para um objeto

Você pode usar `call` para encadear construtores para um objeto, similar ao Java. No seguinte exemplo, o construtor do objeto `Product` é definido com dois parâmetros, `name` e `price`. Outras duas funções `Food` e `Toy` executam `Product` passando `this`, `name` e `price`. O Produto inicializa as propriedades `name` e `price`, ambos definem o `category`.

```js
function Product(name, price) {
  this.name = name;
  this.price = price;

  if (price < 0) {
    throw RangeError(
      "Cannot create product " + this.name + " with a negative price",
    );
  }

  return this;
}

function Food(name, price) {
  Product.call(this, name, price);
  this.category = "food";
}

Food.prototype = Object.create(Product.prototype);

function Toy(name, price) {
  Product.call(this, name, price);
  this.category = "toy";
}

Toy.prototype = Object.create(Product.prototype);

var cheese = new Food("feta", 5);
var fun = new Toy("robot", 40);
```

### Exemplo: Usando o `call` para chamar funções anônimas

Neste exemplo, criamos uma função anônima que usa o `call` para executá-lo em todos os objetos em um array(vetor). O principal propósito da função anônima aqui é adicionar uma função print para todo o objeto, que está disponível para imprimir o índice correto do objeto no array. Não foi necessário passar o valor do objeto como `this` , mas isso foi feito apenas para explicação.

```js
var animais = [
  { especie: "Lion", nome: "King" },
  { especie: "Whale", nome: "Fail" },
];

for (var i = 0; i < animais.length; i++) {
  (function (i) {
    this.print = function () {
      console.log("#" + i + " " + this.especie + ": " + this.nome);
    };
    this.print();
  }).call(animais[i], i);
}
```

### Usando `call` para chamar a função e especificar o contexto de 'this'

No exemplo abaixo, quando vamos chamar a apresentação, o valor de this será associado ao objeto i.
```

function apresentacao() {
  var resposta = [this.pessoa, 'é um excelente', this.funcao].join(' ');
  console.log(resposta);
}

var i = {
  pessoa: 'Douglas Crockford', funcao: 'Desenvolvedor Javascript'
};

apresentacao.call(i); // Douglas Crockford é um excelente Desenvolvedor Javascript
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.call |

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

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

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

* `Function.prototype.bind()`
* `Function.prototype.apply()`
* Introdução à JavaScript Orientado à Objetos (en-US)


Function.name - JavaScript

Function.name
=============

A propriedade somente-leitura **`name`** de um objeto `Function` indica o nome da função como especificado quando esta foi criada, ou `"anonymous"` para funções criadas anonimamente.

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

| Property attributes of `Function.name` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

**Nota:** Note que em implementações não-standard anteriores à ES2015 o atributo `configurable` tinha também o valor `false`.

Exemplos
--------

### Nome de declaração da função

A propriedade `name` retorna o nome de uma declaração de função.

```js
function doSomething() {}
doSomething.name; // "doSomething"
```

### Nome do construtor da função

Funções criadas com a sintaxe `new Function(...)` ou somente `Function(...)` criam objetos `Function` com o nome "anonymous".
```

(new Function).name; // "anonymous"
```

### Nomes de função inferidos

Variáveis e métodos podem inferir o nome de uma função anônima a partir de sua posição sintática (novo na ECMAScript 2015).

```js
var f = function () {};
var object = {
  someMethod: function () {},
};

console.log(f.name); // "f"
console.log(object.someMethod.name); // "someMethod"
```

Você pode definir uma função com um nome numa expressão de função:

```js
var object = {
  someMethod: function object\_someMethod() {},
};
console.log(object.someMethod.name); // grava o log "object\_someMethod"

try {
  object_someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: object\_someMethod is not defined
```

Você não pode mudar o nome de uma função, pois a propriedade é somente-leitura:

```js
var object = {
  // anonymous
  someMethod: function () {},
};

object.someMethod.name = "otherMethod";
console.log(object.someMethod.name); // someMethod
```

Para mudá-lo, você poderia no entanto usar `Object.defineProperty()`.

### Nomes curtos de métodos

```js
var o = {
  foo() {},
};
o.foo.name; // "foo";
```

### Nomes de funções vinculadas

`Function.bind()` produz uma função cujo nome é "bound " seguido do nome da função.

```js
function foo() {}
foo.bind({}).name; // "bound foo"
```

### Nomes de função para *getters* e *setters*

Ao usar propriedades acessórias `get` e `set`, "get" ou "set" aparecerão no nome da função.

```js
var o = {
  get foo() {},
  set foo(x) {},
};

var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
descriptor.get.name; // "get foo"
descriptor.set.name; // "set foo";
```

### Nomes de funções em classes

Você pode usar `obj.constructor.name` para checar a "classe" de um objeto (porém leia com atenção os avisos abaixo):

```js
function Foo() {} // Sintaxe ES2015: class Foo {}

var fooInstance = new Foo();
console.log(fooInstance.constructor.name); // grava o log "Foo"
```

**Aviso:** O interpretador vai definir a propriedade interna `Function.name` somente se uma função não tiver uma propriedade já com o nome *name* (veja a seção 9.2.11 da ECMAScript2015 Language Specification). Porém, a ES2015 especifica que a palavra-chave *static* de maneira que métodos estáticos serão definidos como OwnProperty da função construtora de classe (ECMAScript2015, 14.5.14.21.b + 12.2.6.9).

Portanto não podemos obter o nome de virtualmente qualquer classe com um método estático `name()`:

```js
class Foo {
  constructor() {}
  static name() {}
}
```

Com um método `static name()`, `Foo.name` não guarda mais o nome verdadeiro da classe mas uma referência ao objeto de função `name()`. A definição de classe acima, escrita em sintaxe ES2015, se comportará de maneira similar ao seguinte trecho de código em sintaxe ES5 no Chrome ou no Firefox:

```js
function Foo() {}
Object.defineProperty(Foo, "name", { writable: true });
Foo.name = function () {};
```

Tentar obter a classe de `fooInstance` via `fooInstance.constructor.name` não nos dará de maneira alguma o nome da classe, mas sim uma referência ao método estático da classe. Exemplo:

```js
var fooInstance = new Foo();
console.log(fooInstance.constructor.name); // grava o name() da função no log
```

Você pode ver também, a partir do exemplo de sintaxe ES5, que, no Chrome ou no Firefox, a nossa definição estática de `Foo.name` se torna *writable*. A predefinição interna na ausência de uma definição estática customizada é somente-leitura:

```js
Foo.name = "Hello";
console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.
```

Portanto, você não pode assumir que a propriedade interna `Function.name` sempre guardará um nome de classe..

### Símbolos como nome de função

Se um `Symbol` é usado como nome de função e o símbolo tem uma descrição, o nome do método será a descrição entre colchetes.
```

var sym1 = Symbol("foo");
var sym2 = Symbol();
var o = {
  [sym1]: function(){},
  [sym2]: function(){}
};

o[sym1].name; // "[foo]"
o[sym2].name; // ""
```

Compressores e minificadores JavaScript
---------------------------------------

**Aviso:** Tenha cuidado ao usar `Function.name` e transformações de código-fonte, como aquelas executadas por compressores (minificadores) ou obfuscadores de JavaScript. Estas ferramentas são comumente usadas como parte de processos de *build* de JavaScript para reduzir os tamanhos de programas antes da implementação em produção. Tais transformações frequentemente mudam nomes de função durante o *build*.

Código fonte do tipo:

```js
function Foo() {}
var foo = new Foo();

if (foo.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}
```

pode ser comprimido e se tornar:

```js
function a() {}
var b = new a();
if (b.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}
```

Na versão descomprimida, o programa cai no bloco-verdade e grava o log *'foo' is an instance of 'Foo'*. Todavia, na versão comprimida ele se comporta diferentemente, e cai no bloco `else`. Se você depende de `Function.name`, como no exemplo acima, tenha certeza que seu processo de *build* não mude nomes de função, ou então não assuma que uma função terá um nome determinado.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-name |

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

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


Function.prototype.toString() - JavaScript

Function.prototype.toString()
=============================

O método **`toString()`** retorna uma string representando o código fonte da função.

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

Sintaxe
-------
```

function.toString()
```

### Valor de retorno

Uma string representando o código fonte da função.

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

O objeto da `Function` substitui o método `toString` herdado de `Object`; ele não herda `Object.prototype.toString`. Para objetos `Function` definidos pelo usuário, o método `toString` retorna uma string contendo o seguimento de texto de origem que foi usado para definir a função

O JavaScript chama o método `toString` automaticamente quando uma `Function` pode ser representada como um valor de texto. e.x. quando uma função é concatenada com uma string.

O método `toString()` lançará uma exceção do tipo `TypeError` ("Function.prototype.toString called on incompatible object") se o valor `this` do objeto não é um objeto do tipo `Function.`

```js
Function.prototype.toString.call("foo"); // TypeError
```

Se o método `toString()` é chamado por objetos de funções embutidas ou por uma função criada por `Function.prototype.bind`, `toString()` retorna uma string de uma função nativa que parece

```js
"function () {\n [native code]\n}";
```

Se o método `toString()` é chamado por uma função criada pelo contrutor de `Function`, `toString()` retorna o código fonte de uma declaração de função sintetizada chamada "anonymous" usando os parâmetros passados e o corpo da função.

Exemplos
--------

| Função | Function.prototype.toString resultado |
| --- | --- |
|
```
function f(){}
```
 |
```
"function f(){}"
```
 |
|
```
class A { a(){} }
```
 |
```
"class A { a(){} }"
```
 |
|
```
function* g(){}
```
 |
```
"function* g(){}"
```
 |
|
```
a => a
```
 |
```
"a => a"
```
 |
|
```
({ a(){} }.a)
```
 |
```
"a(){}"
```
 |
|
```
({ *a(){} }.a)
```
 |
```
"*a(){}"
```
 |
|
```
({ [0](){} }[0])
```
 |
```
"[0](){}"
```
 |
|
```
Object.getOwnPropertyDescriptor({
    get a(){}
}, "a").get
```
 |
```
"get a(){}"
```
 |
|
```
Object.getOwnPropertyDescriptor({
    set a(x){}
}, "a").set
```
 |
```
"set a(x){}"
```
 |
|
```
Function.prototype.toString
```
 |
```
"function toString() { [native code] }"
```
 |
|
```
(function f(){}.bind(0))
```
 |
```
"function () { [native code] }"
```
 |
|
```
Function("a", "b")
```
 |
```
"function anonymous(a\n) {\nb\n}"
```
 |

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

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

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

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

Notas específicas do Firefox
----------------------------

* Desde o Firefox 17 a função `Function.prototype.toString()` tem sido implementada salvando o fonte da função. O descompilador foi removido o que torna o parâmetro `indentation` desnecessário. Veja Erro do Firefox 761723 para mais detalhes.
* Do Firefox 38 para o 63 a função `Function.prototype.toString()` lançava exceções para objetos `Proxy` (Erro do Firefox 1100936 e Erro do Firefox 1440468).
Veja também
-----------

* `Object.prototype.toString()`


Function.arguments - JavaScript

Function.arguments
==================

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

A propriedade **`function.arguments`** diz respeito a um objeto tipo array (array-like object) correspondente aos argumentos passados para uma função. Use somente a variável `arguments` em vez disso.

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

A sintaxe `function.arguments` está obsoleta. A forma recomendada de acessar o objeto `arguments` disponível dentro das funções, é simplesmente referenciar a variável `arguments`.

No caso de recursão, ou seja, uma função f aparecer várias vezes na pilha de chamadas, o valor de `f.arguments` representa os argumentos correspondentes a invocação mais recente da função.

O valor da propriedade arguments é normalmente nulo (`null`) se não houver nenhuma invocação pendente da função em andamento (ou seja, a função foi chamada mas ainda não retornou).

Exemplos
--------

```js
function f(n) {
  g(n - 1);
}

function g(n) {
  console.log("before: " + g.arguments[0]);
  if (n > 0) {
    f(n);
  }
  console.log("after: " + g.arguments[0]);
}

f(2);

console.log("returned: " + g.arguments);

// Output

// before: 1
// before: 0
// after: 0
// after: 1
// returned: null
```

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

Não faz parte de nenhuma especificação.

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

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

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

* `arguments` object
* Functions and function scope