Arrays são uma das estruturas de dados mais fundamentais em JavaScript. Com um array, você pode armazenar vários valores em uma única variável. JavaScript fornece vários métodos integrados para manipular arrays, tornando-os incrivelmente versáteis. Nesta postagem, exploraremos todos os métodos de array integrados e como usá-los de maneira eficaz em seus projetos JavaScript.

Métodos principais

para cada()

O método forEach() permite iterar em um array e executar uma função fornecida uma vez para cada elemento do array. É uma maneira simples de percorrer um array.

const array = [1, 2, 3, 4, 5];

array.forEach((element) => {
  console.log(element);
});

mapa()

O método map() cria um novo array preenchido com os resultados da chamada de uma função fornecida em cada elemento do array. Normalmente é usado para transformar dados.

const array = [1, 2, 3, 4, 5];

const doubled = array.map((element) => element * 2);

console.log(doubled); // [2, 4, 6, 8, 10]

filtro()

O método filter() cria um novo array com todos os elementos que passam no teste implementado pela função fornecida. É útil quando você precisa filtrar certos elementos de uma matriz com base em uma condição.

const array = [1, 2, 3, 4, 5];

const evenNumbers = array.filter((element) => element % 2 === 0);

console.log(evenNumbers); // [2, 4]

reduzir()

O método reduz() executa uma função redutora em cada elemento do array, resultando em um único valor de saída. É frequentemente usado para somar valores, acumular totais ou mesclar matrizes em um único valor.

const array = [1, 2, 3, 4, 5];

const sum = array.reduce((accumulator, currentValue) => accumulator   currentValue, 0);

console.log(sum); // 15

encontrar()

O método find() retorna o valor do primeiro elemento na matriz que satisfaz a função de teste fornecida. Ele para depois de encontrar a primeira correspondência.

const array = [1, 2, 3, 4, 5];

const found = array.find((element) => element > 3);

console.log(found); // 4

encontrarIndex()

O método findIndex() retorna o índice do primeiro elemento na matriz que satisfaz a função de teste fornecida. Se nenhum elemento satisfizer a função de teste, ele retornará -1.

const array = [1, 2, 3, 4, 5];

const index = array.findIndex((element) => element > 3);

console.log(index); // 3

organizar()

O método sort() classifica os elementos de um array no lugar e retorna o array classificado. É comumente usado para classificar strings e números, mas pode exigir uma função de comparação para classificar os números corretamente.

const array = [5, 3, 8, 1, 2];

const sortedArray = array.sort((a, b) => a - b);

console.log(sortedArray); // [1, 2, 3, 5, 8]

reverter()

O método reverse() inverte os elementos de um array no lugar. O primeiro elemento da matriz se torna o último e o último se torna o primeiro.

const array = [1, 2, 3, 4, 5];

const reversedArray = array.reverse();

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

concat()

O método concat() é usado para mesclar dois ou mais arrays. Ele retorna um novo array, deixando os arrays originais inalterados.

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];

const concatenatedArray = array1.concat(array2);

console.log(concatenatedArray); // [1, 2, 3, 4, 5, 6]

fatiar()

O método slice() retorna uma cópia superficial de uma parte de um array em um novo objeto de array selecionado do início ao fim (fim não incluído).

const array = [1, 2, 3, 4, 5];

const slicedArray = array.slice(1, 4);

console.log(slicedArray); // [2, 3, 4]

emenda()

O método splice() altera o conteúdo de um array removendo, substituindo ou adicionando elementos.

const array = [1, 2, 3, 4, 5];

array.splice(2, 1, 6, 7);

console.log(array); // [1, 2, 6, 7, 4, 5]

empurrar()

O método push() adiciona um ou mais elementos ao final de um array e retorna o novo comprimento do array.

const array = [1, 2, 3];

array.push(4, 5);

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

pop()

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

const array = [1, 2, 3, 4, 5];

const lastElement = array.pop();

console.log(lastElement); // 5
console.log(array); // [1, 2, 3, 4]

mudança()

O método shift() remove o primeiro elemento de um array e retorna esse elemento.

const array = [1, 2, 3, 4, 5];

const firstElement = array.shift();

console.log(firstElement); // 1
console.log(array); // [2, 3, 4, 5]

não mudar()

O método unshift() adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.

const array = [2, 3, 4, 5];

array.unshift(1);

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

juntar()

O método join() cria e retorna uma nova string concatenando todos os elementos em uma matriz, separados por vírgulas ou uma string separadora especificada.

const array = [1, 2, 3, 4, 5];

const joinedString = array.join('-');

console.log(joinedString); // "1-2-3-4-5"

Métodos Adicionais

todo()

O método every() testa se todos os elementos do array passam na função de teste fornecida.

const array = [2, 4, 6, 8];

const allEven = array.every((element) => element % 2 === 0);

console.log(allEven); // true

alguns()

O método some() testa se pelo menos um elemento na matriz passa na função de teste fornecida.

const array = [1, 2, 3, 4, 5];

const hasEven = array.some((element) => element % 2 === 0);

console.log(hasEven); // true

plano()

O método flat() cria um novo array com todos os elementos do subarray concatenados nele recursivamente até a profundidade especificada.

const array = [1, [2, [3, [4]]]];

const flattenedArray = array.flat(2);

console.log(flattenedArray); // [1, 2, 3, [4]]

mapa plano()

O método flatMap() primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em um novo array. É uma combinação de map() e flat().

const array = [1, 2, 3, 4];

const flattened = array.flatMap((num) => [num, num * 2]);

console.log(flattened); // [1, 2, 2, 4, 3, 6, 4, 8]

preencher()

O método fill() preenche todos os elementos de um array com um valor estático de um índice inicial até um índice final.

const array = [1, 2, 3, 4, 5];

array.fill(0, 2, 4);

console.log(array); // [1, 2, 0, 0, 5]

copiarDentro()

O método copyWithin() copia superficialmente parte de um array para outro local no mesmo array sem modificar seu comprimento.

const array = [1, 2, 3, 4, 5];

array.copyWithin(0, 3, 5);

console.log(array); // [4, 5, 3, 4, 5]

inclui()

O método inclui() verifica se um array contém um determinado valor.

const array = [1, 2, 3, 4, 5];

const hasThree =

 array.includes(3);

console.log(hasThree); // true

toString()

O método toString() converte um array em uma string, separada por vírgulas.

const array = [1, 2, 3, 4, 5];

const arrayString = array.toString();

console.log(arrayString); // "1,2,3,4,5"

indexOf()

O método indexOf() retorna o primeiro índice no qual um determinado elemento pode ser encontrado no array, ou -1 se não estiver presente.

const array = [1, 2, 3, 4, 5];

const index = array.indexOf(3);

console.log(index); // 2

lastIndexOf()

O método lastIndexOf() retorna o último índice no qual um determinado elemento pode ser encontrado no array, ou -1 se não estiver presente.

const array = [1, 2, 3, 4, 3, 5];

const lastIndex = array.lastIndexOf(3);

console.log(lastIndex); // 4

de()

O método Array.from() cria uma nova instância de array a partir de um objeto semelhante a um array ou iterável.

const array = Array.from('hello');

console.log(array); // ['h', 'e', 'l', 'l', 'o']

isArray()

O método Array.isArray() verifica se o valor passado é um array.

const array = [1, 2, 3, 4, 5];
const notArray = { a: 1, b: 2 };

console.log(Array.isArray(array)); // true
console.log(Array.isArray(notArray)); // false

de()

O método Array.of() cria uma nova instância de array com um número variável de elementos.

const array1 = Array.of(1, 2, 3);
const array2 = Array.of('a', 'b', 'c');

console.log(array1); // [1, 2, 3]
console.log(array2); // ['a', 'b', 'c']

Conclusão

Matrizes JavaScript vêm com uma ampla variedade de métodos integrados que permitem uma poderosa manipulação de dados. Compreender esses métodos tornará você mais eficiente na escrita de código limpo e conciso. Reserve algum tempo para experimentar esses métodos e ver como eles podem melhorar seu código.
Publicado originalmente: Guia de métodos de array JavaScript