15 métodos JavaScript para trabalhar com matrizes que você precisa conhecer em 2020

Aqui está a tradução de um artigo publicado em dev.to. Postado por: Ibrahima Ndaw .
O original é publicado no blog do autor.

Uma matriz em JavaScript é uma estrutura de dados especial usada para armazenar vários elementos. Usando as propriedades e métodos internos, você pode adicionar, excluir, enumerar ou processar dados de acordo com suas necessidades. Saber como trabalhar com matrizes em JavaScript levará suas habilidades de desenvolvimento profissional para o próximo nível.

Neste artigo, abordaremos 15 métodos que ajudarão você a trabalhar com mais eficiência com matrizes em JavaScript.



Observe que basicamente simplificaremos a função que é passada como parâmetro.

// Instead of using this way myAwesomeArray.some(test => { if (test === "d") { return test } }) // We'll use the shorter one myAwesomeArray.some(test => test === "d") 

1. alguns ()


Este método verifica se algum elemento da matriz satisfaz a condição especificada na função passada. Ele retornará true se pelo menos um elemento corresponder à função que está sendo testada e false se não.

 const myAwesomeArray = ["a", "b", "c", "d", "e"] myAwesomeArray.some(test => test === "d") //-------> Output : true 

2. reduzir ()


Este método usa uma função que usa um acumulador e um valor como argumento. Aplica a função ao acumulador e a cada valor da matriz, para retornar apenas um valor como resultado.

 const myAwesomeArray = [1, 2, 3, 4, 5] myAwesomeArray.reduce((total, value) => total * value) // 1 * 2 * 3 * 4 * 5 //-------> Output = 120 

3. todo ()


Este método verifica se todos os elementos da matriz atendem à condição especificada na função que está sendo transmitida. Ele retornará true se cada elemento corresponder à função que está sendo testada e false se não.

 const myAwesomeArray = ["a", "b", "c", "d", "e"] myAwesomeArray.every(test => test === "d") //-------> Output : false const myAwesomeArray2 = ["a", "a", "a", "a", "a"] myAwesomeArray2.every(test => test === "a") //-------> Output : true 

4. mapa ()


Este método utiliza uma função como parâmetro e cria uma nova matriz com o resultado da chamada da função especificada para cada elemento da matriz. Ele sempre retornará o mesmo número de itens.

 const myAwesomeArray = [5, 4, 3, 2, 1] myAwesomeArray.map(x => x * x) //-------> Output : 25 // 16 // 9 // 4 // 1 

5.flat ()


Esse método usa uma matriz de matrizes como argumento e suaviza as matrizes aninhadas em uma matriz de nível superior. Observe que esse método funciona apenas para um nível.

 const myAwesomeArray = [[1, 2], [3, 4], 5] myAwesomeArray.flat() //-------> Output : [1, 2, 3, 4, 5] 

6. filtro ()


Esse método usa uma função como parâmetro e retorna uma nova matriz contendo todos os elementos da matriz para os quais a função de filtro foi passada como argumento e a retorna com true .

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, { id: 4, name: "Mass" }, ] myAwesomeArray.filter(element => element.name === "Mass") //-------> Output : 0:{id: 3, name: "Mass"}, // 1:{id: 4, name: "Mass"} 

7. forEach ()


Este método aplica uma função a cada elemento da matriz.

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.forEach(element => console.log(element.name)) //-------> Output : john // Ali // Mass 

8. findIndex ()


Este método usa uma função como parâmetro e depois a aplica à matriz. Retorna o índice do elemento encontrado se o elemento atender à condição da função de verificação passada como argumento. Se não estiver satisfeito, –1 retornado.

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.findIndex(element => element.id === 3) //-------> Output : 2 myAwesomeArray.findIndex(element => element.id === 7) //-------> Output : -1 

9. find ()


Este método usa uma função como argumento e depois a aplica à matriz. Retorna o valor do elemento encontrado na matriz se o elemento satisfizer a condição da função de verificação. Caso contrário, ele retornará com o valor undefined .

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.find(element => element.id === 3) //-------> Output : {id: 3, name: "Mass"} myAwesomeArray.find(element => element.id === 7) //-------> Output : undefined 

10. sort ()


Este método assume uma função como parâmetro. Classifica os elementos da matriz e os retorna.

 const myAwesomeArray = [5, 4, 3, 2, 1] // Sort from smallest to largest myAwesomeArray.sort((a, b) => a - b) //-------> Output : [1, 2, 3, 4, 5] // Sort from largest to smallest myAwesomeArray.sort((a, b) => b - a) //-------> Output : [5, 4, 3, 2, 1] 

11. concat ()


Este método combina duas ou mais matrizes / valores e retorna uma nova matriz.

 const myAwesomeArray = [1, 2, 3, 4, 5] const myAwesomeArray2 = [10, 20, 30, 40, 50] myAwesomeArray.concat(myAwesomeArray2) //-------> Output : [1, 2, 3, 4, 5, 10, 20, 30, 40, 50] 

12. fill ()


Esse método preenche todos os elementos da matriz com o mesmo valor, do índice inicial (padrão 0) ao índice final (array.length padrão).

 const myAwesomeArray = [1, 2, 3, 4, 5] // The first argument (0) is the value // The second argument (1) is the starting index // The third argument (3) is the ending index myAwesomeArray.fill(0, 1, 3) //-------> Output : [1, 0, 0, 4, 5] 

13. inclui ()


Este método retorna true se a matriz contém um elemento específico e false se não.

 const myAwesomeArray = [1, 2, 3, 4, 5] myAwesomeArray.includes(3) //-------> Output : true myAwesomeArray.includes(8) //-------> Output : false 

14. reverse ()


Este método reverte a ordem dos elementos na matriz. O primeiro elemento se torna o último e o último se torna o primeiro.

 const myAwesomeArray = ["e", "d", "c", "b", "a"] myAwesomeArray.reverse() //-------> Output : ['a', 'b', 'c', 'd', 'e'] 

15. flatMap ()


Este método aplica uma função a cada elemento da matriz e suaviza o resultado em uma nova matriz. Ele combina o método flat() e o método map() em uma função.

 const myAwesomeArray = [[1], [2], [3], [4], [5]] myAwesomeArray.flatMap(arr => arr * 10) //-------> Output : [10, 20, 30, 40, 50] // With .flat() and .map() myAwesomeArray.flat().map(arr => arr * 10) //-------> Output : [10, 20, 30, 40, 50] 

Source: https://habr.com/ru/post/pt483958/


All Articles