recursal/MDN huggingface dataset:
Array.prototype.shift()
=======================

Sumário
-------

O método **`shift()`** remove o **primeiro** elemento de um array e retorna esse elemento. Este método muda o tamanho do array.

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

Sintaxe
-------
```

arr.shift()
```

### Valor de retorno

O elemento removido do array; `undefined` se o array estiver vazio.

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

O método shift remove o elemento de índice zero, diminui em 1 os indices dos demais valores e retorna o valor removido. Se a propriedade `length` for 0, então `undefined` é retornado.

`shift` é intencionalmente genérico; esse método pode ser chamado ou aplicado para objetos parecidos com arrays. Objetos que não contém a propriedade `length` representando o tamanho de uma série consecutiva, começando em zero, podem não se comportar de maneira correta.

Exemplos
--------

### Removendo um elemento de array

O código a seguir mostra o array `minhaLista` antes e depois de remover seu primeiro elemento. Ele também mostra o elemento removido.


```js
var minhaLista = ["anjo", "casa", "mandarim", "medico"];

console.log("minhaLista antes: " + minhaLista);
// minhaList antes: ['anjo', 'casa', 'mandarim', 'medico']
var shifted = minhaLista.shift();

console.log("minhaLista depois: " + minhaLista);
// minhaList depois: ['casa', 'mandarim', 'medico']
console.log("Elemento removido: " + shifted);
// Elemento removido: anjo
```

### Usando o método shift() dentro de um loop de while

O médodo `shift()` é frequentemente usado como condição dentro de um loop de while. No exemplo a seguir, cada iteração removerá o elemento seguinte do array, até que ele esteja vazio:


```js
var nomes = ["André", "Eduardo", "Paulo", "Cris", "João"];
while ((i = nomes.shift()) !== undefined) {
  console.log(i);
}
// André Eduardo Paulo Cris João
```

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

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

Compatibilidade de Browser
--------------------------

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

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

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
Array.prototype.unshift()
=========================

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

O método **`unshift()`** adiciona um ou mais elementos no início de um array e retorna o número de elementos (propriedade `length`) atualizado.

Sintaxe
-------
```

arr.unshift([element1[, ...[, elementN]]])
```

### Parâmetros

`elementN`

Os elementos a serem adicionados no começo do array.

### Retorna

A nova propriedade `length` do objeto acima onde o método foi chamado.

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

O método `unshift` insere os valores fornecidos no início de um objeto do tipo array.

`unshift` é intencionalmente genérico; este método pode ser chamado via call ou apply em objetos que se assemelham aos arrays. Objetos que não contêm uma propriedade `length` que reflete a última de uma série consecutiva de propriedades numéricas, iniciada por 0, podem não comportar-se de maneira significativa.

Exemplos
--------


```js
var arr = [1, 2];

arr.unshift(0); // result of call is 3, the new array length
// arr is [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr is [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr is [[-3], -2, -1, 0, 1, 2]
```

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

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

Compatibilidade entre browsers
------------------------------

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

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

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
Array.of()
==========

O método **`Array.of()`** cria um nova instância de `Array` com um número variável de argumentos, independentemente do número ou do tipo dos argumentos.

A diferença entre o **`Array.of()`** e o construtor de **`Array`** é no tratamento dos argumentos inteiros: **`Array.of(7)`** cria um array com um único elemento, `7`, enquanto **`Array(7)`** cria um array vazio de propriedade `length` igual a `7` (**Nota**: isso quer dizer um array com `7` espaços vazios, e não com valores do tipo `undefined`).
```

Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // array com 7 espaços vazios
Array(1, 2, 3);    // [1, 2, 3]
```

Syntaxe
-------
```

Array.of(element0[, element1[, ...[, elementN]]])
```

### Parâmetros

`elementN`

Elementos usados para criar o `array`.

### Valor de retorno

Uma nova instância de `Array`.

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

Esta função é parte do padrão ECMAScript 6 (ou ECMAScript 2015).

Para maiores informações veja:

* `Array.of`
* `Array.from` proposal
* `Array.of` polyfill.
Exemplos
--------


```js
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
```

Polyfill
--------

Executando o seguinte código antes de qualquer outro c[odigo criará o `Array.of()` se ele não for disponível nativamente.


```js
if (!Array.of) {
  Array.of = function () {
    return Array.prototype.slice.call(arguments);
    // Or
    let vals = [];
    for (let prop in arguments) {
      vals.push(arguments[prop]);
    }
    return vals;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.of |

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

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

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

* `Array`
* `Array.from()`
* `TypedArray.of()` (en-US)
Array.prototype.pop()
=====================

Resumo
------

O método **`pop()`** remove o **último** elemento de um array e retorna aquele elemento.

Sintaxe
-------
```

arr.pop()
```

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

O método `pop` remove o último elemento de um array e retorna aquele valor.

Esse método é intencionalmente genérico. Podendo ser utilizado por call ou apply em objetos que implementam arrays.

Se você chamar `pop()` em um array vazio, ele retorna o valor `undefined`.

Exemplos
--------

### Exemplo: Removendo o último elemento de um array

O código seguinte cria o array `meuPeixe` contendo quatro elementos e então remove seu último elemento.


```js
var meuPeixe = ["acara-bandeira", "palhaco", "mandarim", "esturjao"];

console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao']

var meuPeixePop = meuPeixe.pop();

console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim' ]

console.log(meuPeixePop); // 'esturjao'
```

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

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

Compatibilidade nos Navegadores
-------------------------------

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

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

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
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.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)
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.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()
============================

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

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

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