Arrays são uma das estruturas de dados mais comumente usadas em JavaScript. Eles permitem armazenar vários valores em uma única variável e vêm com um rico conjunto de funções integradas que tornam a manipulação e o trabalho com dados simples e eficientes. Neste artigo, exploraremos detalhadamente as funções de array JavaScript, fornecendo explicações, exemplos e comentários para ajudá-lo a dominá-las.

Introdução aos arrays em JavaScript

Um array é uma coleção ordenada de itens que pode conter diferentes tipos de dados, incluindo números, strings, objetos e até mesmo outros arrays.

let fruits = ["Apple", "Banana", "Cherry"];
let numbers = [1, 2, 3, 4, 5];
let mixed = [1, "Apple", true, {name: "John"}, [1, 2, 3]];

Criando matrizes

Arrays podem ser criados usando literais de array ou o construtor Array.

let arr1 = [1, 2, 3];
let arr2 = new Array(1, 2, 3);
console.log(arr1); // Output: [1, 2, 3]
console.log(arr2); // Output: [1, 2, 3]

Propriedades da matriz

• comprimento: Retorna o número de elementos em uma matriz.

let arr = [1, 2, 3, 4, 5];
console.log(arr.length); // Output: 5

Métodos de matriz

1. empurrar()

Adiciona um ou mais elementos ao final de uma matriz e retorna o novo comprimento.

let arr = [1, 2, 3];
arr.push(4);
console.log(arr); // Output: [1, 2, 3, 4]

2. pop()

Remove o último elemento de uma matriz e retorna esse elemento.

let arr = [1, 2, 3];
let last = arr.pop();
console.log(arr); // Output: [1, 2, 3]
console.log(last); // Output: 3

3. mudança()

Remove o primeiro elemento de uma matriz e retorna esse elemento.

let arr = [1, 2, 3];
let first = arr.shift();
console.log(arr); // Output: [2, 3]
console.log(first); // Output: 1

4. não mudar()

Adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento.

let arr = [2, 3];
arr.unshift(1);
console.log(arr); // Output: [1, 2, 3]

5.concat()

Mescla dois ou mais arrays e retorna um novo array.

let arr1 = [1, 2];
let arr2 = [3, 4];
let merged = arr1.concat(arr2);
console.log(merged); // Output: [1, 2, 3, 4]

6. juntar()

Junta todos os elementos de um array em uma string.

let arr = [1, 2, 3];
let str = arr.join("-");
console.log(str); // Output: "1-2-3"

7. reverso()

Inverte a ordem dos elementos em uma matriz.

let arr = [1, 2, 3];
arr.reverse();
console.log(arr); // Output: [3, 2, 1]

8. fatia()

Retorna uma cópia superficial de uma parte de um array em um novo objeto de array.

let arr = [1, 2, 3, 4, 5];
let sliced = arr.slice(1, 3);
console.log(sliced); // Output: [2, 3]

9. emenda()

Altera o conteúdo de um array removendo, substituindo ou adicionando elementos.

let arr = [1, 2, 3, 4, 5];
arr.splice(1, 2, "a", "b");
console.log(arr); // Output: [1, "a", "b", 4, 5]

10. classificar()

Classifica os elementos de um array no lugar e retorna o array classificado.

let arr = [3, 1, 4, 1, 5, 9];
arr.sort((a, b) => a - b);
console.log(arr); // Output: [1, 1, 3, 4, 5, 9]

11. filtro()

Cria um novo array com todos os elementos que passam no teste implementado pela função fornecida.

let arr = [1, 2, 3, 4, 5];
let filtered = arr.filter(x => x > 2);
console.log(filtered); // Output: [3, 4, 5]

12. mapa()

Cria um novo array com os resultados da chamada de uma função fornecida em cada elemento do array de chamada.

let arr = [1, 2, 3];
let mapped = arr.map(x => x * 2);
console.log(mapped); // Output: [2, 4, 6]

13. reduzir()

Aplica uma função a um acumulador e a cada elemento do array para reduzi-lo a um único valor.

let arr = [1, 2, 3, 4];
let sum = arr.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // Output: 10

14. encontrar()

Retorna o valor do primeiro elemento na matriz que satisfaz a função de teste fornecida.

let arr = [1, 2, 3, 4, 5];
let found = arr.find(x => x > 3);
console.log(found); // Output: 4

15. encontrarIndex()

Retorna o índice do primeiro elemento na matriz que satisfaz a função de teste fornecida.

let arr = [1, 2, 3, 4, 5];
let index = arr.findIndex(x => x > 3);
console.log(index); // Output: 3

16. cada()

Testa se todos os elementos do array passam no teste implementado pela função fornecida.

let arr = [1, 2, 3, 4, 5];
let allBelowTen = arr.every(x => x 




  
  
  17. alguns()


Testa se pelo menos um elemento na matriz passa no teste implementado pela função fornecida.


let arr = [1, 2, 3, 4, 5];
let anyAboveThree = arr.some(x => x > 3);
console.log(anyAboveThree); // Output: true





  
  
  18. inclui()


Determina se um array inclui um determinado valor entre suas entradas.


let arr = [1, 2, 3, 4, 5];
let hasThree = arr.includes(3);
console.log(hasThree); // Output: true





  
  
  19. índiceDe()


Retorna o primeiro índice no qual um determinado elemento pode ser encontrado no array ou -1 se não estiver presente.


let arr = [1, 2, 3, 4, 5];
let index = arr.indexOf(3);
console.log(index); // Output: 2





  
  
  20. lastIndexOf()


Retorna o último índice no qual um determinado elemento pode ser encontrado no array ou -1 se não estiver presente.


let arr = [1, 2, 3, 4, 5, 3];
let index = arr.lastIndexOf(3);
console.log(index); // Output: 5





  
  
  21. plano()


Cria uma nova matriz com todos os elementos da submatriz concatenados recursivamente até a profundidade especificada.


let arr = [1, [2, [3, [4]]]];
let flattened = arr.flat(2);
console.log(flattened); // Output: [1, 2, 3, [4]]





  
  
  22. flatMap()


Primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em uma nova matriz.


let arr = [1, 2, 3];
let flatMapped = arr.flatMap(x => [x, x * 2]);
console.log(flatMapped); // Output: [1, 2, 2, 4, 3, 6]





  
  
  23. de()


Cria uma nova instância de matriz copiada superficialmente a partir de um objeto semelhante a uma matriz ou iterável.


let str = "Hello";
let arr = Array.from(str);
console.log(arr); // Output: ["H", "e", "l", "l", "o"]





  
  
  24.isArray()


Determina se o valor passado é um Array.


console.log(Array.isArray([1, 2, 3])); // Output: true
console.log(Array.isArray("Hello")); // Output: false





  
  
  25. de()


Cria um

nova instância de Array com um número variável de argumentos, independentemente do número ou tipo dos argumentos.


let arr = Array.of(1, 2, 3);
console.log(arr); // Output: [1, 2, 3]





  
  
  Exemplos práticos



  
  
  Exemplo 1: Removendo Duplicatas de um Array




let arr = [1, 2, 3, 3, 4, 4, 5];
let unique = [...new Set(arr)];
console.log(unique); // Output: [1, 2, 3, 4, 5]





  
  
  Exemplo 2: somando todos os valores em uma matriz




let arr = [1, 2, 3, 4, 5];
let sum = arr.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // Output: 15





  
  
  Exemplo 3: Achatando um array profundamente aninhado




let arr = [1, [2, [3, [4, [5]]]]];
let flattened = arr.flat(Infinity);
console.log(flattened); // Output: [1, 2, 3, 4, 5]





  
  
  Exemplo 4: Encontrando o valor máximo em uma matriz




let arr = [1, 2, 3, 4, 5];
let max = Math.max(...arr);
console.log(max); // Output: 5





  
  
  Exemplo 5: Criando uma matriz de pares de valores-chave




let obj = { a: 1, b: 2, c: 3 };
let entries = Object.entries(obj);
console.log(entries); // Output: [["a", 1], ["b", 2], ["c", 3]]





  
  
  Conclusão


Arrays são uma parte essencial do JavaScript, fornecendo uma maneira poderosa de gerenciar coleções de dados. Ao dominar as funções de array, você pode realizar manipulações complexas de dados com facilidade e escrever códigos mais eficientes e legíveis. Este guia abrangente cobriu as funções de array mais importantes em JavaScript, completo com exemplos e explicações detalhadas. Pratique o uso dessas funções e experimente diferentes casos de uso para aprofundar sua compreensão e aprimorar suas habilidades de codificação.