recursal/MDN huggingface dataset:
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.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()
====================

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

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]
==================

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

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

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

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
=================

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

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]()
===========================

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

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

 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
==================

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

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

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)