Array.prototype.findIndex() - JavaScript

Array.prototype.findIndex()
===========================

O método **`findIndex()`** retorna o **índice** no array do primeiro elemento que satisfizer a função de teste provida. Caso contrário, retorna -1, indicando que nenhum elemento passou no teste.

Veja também o método `find()`, que retorna o **valor** de um elemento encontrado no array em vez de seu índice.

Sintaxe
-------
```

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

### Parâmetros

`callback`

Função para executar em cada valor no array, tomando três argumentos:

`element`

O elemento atual sendo processado no array.

`index`

O índice do elemento atual sendo processado no array.

`array`

O array sobre o qual `findIndex` foi chamado.

`thisArg`

Opcional. Objeto para usar como `this` na execução do `callback`.

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

O método `findIndex` executa a função `callback` uma vez para cada elemento presente no array até encontrar um onde o `callback` retorna um valor verdadeiro. Se tal elemento for encontrado, `findIndex` imediatamente retorna o índice deste elemento. Caso contrário, `findIndex` retorna -1. `callback` é invocado apenas para índices no array que têm valores atribuídos; nunca é invocado para índices que foram deletados ou que nunca tiveram valores atribuídos.

`callback` é invocado com três argumentos: o valor do elemento, o índice do elemento e o objeto Array sendo percorrido.

Se um parâmetro `thisArg` for fornecido para `findIndex`, ele será usado como o `this` para cada invocação do `callback`. Se não for fornecido, então `undefined` é usado.

`findIndex` não modifica o array sobre o qual é chamado.

A série de elementos processados por `findIndex` é definida antes da primeira invocação do `callback`. Elementos que são adicionados ao array depois que a chamada a `findIndex` começa não serão visitados pelo `callback`. Se um elemento existente não visitado do array for modificado pelo `callback`, seu valor passado ao `callback` será o valor no momento em que `findIndex` visitar o índice deste elemento; elementos que forem deletados não são visitados.

Exemplos
--------

### Encontrar o índice de um número primo em um array

O seguinte exemplo encontra o índice de um elemento no array que é um número primo (ou retorna -1 se não houver número primo).

```js
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, não encontrado
console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
```

Polyfill
--------

Esse método foi adicionado à especificação do ECMAScript 6 e pode não estar disponível em todas as implementações de JavaScript ainda. Contudo, você pode fazer o polyfill de `Array.prototype.findIndex` com o seguinte trecho de código:

```js
if (!Array.prototype.findIndex) {
  Array.prototype.findIndex = function (predicate) {
    if (this === null) {
      throw new TypeError(
        "Array.prototype.findIndex called on null or undefined",
      );
    }
    if (typeof predicate !== "function") {
      throw new TypeError("predicate must be a function");
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

    for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return i;
      }
    }
    return -1;
  };
}
```

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

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

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

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

Veja também
* `Array.prototype.find()`
* `Array.prototype.indexOf()`


Array.prototype.splice() - JavaScript

Array.prototype.splice()
========================

Resumo
------

O método **splice()** altera o conteúdo de uma lista, adicionando novos elementos enquanto remove elementos antigos.

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

Sintaxe
-------
```

array.splice(indice[, deleteCount[, elemento1[, ...[, elementoN]]])

array.splice(indice) // SpiderMonkey/Firefox extension
```

### Parâmetros

`indice`

Índice o qual deve iniciar a alterar a lista. Se maior que o tamanho total da mesma, nenhum elemento será alterado. Se negativo, irá iniciar a partir daquele número de elementos a partir do fim.

`deleteCount`

Um inteiro indicando o número de antigos elementos que devem ser removidos.

Se o parâmetro `deleteCount` não é especificado, ou se é maior que o número de elementos restantes na lista iniciando pelo índice, então todos os elementos até o fim da lista serão deletados.

Se `deleteCount` é 0, nenhum elemento é removido. Neste caso você deve especificar pelo menos um novo elemento.

`elemento1, ..., elementoN`

Os elementos a adicionar na lista. Se você não especificar nenhum elemento, splice simplesmente removerá elementos da mesma.

### Retorno

Uma lista contendo os elementos removidos. Se apenas um elemento é removido, por exemplo, uma lista contendo apenas um elemento é retornada. Se nenhum elemento é removido, uma lista vazia é retornada.

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

Se você especificar um número diferente de elementos a inserir comparado ao número de elementos que você está removendo, a lista terá um tamanho diferente no final da execução.

Exemplo
-------

### Exemplo: Removendo 0 elementos do indice 2, e inserindo "drum"

O script a seguir ilustra o uso do *splice*:

```js
var myFish = ["angel", "clown", "mandarin", "surgeon"];

//remove 0 elementos a partir do índice 2, e insere "drum"
var removed = myFish.splice(2, 0, "drum");
//myFish é ["angel", "clown", "drum", "mandarin", "surgeon"]
//removed é [], nenhum elemento removido

//remove 1 elemento do índice 3
removed = myFish.splice(3, 1);
//myFish é ["angel", "clown", "drum", "surgeon"]
//removed é ["mandarim"]

//remove 1 elemento a partir do índice 2, e insere "trumpet"
removed = myFish.splice(2, 1, "trumpet");
//myFish é ["angel", "clown", "trumpet", "surgeon"]
//removed é ["drum"]

//remove 2 elementos a partir do índice 0, e insere "parrot", "anemone" e "blue"
removed = myFish.splice(0, 2, "parrot", "anemone", "blue");
//myFish é ["parrot", "anemone", "blue", "trumpet", "surgeon"]
//removed é ["angel", "clown"]

//remove 2 elementos a partir do indice 3
removed = myFish.splice(3, Number.MAX\_VALUE);
//myFish é ["parrot", "anemone", "blue"]
//removed é ["trumpet", "surgeon"]
```

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

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

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

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

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

* `push` / `pop` - adiciona/remove elementos do final do array;
* `unshift` / `shift` - adiciona/remove elementos do início do array;
* `concat` - returns a new array comprised of this array joined with other array(s) and/or value(s).


Array.prototype.includes() - JavaScript

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

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

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

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.map() - JavaScript

Array.prototype.map()
=====================

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

Resumo
------

O método **map()** invoca a função `callback` passada por argumento para cada elemento do Array e devolve um novo Array como resultado.

Sintaxe
-------
```

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

### Parâmetros

`callback`

Função cujo retorno produz o elemento do novo Array. Recebe três argumentos:

`valorAtual`

O valor do elemento original do Array de origem.

`indice`

O índice do elemento atual que está sendo processado no array.

`array`

O Array de origem.

`thisArg`

Opcional. Valor a ser utilizado como o *`this`* no momento da execução da função `callback`.

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

O método **`map`** chama a função `callback` recebida por parâmetro para cada elemento do Array original, em ordem, e constrói um novo array com base nos retornos de cada chamada. A função `callback` é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que estiverem como `undefined`, 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 parametro `thisArg` foi passado para o método `map`, ele será repassado para a função `callback` no momento da invocação 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` deve respeitar as regras para determinar como o this é acessado por uma função (em inglês).

O método `map` não modifica o array original. No entanto, a função `callback` invocada por ele pode fazê-lo.

A lista de elementos que serão processados pelo `map` é montada antes da primeira invocação à função `callback`. Se um elemento for acrescentado ao array original após a chamada ao `map`, 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 `map` invocar o `callback`. Elementos removidos não serão visitados.

Exemplos
--------

### Exemplo: Mapeando um array de números para um array de raízes quadradas

O código a seguir mapeia um array de números e cria um novo array contendo o valor da raiz quadrada de cada número do primeiro array.

```js
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots é [1, 2, 3], numbers ainda é [1, 4, 9]
```

### Exemplo: Mapeando um array de números usando uma função `callback` que contém um argumento

O código a seguir mostrar como o método `map` funciona quando a função `callback` possui apenas um argumento. Esse argumento será automaticamente atribuído para cada elemento do array conforme o `map` itera sobre o array original.

```js
var numbers = [1, 4, 9];
var doubles = numbers.map(function (num) {
  return num \* 2;
});
// doubles é agora [2, 8, 18]. numbers ainda é [1, 4, 9]
```

### Exemplo: usando `map` genericamente

Esse exemplo demonstra como usar o map em um `String` para recuperar a representação em ASCII de cada caracter em um array de bytes:

```js
var map = Array.prototype.map;
var a = map.call("Hello World", function (x) {
  return x.charCodeAt(0);
});
// a agora vale [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
```

### Exemplo: usando `map` genericamente com `querySelectorAll`

Esse exemplo demonstra como iterar sobre uma coleção de objetos recuperada através de querySelectorAll. Nesse caso, vamos pegar todos os options selecionados na tela e imprimir no console:

```js
var elems = document.querySelectorAll("select option:checked");
var values = [].map.call(elems, function (obj) {
  return obj.value;
});
```

### Exemplo: Usando `map` para inverter uma string

```js
var str = "12345";
[].map
  .call(str, function (x) {
    return x;
  })
  .reverse()
  .join("");

// Output: '54321'
// Bonus: utilize '===' para verificar se a string original e a nova string são palíndromos
```

### Exemplo: Caso de uso mais complexo

(inspirado nesse post) (em inglês)

É uma prática comum utilizar o callback com apenas um argumento (o elemento atual do array original). Algumas funções também são comumente utilizadas com um argumento, mesmo tendo argumentos adicionais opcionais. Esses hábitos podem resultar em comportamentos indesejado:

```js
// Considere:
["1", "2", "3"].map(parseInt);
// Enquanto era de se esperar [1, 2, 3]
// O resultado atual é [1, NaN, NaN]

// parseInt é normalmente usado com apenas um argumento, mas ele possui dois.
// O primeiro é uma expressão, e o segundo o radical.
// Para a função callback, o Array.prototype.map repassa 3 argumentos:
// o elemento corrente, o indice e o array original
// O terceiro argumento é ignorado pelo parseInt, mas o segundo não, o que certamente gerou o comportamento inesperado. Veja o post para maiores detalhes

function returnInt(element) {
  return parseInt(element, 10);
}

["1", "2", "3"].map(returnInt); // [1, 2, 3]
// O resultado atual é um array de números (como esperado)

// Bonus: Um jeito mais simples de conseguir o mesmo resultado sem nenhuma "pegadinha do Malandro":
["1", "2", "3"].map(Number); // [1, 2, 3]
```

Polyfill
--------

(veja definição em Polyfill)

O método `map` foi introduzido ao padrão ECMA-262 na sua 5ª edição, o que significa que ele pode não estar presente em todas as implementações desse padrão. Você pode contornar esse problema inserindo o código a seguir no início dos seus scripts, permitindo o uso do `map` mesmo que ele não esteja sendo suportado nativamente. Esse algoritmo é exatamente o especificado no ECMA-262 5ª edição, assumindo que `Object`, `TypeError`, e `Array` tenham seus valores originais, e que `callback.call` avalie para o valor original de ``Function.prototype.call``.

```js
// Production steps of ECMA-262, Edition 5, 15.4.4.19
// Reference: http://es5.github.io/#x15.4.4.19
if (!Array.prototype.map) {
  Array.prototype.map = function (callback, thisArg) {
    var T, A, 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(callback) is false, throw a TypeError exception.
    // See: http://es5.github.com/#x9.11
    if (typeof callback !== "function") {
      throw new TypeError(callback + " is not a function");
    }

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

    // 6. Let A be a new array created as if by the expression new Array(len)
    // where Array is the standard built-in constructor with that name and
    // len is the value of len.
    A = new Array(len);

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

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

      // 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 mappedValue be the result of calling the Call internal
        // method of callback with T as the this value and argument
        // list containing kValue, k, and O.
        mappedValue = callback.call(T, kValue, k, O);

        // iii. Call the DefineOwnProperty internal method of A with arguments
        // Pk, Property Descriptor
        // { Value: mappedValue,
        // Writable: true,
        // Enumerable: true,
        // Configurable: true },
        // and false.

        // In browsers that support Object.defineProperty, use the following:
        // Object.defineProperty(A, k, {
        // value: mappedValue,
        // writable: true,
        // enumerable: true,
        // configurable: true
        // });

        // For best browser support, use the following:
        A[k] = mappedValue;
      }
      // d. Increase k by 1.
      k++;
    }

    // 9. return A
    return A;
  };
}
```

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

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

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

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

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

* `Array.prototype.forEach()`
* `Map` object
* `Array.from()`


Array.prototype.some() - JavaScript

Array.prototype.some()
======================

O método **`some()`** testa se ao menos um dos elementos no array passa no teste implementado pela função atribuída e retorna um valor **`true`** ou **`false`**.

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

Sintaxe
-------
```

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

### Parâmetros

`callback`

Função para testar cada elemento, recebendo três argumentos:

`currentValue`

O valor atual do elemento sendo processado no array.

`index`

O índice do elemento atual sendo processado no array.

`array`

O array onde o método `some()` foi chamado.

`thisArg`

Opcional. Valor para usar como *`this`* durante a execução do `callback`.

### Valor de retorno

Esta função retorna **`true`** se a função callback retornar **`true`** para qualquer elemento do array; caso contrário, **`false`**.

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

`some()` executa a função callback uma vez para cada elemento presente no array até achar um onde o `callback` retorne um valor *true*. Se em qualquer dos elementos o valor for encontrado, `some()` imediatamente retorna `true`. Caso contrario, `some()` retorna `false`. `callback` é invocado somente para índices do array que contenham valor definido; não é invocado para índices que foram deletados ou os quais nunca tiveram valor definido.

`callback` é invocado com três argumentos: o valor do elemento, o índice do elemento, e o array onde a função foi chamada.

Se o parâmetro `thisArg` foi passado ao `some()`, ele sera passado ao `callback` quando o mesmo for invocado, para ser usado como o valor de `this` internamente na função callback. Caso contrario, o valor `undefined` será passado para uso como `this`. O valor `this` observado pela `callback` é determinado de acordo com as regras usuais para determinar o que é visto por uma função.

`some()` não altera o array dentro do qual ele é chamado.

O intervalo de elementos processado por `some()` é definido antes da primeira invocação da `callback`. Elementos contidos no array antes da chamada `some()` ser iniciada não serão testados pela *callback*. Se algum elemento pertencente ao array for alterado pela `callback`, o valor passado para a `callback` será o valor do momento em que a função `some()` encontra o índice daquele elemento. Elementos deletados não são testados.

Exemplos
--------

### Testando valores de elementos de um array

O exemplo a seguir testa se algum elemento de um array é maior que 10.

```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
```

### Testando valores de elementos de um array usando arrow functions

Arrow functions fornece uma sintaxe mais curta para o mesmo teste.

```js
[2, 5, 8, 1, 4].some((elem) => elem > 10); // false
[12, 5, 8, 1, 4].some((elem) => elem > 10); // true
```

Polyfill
--------

`some()` was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of `some()` in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming `Object` and `TypeError` have their original values and that `fun.call` evaluates to the original value of `Function.prototype.call()`.

```js
// Production steps of ECMA-262, Edition 5, 15.4.4.17
// Reference: http://es5.github.io/#x15.4.4.17
if (!Array.prototype.some) {
  Array.prototype.some = function (fun /\*, thisArg\*/) {
    "use strict";

    if (this == null) {
      throw new TypeError("Array.prototype.some called on null or undefined");
    }

    if (typeof fun !== "function") {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;

    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisArg, t[i], i, t)) {
        return true;
      }
    }

    return false;
  };
}
```

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

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

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.every()`
* `TypedArray.prototype.some()` (en-US)


Array.prototype.find() - JavaScript

Array.prototype.find()
======================

O método **`find()`** retorna o **valor** do **primeiro elemento** do array que satisfizer a função de teste provida. Caso contrario, `undefined` é retornado.

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

Veja também o método `findIndex()`, que retorna o **índice** do elemento encontrado no array ao invés do seu valor.

Se você precisa encontrar a posição de um elemento ou se um elemento existe em um array, use `Array.prototype.indexOf()` ou `Array.prototype.includes()`.

Sintaxe
-------
```

arr.find(callback(element[, index[, array]])[, thisArg])
```

### Parâmetros

`callback`

Função executada a cada iteração do array, recebendo três argumentos:

`element`

O elemento atual que está sendo processado no array.

`index`Optional

O índice do elemento atualmente sendo processado no array.

`array`Optional

O array sobre o qual `find` foi chamado.

`thisArg`Optional

Opcional. Objeto usado como `this` quando executando o `callback`.

### Valor retornado

O **valor** do **primeiro elemento** do array que satisfaz a função de teste fornecida; caso contrário, `undefined`.

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

O método `find` executa a função `callback` uma vez para cada elemento presente no array até que encontre um onde `callback` retorne o valor true. Se o elemento é encontrado, `find` retorna imediatamente o valor deste elemento. Caso contrário, `find` retorna `undefined`. O `callback` é acionado para todos os índices do array de `0` a `tamanho-1`, não apenas para aqueles que possuem valores atribuídos. Sendo assim, ele pode ser menos eficiente para arrays muito grandes em que existem outros métodos que só visitam os índices que tenham valor atribuído.

O `callback` é acionado com três argumentos: o valor do elemento, o índice do elemento e o objeto do Array que está sendo executado.

Se um parâmetro `thisArg` é provido ao `find`, ele será usado como o `this` para cada acionamento do `callback`. Se não for provido, então `undefined` é usado.

O `find` não altera a array à qual foi acionado.

O conjunto dos elementos processados por `find` é definido antes do primeiro acionamento do `callback`. Elementos que são anexados à array após o início da chamada ao `find` não serão visitados pelo `callback`. Se um elemento existente ainda não visitado da array for alterado pelo `callback`, o valor passado ao `callback` quando o visitar será o valor no momento que `find` visita o índice daquele elemento; elementos excluídos ainda são visitados.

Exemplos
--------

### Encontrar um objeto em um array por uma de suas propriedades

```js
const inventory = [
  { name: "apples", quantity: 2 },
  { name: "bananas", quantity: 0 },
  { name: "cerejas", quantity: 5 },
];

function isCherries(fruit) {
  return fruit.name === "cerejas";
}

console.log(inventory.find(isCherries));
// { name: 'cerejas', quantity: 5 }
```

#### Utilizando arrow function

```js
const inventory = [
  { name: "maças", quantity: 2 },
  { name: "bananas", quantity: 0 },
  { name: "cherries", quantity: 5 },
];

const result = inventory.find((fruit) => fruit.name === "cherries");

console.log(result); // { name: 'cherries', quantity: 5 }
```

### Encontrar um número primo em um array

O exemplo a seguir encontra um elemento dentro da array que é número primo (ou retorna `undefined` se não houverem números primos).

```js
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
console.log([4, 5, 8, 12].find(isPrime)); // 5
```

Polyfill
--------

Este método foi adicionado à especificação do ECMAScript 2015 e pode não estar disponível em todas as implementações do JavaScript. Entretanto, você pode fazer um polyfill para o `Array.prototype.find` com o trecho de código abaixo:

```js
if (!Array.prototype.find) {
  Array.prototype.find = function (predicate) {
    if (this === null) {
      throw new TypeError("Array.prototype.find called on null or undefined");
    }
    if (typeof predicate !== "function") {
      throw new TypeError("predicate must be a function");
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

    for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return value;
      }
    }
    return undefined;
  };
}
```

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

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

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

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

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

* `Array.prototype.findIndex()`
Experimental
* `Array.prototype.every()`


Array.prototype.toString() - JavaScript

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

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

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

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

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

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.copyWithin() - JavaScript

Array.prototype.copyWithin()
============================

O método **`copyWithin()`** copia parte de um array para outra localização no mesmo array e o retorna sem alterar seu tamanho.

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

Sintaxe
-------

```js
copyWithin(target)
copyWithin(target, start)
copyWithin(target, start, end)
```

### Parâmetros

`target`

Índice de base zero à qual copiar a sequência para, convertido para inteiro.

* Índice negativo será contado a partir do final do array — se `target < 0`, `target + array.length` é utilizado.
* Se `target < -array.length`, `0` é utilizado.
* Se `target >= array.length`, nada é copiado.
* Se `target` é posicionado após `start` depois da normalização, a cópia só acontece até o final do `array.length` (em outras palavras, `copyWithin()` nunca estende o array).

`start` Optional

Índice de base zero à qual inicia a cópia dos elementos a partir de, convertido para inteiro.

* Índice negativo será contado a partir do final do array — se `start < 0`, `start + array.length` é utilizado.
* Se `start < -array.length` ou `start` é omitido, `0` é utilizado.
* Se `start >= array.length`, nada é copiado.

`end` Optional

Índice de base zero à qual termina a cópia dos elementos a partir de, convertido para inteiro. `copyWithin()` copia até, mas não inclui o `end`.

* Índice negativo será contado a partir do final do array — se `end < 0`, `end + array.length` é utilizado.
* Se `end < -array.length`, `0` é utilizado.
* Se `end >= array.length` ou `end` é omitido, `array.length` é utilizado, fazendo com que todos os elementos até o final sejam copiados.
* Se `end` é posicionado antes ou em `start` após a normalização, nada será copiado.

### Valor de retorno

O array modificado.

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

O método `copyWithin()` funciona como o `memmove` do C e C++, e é um método de alta performance para troca de dados de um `Array`. Isso se aplica especialmente ao método `TypedArray` (en-US) de mesmo nome. A sequência é copiada e colada como uma operação; a sequência colada terá os valores copiados mesmo quando a região de copiar e colar se sobrepuserem.

O método `copyWithin()` é um método mutável. Ele não altera o comprimento de `this`, mas mudará o conteúdo de `this` e criará novas propriedades ou excluirá propriedades existentes, se necessário.

O método `copyWithin()` preserva slots vazios. Se a região a ser copiada for sparse, os novos índices correspondentes dos slots vazios são excluídos (en-US) e também se tornam slots vazios.

O método `copyWithin()` é genérico. Ele apenas espera que o valor de `this` tenha uma propriedade `length` e propriedades integer-keyed. Embora as strings também sejam semelhantes a arrays, esse método não é adequado para ser aplicado nelas, pois as strings são imutáveis.

Exemplos
--------

### Usando copyWithin()

```js
console.log([1, 2, 3, 4, 5].copyWithin(-2));
// [1, 2, 3, 1, 2]

console.log([1, 2, 3, 4, 5].copyWithin(0, 3));
// [4, 5, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(0, 3, 4));
// [4, 2, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(-2, -3, -1));
// [1, 2, 3, 3, 4]
```

### Usando copyWithin() em arrays sparse

`copyWithin()` propagará slots vazios(empty).

```js
console.log([1, , 3].copyWithin(2, 1, 2)); // [1, empty, empty]
```

### Chamando copyWithin() em objetos não array

O método `copyWithin()` lê a propriedade `length` do `this` e então manipula os índices inteiros envolvidos.

```js
const arrayLike = {
  length: 5,
  3: 1,
};
console.log(Array.prototype.copyWithin.call(arrayLike, 0, 3));
// { '0': 1, '3': 1, length: 5 }
console.log(Array.prototype.copyWithin.call(arrayLike, 3, 1));
// { '0': 1, length: 5 }
// A propriedade '3' é excluída porque a fonte copiada é um slot vazio.
```

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

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

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

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

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

* Polyfill de `Array.prototype.copyWithin` no `core-js`
* Coleções indexadas
* `Array`
* `TypedArray.prototype.copyWithin()` (en-US)


Array.prototype.forEach() - JavaScript

Array.prototype.forEach()
=========================

O método `forEach()` executa uma dada função em cada elemento de um array.

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

Sintaxe
-------
```

arr.forEach(callback(currentValue [, index [, array]])[, thisArg]);
```

### Parâmetros

`callback`

Função para executar em cada elemento, recebendo três argumentos:

`currentValue`

O valor atual do elemento sendo processado no array.

`index` Optional

O índice do elemento atual sendo processado no array.

`array` Optional

O array que `forEach()` está sendo aplicado.

`thisArg` Optional

Opcional. Valor a ser usado como `this` quando executar `callback`.

### Valor retornado

`undefined`.

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

O `forEach` executa o `callback` fornecido uma vez para cada elemento da ordem com um valor atribuido. Ele não é invocado para propriedades de índices que foram deletados ou que não foram inicializados (por ex. em arrays esparsos).

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

* o **valor do elemento**
* o **índice do elemento**
* o **array que está sendo percorrido**

Se um parâmetro `thisArg` for passado para `forEach()`, ele será passado para o `callback` quando invocado como valor para `this`. Caso contrário, o valor `undefined` será passado como valor para `this`. O valor de `this` assumido no `callback` é determinado de acordo com as regras usuais para determinação do `this` visto por uma função.

O intervalo dos elementos processados por `forEach()` é determinado antes da primeira invocação do `callback`. Elementos que forem adicionados ao array depois da chamada ao `forEach()` começar não serão visitados pelo `callback`. Se os valores dos elementos existentes do array forem alterados, o valor passado para o `callback` será o valor no momento em que o `forEach()` visitá-los; elementos que forem deletados antes de serem visitados não serão visitados.

`forEach()` executa a a função `callback` uma vez para cada elemento do array – diferentemente de `map()` ou `reduce()`, ele sempre retorna o valor `undefined` e não é encadeável. O caso de uso típico é alterar o array no final do loop.

**Nota:** A única maneira de parar ou interromper um loop `forEach()` é disparando uma exceção. Se você precisa desse recurso, o método `forEach()` é a ferramenta errada. Você estará mais bem servido com um loop simples nesse caso. Se estiver testando o array de elementos para um predicado e precisar de um valor de retorno Boleano, você pode usar `every()` ou `some()`. Se estiverem disponíveis, os novos métodos `find()` e `findIndex()` também podem ser usados para terminação antecipada em predicados verdadeiros.

Exemplos
--------

### Imprimindo os conteúdos de uma ordem

Os códigos a seguir logam uma linha para cada elemento na ordem:

```js
function logArrayElements(element, index, array) {
  console.log("a[" + index + "] = " + element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9
```

### Função para cópia de um objeto

O código a seguir cria uma cópia para cada objeto dado. Há diferentes formas de criar uma cópia para um objeto. Esta é somente uma forma de explicar como `Array.prototype.forEach` funciona. Ela usa um grupo de novas funções ECMAScript 5 Object.\*

```js
function copy(o) {
  var copy = Object.create(Object.getPrototypeOf(o));
  var propNames = Object.getOwnPropertyNames(o);

  propNames.forEach(function (name) {
    var desc = Object.getOwnPropertyDescriptor(o, name);
    Object.defineProperty(copy, name, desc);
  });

  return copy;
}

var o1 = { a: 1, b: 2 };
var o2 = copy(o1); // o2 looks like o1 now
```

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

`forEach` é uma adição recente para o ECMA-262 standard; assim sendo, pode não estar presente em outras implementações do standard. Você pode contornar isto pela inserção do código a seguir no começo de seus scripts, permitindo o uso de `forEach` em implementações que normalmente não possuem este suporte.

```js
if (!Array.prototype.forEach) {
  Array.prototype.forEach = function (fn, scope) {
    for (var i = 0, len = this.length; i < len; ++i) {
      fn.call(scope, this[i], i, this);
    }
  };
}
```

Um algorítimo 100% verdadeiro para a 5ª Edição do ECMA-262, pode ser visto abaixo:

O algoritmo é exatamente o especificado na 5ª Edição da ECMA-262, assumindo `Object` e `TypeError` possuem seus valores originais e avalia `callback.call` para o valor original de `Function.prototype.call` (en-US).

```js
// Production steps of ECMA-262, Edition 5, 15.4.4.18
// Reference: http://es5.github.com/#x15.4.4.18
if (!Array.prototype.forEach) {
  Array.prototype.forEach = function forEach(callback, thisArg) {
    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; // Hack to convert O.length to a UInt32

    // 4. If IsCallable(callback) is false, throw a TypeError exception.
    // See: http://es5.github.com/#x9.11
    if ({}.toString.call(callback) !== "[object Function]") {
      throw new TypeError(callback + " is not a function");
    }

    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
    if (thisArg) {
      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 (Object.prototype.hasOwnProperty.call(O, k)) {
        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
        kValue = O[k];

        // ii. Call the Call internal method of callback with T as the this value and
        // argument list containing kValue, k, and O.
        callback.call(T, kValue, k, O);
      }
      // d. Increase k by 1.
      k++;
    }
    // 8. return undefined
  };
}
```

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

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

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

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

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

* `Array.prototype.find()`
* `Array.prototype.findIndex()`
* `Array.prototype.map()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Map.prototype.forEach()`
* `Set.prototype.forEach()` (en-US)


Array.prototype.toLocaleString() - JavaScript

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.indexOf() - JavaScript

Array.prototype.indexOf()
=========================

O método **`indexOf()`** retorna o primeiro índice em que o elemento pode ser encontrado no array, retorna -1 caso o mesmo não esteja presente.

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

Sintaxe
-------
```

array.indexOf(elementoDePesquisa, [pontoInicial = 0])
```

### Parâmetros

`elementoDePesquisa`

`Elemento a ser pesquisado no array.`

`pontoInicial`

O índice para iniciar a procura. Se o índice for maior ou igual ao tamanho do array, é retornado -1 e signfica que o item não será procurado. Se o `pontoInicial` é fornecido com um número negativo, é tomado como deslocamento da extremidade do array. Nota: se o `pontoInicial` fornecido é negativo, a procura no array acontece de frente para trás. Se o `pontoInicial` fornecido é 0, então o array inteiro será pesquisado. Padrão: 0 (pesquisa em todo array).

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

`indexOf()` compara o `elementoDePesquisa` com os elementos do Array usando igualdade estrita (en-US) (o mesmo método usado pelo ===, ou triple-equals operator).

Exemplos
--------

### Usando `indexOf()`

`O exemplo seguinte usa indexOf() para localizar valores em um array`

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

### Encontrar todas as ocorrências de um elemento

```js
var indices = [];
var array = ["a", "b", "a", "c", "a", "d"];
var elemento = "a";
var idx = array.indexOf(elemento);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(elemento, idx + 1);
}
console.log(indices);
// [0, 2, 4]
```

### Encontrar se um elemento existe ou não e atualizar o array

```js
function atualizarColecaoVegetais(vegetais, vegetal) {
  if (vegetais.indexOf(vegetal) === -1) {
    vegetais.push(vegetal);
    console.log("Nova coleção de vegetais é : " + vegetais);
  } else if (vegetais.indexOf(vegetal) > -1) {
    console.log(vegetal + " já existe na coleção de vegetais.");
  }
}

var vegetais = ["batata", "tomate", "pimenta", "pimentao"];

atualizarColecaoVegetais(vegetais, "espinafre");
// Nova coleção de vegatais é : batata,tomate,pimenta,pimentao,espinafre
atualizarColecaoVegetais(vegetais, "espinafre");
// espinafre já existe na coleção de vegetais.
```

Polyfill
--------

`indexOf()` foi adicionado ao ECMA-262 standard em sua 5 edição; como tal, não pode estar presente em todos navegadores.Você pode contornar isso utilizando o seguinte codigo no inicio de seus scripts. Isto permitirá que voce use o `indexOf()` quando não possuir suporte nativo. Esse algoritmo corresponde ao especificado no ECMA-262, edição 5, assumindo `TypeError` e `Math.abs()` tem seus valores originais.

```js
// Passos para a produção do ECMA-262, Edition 5, 15.4.4.14
// Referência: http://es5.github.io/#x15.4.4.14
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function (elementoDePesquisa, pontoInicial) {
    var k;

    //1. Deixe-o ser o resultado da chamada de toObject
    // passando o valor de this como argumento.
    if (this == null) {
      throw new TypeError(
        '"this" é nulo (null) ou não foi definido (undefined)',
      );
    }

    var O = Object(this);

    // 2. Deixar o tamanhoValor ser o resultado da
    // chamada do método interno Get de 0 com o
    // argumento "length"
    // 3. Deixar o tamanhoValor ser um ToUint32(tamanhoValor).
    var tamanho = O.length >>> 0;

    // 4. se o tamanho é 0, retorna -1.
    if (tamanho === 0) {
      return -1;
    }

    // 5. Se o argumento pontoInicial for passado,
    // use o ToInteger(pontoInicial); senao use 0.
    var n = +pontoInicial || 0;

    if (Math.abs(n) === Infinity) {
      n = 0;
    }

    //6. Se n >= tamanho, retorna -1.
    if (n >= tamanho) {
      return -1;
    }

    // 7. Se n>= 0, entao k seja n.
    // 8. Senao, n<0, k seja tamanho - abs(n).
    // Se k é menor que 0, entao k seja 0.
    k = Math.max(n >= 0 ? n : tamanho - Math.abs(n), 0);

    // 9. Repita, enquanto k < tamanho
    while (k < tamanho) {
      // a. Deixe Pk ser ToString(k).
      // isto é implicito para operandos LHS de um operador

      // b. Deixe o kPresent ser o resultado da chamada do método
      // interno de 0 com argumento Pk
      // Este passo pode ser combinado com c.
      // c. Se kPresent é true, entao
      // i. Deixe o elementK ser o resultado da chamada do metodo
      // interno Get de 0 com argumento ToString(k)
      // ii. Deixe o resultado ser aplicado pelo Algoritmo de
      // Comparação de Igualdade Estrita (Strict Equality Comparison)
      // para o elementoDePesquisa e elementK
      // iii. caso verdadeiro, retorne k.
      if (k in O && O[k] === elementoDePesquisa) {
        return k;
      }
      k++;
    }
    return -1;
  };
}
```

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

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

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

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

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

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


Array.prototype.flat() - JavaScript

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


Array.from() - JavaScript

Array.from()
============

Resumo
------

O método **`Array.from()`** cria uma nova instância `de um Array` quando for passado um array-like ou um iterable object como argumento.

No ES6, a sintaxe de classe permite a subclassificação de classes nativas e classes definidas pelo usuário; como resultado, os métodos estáticos pertencentes a classe, como **`Array.from`**, são "herdadas" por subclasses do **`Array`** e criam novas instâncias da subclasse, não do **`Array`**.

Sintaxe
-------
```

Array.from(arrayLike[, mapFn[, thisArg]])
```

### Parâmetros

`arrayLike`

Um array-like ou um objeto iterável para converter em array.

`mapFn`

*Opcional*. Função Map que será chamada para cada elemento do array.

`thisArg`

*Opcional*. Valor a ser utilizado como this quando a mapFn for chamada.

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

`Array.from()` deixa você criar um Array de:

* objetos array-like (objetos com a propriedade `length` e elementos indexados); ou
* Objetos iteráveis (en-US) (objetos onde você pode coletar seus elementos, assim como `Map` e `Set`).

`Array.from()` tem um parametro opcional `mapFn`, que permite executar a função `map` para cada elemento do array (ou subclasse de objeto) que está sendo criado. Simplificando, `Array.from(obj, mapFn, thisArg)` é o mesmo que `Array.from(obj).map(mapFn, thisArg)`, com a excessão de não cria um array intermediário . Isso é importante, principalmente para certas subclasses de array, como typed array, no qual o array intermediário iria necessáriamente ter o valor truncado para encaixar-se no tipo apropriado.

A propriedade `length` do método `from()` é `1`.

No ES2015, a sintaxe de class permite a definição de subclasses tanto internas quando definidas pelo usuário. Como resultado, métodos estáticos como `Array.from()` são "herdados" pelas subclasses de `Array`, e cria novas instâncias da subclasse, não de `Array`.

Polyfill
--------

`Array.from` foi adicionado ao padrão ECMA-262 em sua 6ª edição; desta forma, não está presente na aplicações anteriores da especificação. Na ausência do código nativo, você pode inserir o código seguinte no início do script, permitindo `o uso parcial da funcionalidade do Array.from`. Esse algorítmo é equivalente ao especificado no ECMA-262, 6ª edição, exceto que `Object` e `TypeError` tem seus valores originais e que `callback.call` retorna o valor original de `Function.prototype.call`. Além disso, os verdadeiros iterables não podem ser representados genéricamente no polyfill, criando a principal distinção do que foi definido na especificação.

```js
// Production steps of ECMA-262, Edition 6, 22.1.2.1
// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
if (!Array.from) {
  Array.from = (function () {
    var toStr = Object.prototype.toString;
    var isCallable = function (fn) {
      return typeof fn === "function" || toStr.call(fn) === "[object Function]";
    };
    var toInteger = function (value) {
      var number = Number(value);
      if (isNaN(number)) {
        return 0;
      }
      if (number === 0 || !isFinite(number)) {
        return number;
      }
      return (number > 0 ? 1 : -1) \* Math.floor(Math.abs(number));
    };
    var maxSafeInteger = Math.pow(2, 53) - 1;
    var toLength = function (value) {
      var len = toInteger(value);
      return Math.min(Math.max(len, 0), maxSafeInteger);
    };

    // The length property of the from method is 1.
    return function from(arrayLike /\*, mapFn, thisArg \*/) {
      // 1. Let C be the this value.
      var C = this;

      // 2. Let items be ToObject(arrayLike).
      var items = Object(arrayLike);

      // 3. ReturnIfAbrupt(items).
      if (arrayLike == null) {
        throw new TypeError(
          "Array.from requires an array-like object - not null or undefined",
        );
      }

      // 4. If mapfn is undefined, then let mapping be false.
      var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
      var T;
      if (typeof mapFn !== "undefined") {
        // 5. else
        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
        if (!isCallable(mapFn)) {
          throw new TypeError(
            "Array.from: when provided, the second argument must be a function",
          );
        }

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

      // 10. Let lenValue be Get(items, "length").
      // 11. Let len be ToLength(lenValue).
      var len = toLength(items.length);

      // 13. If IsConstructor(C) is true, then
      // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len.
      // 14. a. Else, Let A be ArrayCreate(len).
      var A = isCallable(C) ? Object(new C(len)) : new Array(len);

      // 16. Let k be 0.
      var k = 0;
      // 17. Repeat, while k < len… (also steps a - h)
      var kValue;
      while (k < len) {
        kValue = items[k];
        if (mapFn) {
          A[k] =
            typeof T === "undefined"
              ? mapFn(kValue, k)
              : mapFn.call(T, kValue, k);
        } else {
          A[k] = kValue;
        }
        k += 1;
      }
      // 18. Let putStatus be Put(A, "length", len, true).
      A.length = len;
      // 20. Return A.
      return A;
    };
  })();
}
```

Exemplos
--------

```js
// Array-like object (arguments) para um Array
function f() {
  return Array.from(arguments);
}

f(1, 2, 3);
// [1, 2, 3]

// Qualquer iterable object ...
// com Set
var s = new Set(["foo", window]);
Array.from(s);
// ["foo", window]

// Map
var m = new Map([
  [1, 2],
  [2, 4],
  [4, 8],
]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]

// String
Array.from("foo");
// ["f", "o", "o"]

// Usando um arrow function como função map para
// manipular os elementos
Array.from([1, 2, 3], (x) => x + x);
// [2, 4, 6]

// Gerando uma sequência de números
Array.from({ length: 5 }, (v, k) => k);
// [0, 1, 2, 3, 4]
```

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

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

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

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

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

* `Array`
* `Array.prototype.map()`
* `TypedArray.from()` (en-US)


Array.prototype.shift() - JavaScript

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.reduce() - JavaScript

Array.prototype.reduce()
========================

O método **`reduce()`** executa uma função **reducer** (fornecida por você) para cada elemento do array, resultando num único valor de retorno.

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

A função **reducer** recebe quatro parâmetros:

1. Acumulador (`acc`)
2. Valor Atual (`cur`)
3. Index Atual (`idx`)
4. Array original (`src`)

O valor de retorno da sua função **reducer** é atribuída ao acumulador. O acumulador, com seu valor atualizado, é repassado para cada iteração subsequente pelo array, que por fim, se tornará o valor resultante, único, final.

Sintaxe
-------

```js
array.reduce(callback( acumulador, valorAtual[, index[, array]] )[, valorInicial])
```

### Parâmetros

`callback`

Função que é executada em cada valor no array (exceto no primeiro, se nenhum `valorInicial` for passado); recebe quatro argumentos:

`acumulador`

É o valor inicial (ou o valor do callback anterior). Este valor inicia com o `valorInicial` e será retornado na última iteração.

`valorAtual`

Opcional. O índice do elemento atual que está sendo processado no array. Começa a partir do index `0` se um `valorInicial` for fornecido. Do contrário, começa do index `1`.

`valorInicial`

Opcional. Valor a ser usado como o primeiro argumento da primeira chamada da função `callback`. Se nenhum `valorInicial` é fornecido, o primeiro elemento do array será usado como o valor inicial do `acumulador` e o `valorAtual` não será lido. Chamar `reduce()` em uma array vazia sem valor inicial retornará um erro.

### Valor retornado

O valor que resulta da execução da função de callback do "reducer" até a conclusão de todo o array.

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

O método `reduce()` executa a função de `callback` uma vez para cada elemento presente no array, excluindo furos (valores indefinidos), recebendo quatro argumentos:

1. *acumulador* - valor inicial (ou o valor do callback anterior),
2. *valorAtual* - o valor do elemento atual
3. *index* - o índice atual e
4. `array` - o array onde a iteração está ocorrendo.

A primeira vez que o callback é chamado, o `acumulador` e o `valorAtual` podem ter um de dois valores possíveis. Se o `valorInicial` tiver sido fornecido na chamada à função `reduce()`, então o `acumulador` será igual ao `valorInicial` e o `valorAtual` será igual ao primeiro valor no array. Caso nenhum `valorInicial` seja fornecido, `acumulador` será igual ao primeiro valor no array, e `valorAtual` será igual ao segundo.

**Nota:** Se o `valorInicial` não tiver sido passado como argumento, então reduce() executará o callback da função começando a partir do índice 1 (index 1), pulando o primeiro índice (`index 0`). Se o `valorInicial` for passado como argumento, a função irá começar no index 0.

Se a array estiver vazia e o `valorInicial` não tiver sido informado, uma exceção do tipo `TypeError` será lançada.

Se a array possuir somente um elemento (independente da posição) e o `valorInicial` não tiver sido fornecido, ou se `valorInicial` for fornecido, mas a array estiver vazia, o valor será retornado sem que a função de `callback` seja chamada.

É mais seguro prover um `valorInicial`, porque existem até *quatro* possíveis saídas sem o `valorInicial`, como mostrado no exemplo:

```js
var maxCallback = (acc, cur) => Math.max(acc.x, cur.x);
var maxCallback2 = (max, cur) => Math.max(max, cur);

// reduce() sem valores iniciais
[{ x: 22 }, { x: 42 }].reduce(maxCallback); // 42
[{ x: 22 }].reduce(maxCallback); // { x: 22 }
[].reduce(maxCallback); // TypeError

// map/reduce; melhor solução, funciona para vetores vazios e tambem para vetores grandes
[{ x: 22 }, { x: 42 }].map((el) => el.x).reduce(maxCallback2, -Infinity);
```

### Como funciona o reduce()

Suponha que o seguinte uso de reduce() tenha ocorrido:

```js
[0, 1, 2, 3, 4].reduce(function (acumulador, valorAtual, index, array) {
  return acumulador + valorAtual;
});
// 10
```

O callback será invocado quatro vezes, com os argumentos e valores em cada chamada sendo:

|  | `acumulador` | valorAtual | index | `array` | **valor de retorno** |
| --- | --- | --- | --- | --- | --- |
| primeira chamada | `0` | `1` | `1` | `[0, 1, 2, 3, 4]` | `1` |
| segunda chamada | `1` | `2` | `2` | `[0, 1, 2, 3, 4]` | `3` |
| terceira chamada | `3` | `3` | `3` | `[0, 1, 2, 3, 4]` | `6` |
| quarta chamada | `6` | `4` | `4` | `[0, 1, 2, 3, 4]` | `10` |

O valor retornado pelo `reduce` será o da última chamada à callback `(10)`.

Você também pode usar uma Arrow Function em vez de uma função completa. O código abaixo produz a mesma saída que o código do bloco acima:

```js
[0, 1, 2, 3, 4].reduce((accum, curr) => accum + curr);
```

Se você informar um `valorInicial` como o segundo argumento de reduce, o resultado será:

```js
[0, 1, 2, 3, 4].reduce(function (acumulador, valorAtual, indice, array) {
  return acumulador + valorAtual;
}, 10);

// 20
```

| `callback` | `acumulador` | `valorAtual` | `index` | `array` | `valor de retorno` |
| --- | --- | --- | --- | --- | --- |
| primeira chamada | `10` | `0` | `0` | `[0, 1, 2, 3, 4]` | `10` |
| segunda chamada | `10` | `1` | `1` | `[0, 1, 2, 3, 4]` | `11` |
| terceira chamada | `11` | `2` | `2` | `[0, 1, 2, 3, 4]` | `13` |
| quarta chamada | `13` | `3` | `3` | `[0, 1, 2, 3, 4]` | `16` |
| quinta chamada | `16` | `4` | `4` | `[0, 1, 2, 3, 4]` | `20` |

O retorno da última chamada `20`,é retornado como resultado da função `reduce()`.

Exemplos
--------

### Soma todos os valores de uma array

```js
let total = [0, 1, 2, 3].reduce(function (acumulador, valorAtual) {
  return acumulador + valorAtual;
}, 0);
// retorna 6
```

outra alternativa é usar uma arrow function:

```js
var total = [0, 1, 2, 3].reduce(
  (acumulador, valorAtual) => acumulador + valorAtual,
  0,
);
```

### Soma de valores de um objeto de um array

Para resumir os valores contidos em um array, você **deve** fornecer um `valorInicial`, para que cada item passe por sua função.

```js
var valorInicial = 0;
var soma = [{ x: 1 }, { x: 2 }, { x: 3 }].reduce(function (
  acumulador,
 valorAtual,
) {
  return acumulador + valorAtual.x;
}, valorInicial);

console.log(soma); // retorna 6
```

Utilizando uma arrow function:

```js
var valorInicial = 0;
var soma = [{ x: 1 }, { x: 2 }, { x: 3 }].reduce(
  (acumulador, valorAtual) => acumulador + valorAtual.x,
  valorInicial,
);

console.log(soma); // retorna 6
```

### Redução de um array de arrays

```js
let reduzido = [
  [0, 1],
  [2, 3],
  [4, 5],
].reduce(function (acumulador, valorAtual) {
  return acumulador.concat(valorAtual);
}, []);
// reduzido é [0, 1, 2, 3, 4, 5]
```

Utilizando uma arrow function:

```js
let reduzido = [
  [0, 1],
  [2, 3],
  [4, 5],
].reduce((acumulador, valorAtual) => acumulador.concat(valorAtual), []);
```

### Contando valores iguais em um objeto

```js
let nomes = ["Alice", "Bob", "Tiff", "Bruce", "Alice"];

let quantidadeNomes = nomes.reduce(function (todosNomes, nome) {
  if (nome in todosNomes) {
    todosNomes[nome]++;
  } else {
    todosNomes[nome] = 1;
  }
  return todosNomes;
}, {});
// quantidade de nomes:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }
```

### Agrupando objetos por uma propriedade

```js
let pessoas = [
  { nome: "Alice", idade: 21 },
  { nome: "Max", idade: 20 },
  { nome: "Jane", idade: 20 },
];

function agruparPor(objetoArray, propriedade) {
  return objetoArray.reduce(function (acc, obj) {
    let key = obj[propriedade];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
}

let grupodePessoas = agruparPor(pessoas, "idade");
// grupodePessoas é:
// {
// 20: [
// { nome: 'Max', idade: 20 },
// { nome: 'Jane', idade: 20 }
// ],
// 21: [{ nome: 'Alice', idade: 21 }]
// }
```

### Juntando arrays contidos num array de objetos usando o operador spread e o `valorInicial`

```js
// friends - um array de objetos
// onde o campo "books" é a lista de livros favoritos
var friends = [
  {
    name: "Anna",
    books: ["Bible", "Harry Potter"],
    age: 21,
  },
  {
    name: "Bob",
    books: ["War and peace", "Romeo and Juliet"],
    age: 26,
  },
  {
    name: "Alice",
    books: ["The Lord of the Rings", "The Shining"],
    age: 18,
  },
];

// allbooks - lista que contém todos os livros de friends +
// lista adicional contida em valorInicial
var allbooks = friends.reduce(
  function (prev, curr) {
    return [...prev, ...curr.books];
  },
  ["Alphabet"],
);

// allbooks = [
// 'Alphabet', 'Bible', 'Harry Potter', 'War and peace',
// 'Romeo and Juliet', 'The Lord of the Rings',
// 'The Shining'
// ]
```

### Removendo itens duplicados num array

**Nota:** Se você estiver usando um ambiente compatível com `Set` and `Array.from()`, você pode usar `let orderedArray = Array.from(new Set(myArray))` para obter um array em que os itens duplicados tenham sido removidos.

```js
let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4];
let result = arr.sort().reduce((init, current) => {
  if (init.length === 0 || init[init.length - 1] !== current) {
    init.push(current);
  }
  return init;
}, []);
console.log(result); //[1,2,3,4,5]
```

### Substituindo .filter().map() por .reduce()

Usar `Array.filter()` seguido por `Array.map()` faz com que o array seja percorrido duas vezes. Você pode obter o mesmo resultado percorrendo o array apenas uma vez com `Array.reduce()`, o que é, portanto, mais eficiente. (Se você gosta de for loops, você pode usar filter e map percorrendo o array apenas uma vez com `Array.forEach()`).

```js
const numbers = [-5, 6, 2, 0];

const doubledPositiveNumbers = numbers.reduce((accumulator, currentValue) => {
  if (currentValue > 0) {
    const doubled = currentValue \* 2;
    accumulator.push(doubled);
  }
  return accumulator;
}, []);

console.log(doubledPositiveNumbers); // [12, 4]
```

### Rodando promises em sequência

```js
/\*\*
 \* Roda promises de um promise array de uma maneira encadeada
 \*
 \* @param {array} arr - promise arr
 \* @return {Object} promise object
 \*/
function runPromiseInSequense(arr) {
  return arr.reduce((promiseChain, currentPromise) => {
    return promiseChain.then((chainedResult) => {
      return currentPromise(chainedResult).then((res) => res);
    });
  }, Promise.resolve());
}

// promise function 1
function p1() {
  return new Promise((resolve, reject) => {
    resolve(5);
  });
}

// promise function 2
function p2(a) {
  return new Promise((resolve, reject) => {
    resolve(a \* 2);
  });
}

// promise function 3
function p3(a) {
  return new Promise((resolve, reject) => {
    resolve(a \* 3);
  });
}

const promiseArr = [p1, p2, p3];
runPromiseInSequense(promiseArr).then((res) => {
  console.log(res); // 30
});
```

### Escrever map usando reduce

```js
if (!Array.prototype.mapUsingReduce) {
  Array.prototype.mapUsingReduce = function (callback, thisArg) {
    return this.reduce(function (mappedArray, currentValue, index, array) {
      mappedArray[index] = callback.call(thisArg, currentValue, index, array);
      return mappedArray;
    }, []);
  };
}

[1, 2, , 3].mapUsingReduce(
  (currentValue, index, array) => currentValue + index + array.length,
); // [5, 7, , 10]
```

Polyfill
--------

`Array.prototype.reduce` foi adicionado ao padrão ECMA-262 na quinta edição; e portanto, pode não estar presente em todas as implementações do padrão. Você pode contornar isso inserindo o código a seguir no início de seus scripts, permitindo o uso do `reduce()` em implementações que não possuem suporte nativo a ele.

```js
// Etapas de produção para o ECMA-262, Edition 5, 15.4.4.21
// Referencia: http://es5.github.io/#x15.4.4.21
if (!Array.prototype.reduce) {
  Array.prototype.reduce = function (callback /\*, valorInicial\*/) {
    "use strict";
    if (this == null) {
      throw new TypeError(
        "Array.prototype.reduce chamado é nulo (null) ou indefinido (undefined)",
      );
    }
    if (typeof callback !== "function") {
      throw new TypeError(callback + " não é uma função");
    }
    var t = Object(this),
      len = t.length >>> 0,
      k = 0,
      value;
    if (arguments.length == 2) {
      value = arguments[1];
    } else {
      while (k < len && !(k in t)) {
        k++;
      }
      if (k >= len) {
        throw new TypeError(
          "Reduce possui um array vazio sem um valor inicial",
        );
      }
      value = t[k++];
    }
    for (; k < len; k++) {
      if (k in t) {
        value = callback(value, t[k], k, t);
      }
    }
    return value;
  };
}
```

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

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

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

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

Leia também
-----------

* `Array.prototype.reduceRight()`


Array.prototype.unshift() - JavaScript

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

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

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.concat() - JavaScript

Array.prototype.concat()
========================

 O método **`concat()`** é utilizado para mesclar dois ou mais arrays.
 Esse método não altera os arrays existentes, mas, em vez disso, retorna um novo array.

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

Sintaxe
-------

```js
concat()
concat(valor0)
concat(valor0, valor1)
concat(valor1, valor2, /\*...,\*/ valorN)
```

### Parâmetros

`valorN` Optional

 Arrays e/ou valores para concatenar em um novo array. Se todos
 os parâmetros `valorN` forem omitidos, `concat` retorna uma
 shallow copy (en-US) de todos os arrays existentes do qual é chamado. Veja a descrição abaixo
 para mais detalhes.

### Valor de retorno

Uma nova instância `Array`.

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

O método `concat` cria um novo array. O array irá primeiro ser preenchido pelos elementos no objeto no qual é chamado. Então, para cada argumento, seu valor será concatenado no array — para objetos normais ou primitivos, o próprio argumento se tornará um elemento do array final; para arrays ou objetos tipo array com a propriedade `Symbol.isConcatSpreadable` definida como um valor verdadeiro, cada elemento do argumento será adicionado independentemente ao array final. O método `concat` não recursa em argumentos de array aninhados.

O método `concat()` é um copying method. Ele não altera `this` ou quaquer um dos arrays fornecidos como argumentos, mas, em vez disso retorna uma shallow copy (en-US) que contém os mesmos elementos dos arrays originais.

O método `concat()` preserva slots vazios se qualquer um dos arrays de origem for sparse.

O método `concat()` é genérico. O valor `this` é tratado da mesma forma como os outros argumentos (exceto que será convertido em um objeto primeiro), o que significa que objetos simples serão anexados diretamente ao array resultante, enquanto objetos do tipo array com verdadeiro `@@isConcatSpreadable` serão propagados no array resultante.

Exemplos
--------

### Concatenando dois arrays

O código a seguir concatena dois arrays:

```js
const letras = ["a", "b", "c"];
const numeros = [1, 2, 3];

const alfaNumerico = letras.concat(numeros);
console.log(alfaNumerico);
// resulta em ['a', 'b', 'c', 1, 2, 3]
```

### Concatenando três arrays

O código a seguir concatena três arrays:

```js
const num1 = [1, 2, 3];
const num2 = [4, 5, 6];
const num3 = [7, 8, 9];

const numeros = num1.concat(num2, num3);

console.log(numeros);
// resulta em [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

### Concatenando valores em um array

O código a seguir concatena três valores em um array:

```js
const letras = ["a", "b", "c"];

const alfaNumerico = letras.concat(1, [2, 3]);

console.log(alfaNumerico);
// resulta em ['a', 'b', 'c' , 1, 2, 3]
```

### Concatenando arrays aninhados

O código a seguir concatena arrays aninhados e demonstra a retenção de referência:

```js
const num1 = [[1]];
const num2 = [2, [3]];

const numeros = num1.concat(num2);

console.log(numeros);
// resulta em [[1], 2, [3]]

//modifica o primeiro elemento do num1
num1[0].push(4);

console.log(numeros);
// resulta em [[1, 4], 2, [3]]
```

### Concatenanto objetos tipo array com Symbol.isConcatSpreadable

`concat` não trata todos os objetos tipo array como arrays por padrão — somente se `Symbol.isConcatSpreadable` estiver definido como um valor verdadeiro (P.ex. `true`)

```js
const obj1 = { 0: 1, 1: 2, 2: 3, length: 3 };
const obj2 = { 0: 1, 1: 2, 2: 3, length: 3, [Symbol.isConcatSpreadable]: true };
console.log([0].concat(obj1, obj2));
// resulta em [ 0, { '0': 1, '1': 2, '2': 3, length: 3 }, 1, 2, 3 ]
```

### Usando concat() em arrays sparse

Se qualquer uma das arrays é sparse, a array resultante será também sparse:

```js
console.log([1, , 3].concat([4, 5])); // [1, empty, 3, 4, 5]
console.log([1, 2].concat([3, , 5])); // [1, 2, 3, empty, 5]
```

### Chamando concat() em objetos não array

Se o valor `this` não for um array, ele será convertido em um objeto e então tratado da mesma forma que os argumentos para `concat()`. Nesse caso o valor de retorno é sempre um novo array simples.

```js
console.log(Array.prototype.concat.call({}, 1, 2, 3)); // [{}, 1, 2, 3]
console.log(Array.prototype.concat.call(1, 2, 3)); // [ [Number: 1], 2, 3 ]
const arrayLike = { [Symbol.isConcatSpreadable]: true, length: 2, 0: 1, 1: 2 };
console.log(Array.prototype.concat.call(arrayLike, 3, 4)); // [1, 2, 3, 4]
```

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

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

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

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

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

* Polyfill of `Array.prototype.concat` in `core-js` with fixes and implementation of modern behavior like `Symbol.isConcatSpreadable` support
* Indexed collections
* `Array`
* `Array.prototype.push()`
* `Array.prototype.unshift()`
* `Array.prototype.splice()`
* `String.prototype.concat()`
* `Symbol.isConcatSpreadable`