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

Sumário
-------

O método `includes()` determina se um array contém um determinado elemento, retornando `true` ou `false` apropriadamente.

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

Sintaxe
-------


```js
array.includes(searchElement[, fromIndex])
```

### Parâmetros

`searchElement`

O elemento a buscar

`fromIndex`

Opcional. A posição no array de onde a busca pelo `searchElement` se iniciará. Por padrão, 0.

Exemplos
--------


```js
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
```

Polyfill
--------


```js
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, "includes", {
    value: function (searchElement, fromIndex) {
      // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      // (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      // a. Let k be n.
      // 6. Else n < 0,
      // a. Let k be len + n.
      // b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        // c. Increase k by 1.
        // NOTE: === provides the correct "SameValueZero" comparison needed here.
        if (o[k] === searchElement) {
          return true;
        }
        k++;
      }

      // 8. Return false
      return false;
    },
  });
}
```

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

Proposta ES7: https://github.com/domenic/Array.prototype.contains/blob/master/spec.md

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

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

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

* `TypedArray.prototype.includes()` (en-US)
* `String.prototype.includes()`
* `Array.prototype.indexOf()`
Array.prototype.keys()
======================

Sumário
-------

O método **`keys()`** retorna um novo **`Array Iterator`** que contém as chaves para cada *index* do array.

Sintaxe
-------
```

arr.keys()
```

Exemplos
--------

### Exemplo: uso básico


```js
var arr = ["a", "b", "c"];
var iterator = arr.keys();

console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### Exemplo: keys iterator não ignora lacunas


```js
var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // [0, 2]
console.log(denseKeys); // [0, 1, 2]
```

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

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

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

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

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

* `Array.prototype.values()`
* `Array.prototype.entries()`
Array.prototype[@@unscopables]
==============================

A propriedade de símbolo **`@@unscopable`** contém nomes de propriedades que não foram incluídos no padrão ECMAScript antes da versão ES2015. Essas propriedades são excluídas do statement bindings `with`.Sintaxe
-------
```

arr[Symbol.unscopables]
```

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

As propriedades padrão de array que são excluídas dos bindings `with` são: copyWithin, entries, fill, find, findIndex, includes, keys, e values.

Veja `Symbol.unscopables` para saber como definir `unscopables` para seus objetos.

| Property attributes of `Array.prototype[@@unscopables]` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Exemplos
--------

O código a seguir funciona bem no ES5 e abaixo. No entanto, no ECMAScript 2015 e posterior, o método `Array.prototype.keys()` foi introduzido. Isso significa que dentro de ambientes `with`, as "keys" seriam agora o método e não a variável. É aqui que a propriedade de símbolo `@@unscopables` `Array.prototype[@@unscopables]` entra em ação e impede que alguns métodos do Array estejam sendo definidos na instrução `with`.


```js
var keys = [];

with (Array.prototype) {
  keys.push("alguma coisa");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

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

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

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

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

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

* `Symbol.unscopables`
Array.prototype.length
======================

A propriedade **`length`** representa um inteiro de 32-bit sem sinal, que especifíca o número de elementos em um array.

| Property attributes of `Array.prototype.length` |
| --- |
| Writable | yes |
| Enumerable | no |
| Configurable | no |

Sintaxe
-------
```

arr.length
```

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

O valor da propriedade length é um inteiro com um sinal positivo e valor menor que 2 elevado na 32ª potência(232).

Você pode setar o a propriedade `length` para truncar um array a qualquer momento. Quando você extende um array mudando sua propriedade `length`, o numero de elementos atuais não é incrementado; por exemplo, se você setar o tamanho para 3 quando ele é atualmente 2, o array continua somente com 2 elementos. Assim, a propriedade `length` não diz nada sobre o tamanho de valores definidos no array. Veja também Relacionamento entre `length` e propriedades numéricas.

Exemplos
--------

### Iterando sobre um array

No exemplo a seguir `numbers` é iterado considerando a propriedade `length` para ver quantos elementos ele tem. O valor de cada elemento recebe então o dobro.


```js
var numbers = [1, 2, 3, 4, 5];

for (var i = 0; i < numbers.length; i++) {
  numbers[i] \*= 2;
}
// numbers is now [2, 4, 6, 8, 10]
```

### Encurtando um array

O exemplo a seguir encurta o array `statesUS` para um tamanho de 50 se o tamanho corrente for maior do que 50.


```js
if (statesUS.length > 50) {
  statesUS.length = 50;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

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

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

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

* `Array`
Array.prototype.toString()
==========================

O método **`toString()`** retorna uma string representando um array específico e seus elementos.

Sintaxe
-------
```

arr.toString()
```

### Parâmetros

Nenhum.

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

O objeto `Array` substitui o método toString() de `Object`. Para objetos do tipo Array, o método toString() concatena todos os valores em apenas uma string. Segue exemplo abaixo, de como ele se comporta.


```js
var monthNames = ["Jan", "Feb", "Mar", "Apr"];
var myVar = monthNames.toString(); // atribui 'Jan,Feb,Mar,Apr' para myVar.
```


JavaScript chama o método toString automaticamente quando um Array é para ser representado como um valor de texto ou quando um Array é designado em uma concatenação.

### Semântica ECMAScript 5

Implementado no JavaScript 1.8.5 (Firefox 4), e compatível com a 5ª versão do ECMAScript, a função toString() é genérica e pode ser usada em qualquer Objeto. Se o objeto tem um método join(), ele será chamado e esse valor será devolvido. Do contrário, `Object.prototype.toString()` será chamado, e o valor será retornado.

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

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

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

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

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

* `Object.prototype.toSource()`
Array.prototype.fill()
======================

O método **`fill()`** preenche todos os valores do array a partir do índice inicial a um índice final com um valor estático.

Sintaxe
-------
```

arr.fill(valor[, ínicio = 0[, fim = this.length]])
```

### Parâmetros

`valor`

Valor para preencher o array.

`ínicio`

Opcional. Índice inicial.

`fim`

Opcional. Índice final.

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

O intervalo de preenchimento dos elementos é [`início`, `fim`).

O método **`fill`** pode receber até três argumentos `valor`, `ínicio` e `fim`. Os argumentos `ínicio` e `fim` são opcionais com valor padrão `0 (valor)` e o tamanho do objeto `(fim)`.

Se o `ínicio` for negativo, ele será tratado como `tamanho + ínicio` onde `tamanho é o tamanho total do array`. Se o `fim` for negativo, ele será tratado como `tamanho + fim`.

A função **fill** é intencionalmente genérica, ele não precisa que o valor do this seja um objeto Array.

O método **fill** é um método mutável, ele irá mudar o objeto em si, e retorná-lo, não somente uma cópia do objeto.

Exemplos
--------


```js
[1, 2, 3].fill(4); // [4, 4, 4]
[1, 2, 3].fill(4, 1); // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2); // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1); // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2); // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3]
Array(3).fill(4); // [4, 4, 4]
[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3}
```

Polyfill
--------


```js
if (!Array.prototype.fill) {
  Array.prototype.fill = function (value) {
    // Passo 1-2.
    if (this == null) {
      throw new TypeError("this is null or not defined");
    }

    var O = Object(this);

    // Passo 3-5.
    var len = O.length >>> 0;

    // Passo 6-7.
    var start = arguments[1];
    var relativeStart = start >> 0;

    // Passo 8.
    var k =
      relativeStart < 0
        ? Math.max(len + relativeStart, 0)
        : Math.min(relativeStart, len);

    // Passo 9-10.
    var end = arguments[2];
    var relativeEnd = end === undefined ? len : end >> 0;

    // Passo 11.
    var final =
      relativeEnd < 0
        ? Math.max(len + relativeEnd, 0)
        : Math.min(relativeEnd, len);

    // Passo 12.
    while (k < final) {
      O[k] = value;
      k++;
    }

    // Passo 13.
    return O;
  };
}
```

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

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

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

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

[1] Começando com Chrome 36, isto era disponível com uma mudança nas preferencias. Em chrome://flags, ativar a entrada "Enable Experimental JavaScript".

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

* `Array`
* `TypedArray.prototype.fill()` (en-US)
Array.prototype.join()
======================

O método **`join()`** junta todos os elementos de um array (ou um array-like object) em uma string e retorna esta string.Experimente
-----------

Sintaxe
-------
```

arr.join([separador = ','])
```

### Parâmetros

`separador` Optional

Específica uma string para separar cada elemento adjacente do array. O separador é convertido em uma string se necessário. Se omitido, os elementos do array são separados com uma vírgula (","). Se o `separador` for uma string vazia, todos os elementos são juntados sem nenhum caracter entre eles.

### Valor de retorno

Uma string com todos os elementos do array juntos. Se `arr.length` é `0`, uma string vazia é retornada.

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

As conversões em string de todos os elementos de um array são juntados em apenas uma string.

**Aviso:** Obs: Se um elemento é `undefined` ou `null`, ele é convertido em uma string vazia.

Exemplos
--------

### Juntando um array de quatro formas diferentes

O exemplo interativo a seguir cria um array, `a`, com três elementos, e o junta três vezes: a primeira com virgulas, a segunda so junta os elementos e a terceira com um sinal de menos.

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

### Juntando um array-like object (objeto estilo-array)

O exemplo abaixo junta um array-like object (ex: o objeto `arguments`), chamando `Function.prototype.call` no `Array.prototype.join`.


```js
function f(a, b, c) {
  var s = Array.prototype.join.call(arguments);
  console.log(s); // '1,a,true'
}
f(1, "a", true);
//saida esperada: "1,a,true"
```

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

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

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

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

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

* `String.prototype.split()`
* `Array.prototype.toString()`
* `TypedArray.prototype.join()` (en-US)
Array.isArray()
===============

Sumário
-------

O método **`Array.isArray()`** retorna `true` se um objeto é uma array, e `false` se não é.

Sintaxe
-------
```

Array.isArray(obj)
```

### Parâmetros

`obj`

O objeto a ser verificado.

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

Se o objeto é um `Array`, retorna `true`(verdadeiro), caso contrário é retornado `false`(falso).

Veja o artigo "Determinando com absoluta precisão se um objeto em Javascript é ou não uma array" para mais detalhes.

Exemplos
--------


```js
// todas as chamadas conseguintes retornam true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
// Pequeno detalhe: Array.prototype por si só é uma array:
Array.isArray(Array.prototype);

// todas as conseguintes retornam false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray("Array");
Array.isArray(true);
Array.isArray(false);
Array.isArray({ \_\_proto\_\_: Array.prototype });
```

Polyfill
--------

Executando o seguinte código antes de qualquer outro, o método `Array.isArray()` será criado, caso o browser não o disponibilize nativamente.


```js
if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
}
```

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

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

Compatibilidade com o Browser
-----------------------------

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

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

* `Array`
Array.prototype.entries()
=========================

O método **`entries()`** retorna um novo objeto **`Array Iterator`** que contém os pares chave/valor para cada índice no array.

Sintaxe
-------
```

arr.entries()
```

Exemplos
--------


```js
var arr = ["a", "b", "c"];
var eArr = arr.entries();

console.log(eArr.next().value); // [0, 'a']
console.log(eArr.next().value); // [1, 'b']
console.log(eArr.next().value); // [2, 'c']
```

### O mesmo que acima, utilizando um loop for…of


```js
var arr = ["a", "b", "c"];
var eArr = arr.entries();

for (let e of eArr) {
  console.log(e);
}
// [0, 'a']
// [1, 'b']
// [2, 'c']
```

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

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

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.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
Array.prototype.flatMap()
=========================

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

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

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

O método **`flatMap()`** primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em um novo array. É idêntico a um `map` seguido por um `flat` de profundidade 1, mas **`flatMap`** é bastante útil e mescla ambos em um método um pouco mais eficiente.

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

Sintaxe
-------
```

var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
    // retorna o elemento para new_array
}[, thisArg])
```

### Parâmetros

`callback`

Função que produz um elemento de uma nova Array, pegando três argumentos:

`currentValue`

O valor atual sendo processo na array.

`index`Optional

O index do valor atual sendo processo na array.

`array`Optional

O `map` da array que foi chamado.


`thisArg`Optional

Valor para ser usado como `this` quando `callback` estiver sendo executado.

### Valor de retorno

Uma nova array com cada elemento sendo o resultado da função callback e achatado ao valor de 1.

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

Veja `Array.prototype.map()` para uma detalhada descrição da função callback. O método `flatMap` é idêntico ao `map` seguido por um chamado a `flatten` (en-US) de profundidade 1.

Exemplos
--------

### `map` e `flatMap`


```js
var arr1 = [1, 2, 3, 4];

arr1.map((x) => [x \* 2]);
// [[2], [4], [6], [8]]

arr1.flatMap((x) => [x \* 2]);
// [2, 4, 6, 8]

// Só o primeiro nível
arr1.flatMap((x) => [[x \* 2]]);
// [[2], [4], [6], [8]]
```


Enquanto que acima poderíamos alcançar apenas com a utilização de map, já aqui temos um exemplo onde `flatMap` é mais apropriado.

Vamos gerar uma lista de palavras a partir de uma lista de sentenças.


```js
let arr1 = ["it's Sunny in", "", "California"];

arr1.map((x) => x.split(" "));
// [["it's","Sunny","in"],[""],["California"]]

arr1.flatMap((x) => x.split(" "));
// ["it's","Sunny","in", "", "California"]
```


Perceba, o comprimento da lista de saída pode ser diferente do comprimento da lista de entrada.

Alternativa
-----------

### `reduce` e `concat`


```js
var arr1 = [1, 2, 3, 4];
arr1.flatMap((x) => [x \* 2]);
// é equivalente a
arr1.reduce((acc, x) => acc.concat([x \* 2]), []);
// [ 2, 4, 6, 8 ]
```

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

| Specification | Status | Comment |
| --- | --- | --- |
| `Array.prototype.flatMap` proposal | Rascunho |  |

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

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

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

* `Array.prototype.flatten()` (en-US)
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`
Array.prototype.toLocaleString()
================================

O método **`toLocaleString()`** retorna uma representaçao de elementos de um array. Os elementos são convertidos para Strings utilizando seus respectivos métodos `toLocaleString` e essas cadeias são separadas por uma sequência específica de localidade (separados por virgula ",").Sintaxe
-------
```

array.toLocaleString();
```

### Parâmetros

`locales` Optional

Uma string com uma tag de linguagem BCP 47, ou um array como strings. Para uma forma geral e uma interpretação do arquivo `locales`, veja a página `Intl`.

`options` Optional

Um objeto com as propriedades de configurações, para números veja `Number.prototype.toLocaleString()`, e para datas veja `Date.prototype.toLocaleString()` (en-US).

### Retorno

Uma string que representa os elementos de um array.

Exemplos
--------

### Usando `toLocaleString`

Os elementos de um array são convertidos para strings usando seus respectivos métodos `toLocaleString`:

* `Object`: `Object.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()` (en-US)


```js
var numero = 1337;
var data = new Date();
var meuArray = [numero, data, "foo"];

var resultado = meuArray.toLocaleString();

console.log(resultado);
// saída '1337,July 26, 2015 at 20:02:23 GMT-3,foo'
// se estiver no Brasil com o fuso horario GMT-0300 (BRT) de Brasília.
```


Para mais exemplos, veja as páginas `Intl`, `NumberFormat`, e `DateTimeFormat` (en-US).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-array.prototype.tolocalestring |

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

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

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

* `Array.prototype.toString()`
Array.prototype.flat()
======================

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

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

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

O método **`flat()`** cria um novo array com todos elementos sub-arrays concatenados nele de forma recursiva até a profundidade especificada.

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

Sintaxe
-------


```js
flat();
flat(depth);
```

### Parâmetros

`depth` Optional

O nível de profundidade especifíca o quão profundo um array aninhando deve ser achatado. O padrão é 1.

### Retorno

Um novo array com os elementos sub-array concatenados nele.

Exemplos
--------

### Achatando arrays aninhados


```js
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8]
```

### Achatando e buracos em array

o método flat remove espaços vazios do array:


```js
var arr5 = [1, 2, , 4, 5];
arr5.flat();
// [1, 2, 4, 5]
```

Alternativa
-----------

### `reduce` e `concat`


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

// Achatar array de nível único
arr.flat();
// É equivalente à
arr.reduce((acc, val) => acc.concat(val), []);
// [1, 2, 3, 4]

// Ou com sintaxe de decomposição
const flattened = (arr) => [].concat(...arr);
```

### `reduce` + `concat` + `isArray` + recursividade


```js
var arr = [1, 2, [3, 4, [5, 6]]];

// Para achatamentos mais profundos, use recursividade com reduce e concat
function flatDeep(arr, d = 1) {
  return d > 0
    ? arr.reduce(
        (acc, val) =>
          acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val),
        [],
      )
    : arr.slice();
}

flatDeep(arr, Infinity);
// [1, 2, 3, 4, 5, 6]
```

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

| Especificação | Status | Comentários |
| --- | --- | --- |
| `Array.prototype.flat` proposal | Draft |  |

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

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

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

* `Array.prototype.flatMap()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`