O que é um Array?

O método concat() é usado para concatenar (unir) dois ou mais arrays, retornando um *novo* array que contém todos os elementos dos arrays originais. O array original não é modificado.

Sintaxe: array1.concat(array2, array3, ..., arrayN)

Exemplo:

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const arr3 = arr1.concat(arr2); // arr3 será [1, 2, 3, 4, 5, 6]

Uso prático: Útil quando você precisa combinar dados de diferentes fontes em um único array, sem modificar os arrays originais.

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

Sintaxe: array.push(elemento1, elemento2, ...)

Exemplo:

let arr = [1, 2];
arr.push(3); // arr agora é [1, 2, 3]
console.log(arr.push(4,5)); //Imprime 5 (novo comprimento), arr agora é [1,2,3,4,5]

Uso prático: Ideal para adicionar novos itens a uma lista que cresce ao longo do tempo, como um histórico de ações do usuário ou uma fila de tarefas.

O método pop() remove o *último* elemento de um array e retorna esse elemento. Se o array estiver vazio, ele retorna `undefined`. O array original é modificado.

Sintaxe: array.pop()

Exemplo:

let arr = ["maçã", "banana", "laranja"];
let removedItem = arr.pop(); // removedItem será "laranja", arr será ["maçã", "banana"]
console.log(removedItem); // Imprime "laranja"
console.log(arr); // Imprime ["maçã", "banana"]

Uso prático: Útil para remover o último item adicionado a uma lista, como desfazer a última ação do usuário em um editor de texto ou remover o último item de uma fila FIFO (First-In, First-Out).

O método shift() remove o *primeiro* elemento de um array e retorna esse elemento. Se o array estiver vazio, ele retorna `undefined`. O array original é modificado.

Sintaxe: array.shift()

Exemplo:

let arr = ["maçã", "banana", "laranja"];
let removedItem = arr.shift(); // removedItem será "maçã", arr será ["banana", "laranja"]
console.log(removedItem); // Imprime "maçã"
console.log(arr); // Imprime ["banana", "laranja"]

Uso prático: Frequentemente usado para processar itens em uma fila FIFO (First-In, First-Out), como processar mensagens em um sistema de comunicação.

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

Sintaxe: array.unshift(elemento1, elemento2, ...)

Exemplo:

let arr = [1, 2, 3];
arr.unshift(0); // arr agora é [0, 1, 2, 3]
console.log(arr.unshift(-1, -2)); //Imprime 5 (novo comprimento), arr agora é [-2,-1,0,1,2,3]

Uso prático: Ideal para adicionar itens a uma lista no início, como adicionar novas entradas a um log de eventos em ordem cronológica inversa.

Adiciona ou remove elementos de um array em uma posição específica.
Exemplo: Para remover um elemento, use frutas.splice(1, 1); com frutas = ["maçã", "banana", "laranja"], que remove "banana", resultando em ["maçã", "laranja"]. Para adicionar, use frutas.splice(1, 0, "uva"); para inserir "uva" na posição 1.

O método slice() retorna uma *nova* parte de um array como um novo array, sem modificar o array original. Ele extrai uma fatia do array original, especificada por um índice inicial e um índice final (opcional).

Sintaxe: array.slice(inicio, fim)

inicio: Índice do primeiro elemento a incluir na fatia (inclusivo).

fim: Índice do elemento *após* o último elemento a incluir (exclusivo). Se omitido, a fatia vai até o final do array.

Exemplo:

const arr = ["a", "b", "c", "d", "e"];
const sliced = arr.slice(1, 4); // sliced será ["b", "c", "d"]
console.log(sliced); //Imprime ["b", "c", "d"]
console.log(arr); //Imprime ["a", "b", "c", "d", "e"]

Uso prático: Muito útil para criar cópias de partes de um array sem afetar o array original, como para manipular uma parte específica de dados sem alterar o conjunto de dados principal.

O método sort() ordena os elementos de um array *in loco* (modificando o array original). Por padrão, ele ordena os elementos como strings em ordem lexicográfica (alfabética).

Sintaxe: array.sort(compareFunction)

compareFunction (opcional): Uma função que define a ordem de classificação. Se omitida, a ordenação é feita como strings. A função de comparação recebe dois argumentos (a, b) e deve retornar:

• Um valor menor que 0 se `a` deve vir antes de `b`.
• 0 se `a` e `b` são iguais.
• Um valor maior que 0 se `a` deve vir depois de `b`.

Exemplo (sem compareFunction - ordenação como strings):

let arr = ["banana", "maçã", "laranja"];
arr.sort(); // arr agora é ["banana", "laranja", "maçã"] (ordenado lexicograficamente)

Exemplo (com compareFunction - ordenação numérica):

let numeros = [3, 1, 4, 1, 5, 9, 2, 6];
numeros.sort((a, b) => a - b); // numeros agora é [1, 1, 2, 3, 4, 5, 6, 9] (ordenado numericamente)

Uso prático: Essencial para organizar dados em ordem crescente ou decrescente, como ordenar uma lista de nomes, números, datas ou qualquer outro tipo de dado comparável.

O método reverse() inverte a ordem dos elementos de um array *in loco* (modificando o array original). Ele retorna o array invertido.

Sintaxe: array.reverse()

Exemplo:

let arr = [1, 2, 3, 4, 5];
arr.reverse(); // arr agora é [5, 4, 3, 2, 1]
console.log(arr); // Imprime [5, 4, 3, 2, 1]

Uso prático: Útil para apresentar dados em ordem inversa, como exibir um histórico de eventos do mais recente para o mais antigo, ou inverter a ordem de itens em uma lista.

O método forEach() executa uma função fornecida uma vez para cada elemento de um array. Ele não retorna nenhum valor, apenas executa a função para cada elemento. O array original não é modificado.

Sintaxe: array.forEach(function(currentValue, index, arr), thisValue)

currentValue: O valor atual do elemento sendo processado.

index: O índice do elemento atual.

arr: O array original.

thisValue (opcional): Um valor para usar como `this` dentro da função de callback.

Exemplo:

const arr = ["maçã", "banana", "laranja"];
arr.forEach(fruta => console.log(fruta)); // Imprime cada fruta no console

Uso prático: Ideal para iterar sobre um array e executar uma ação para cada elemento, como exibir os elementos em uma página web ou processar uma lista de dados.

O método map() cria um *novo* array com os resultados da chamada de uma função fornecida para cada elemento do array original. O array original não é modificado.

Sintaxe: array.map(function(currentValue, index, arr), thisValue)

currentValue: O valor atual do elemento sendo processado.

index: O índice do elemento atual.

arr: O array original.

thisValue (opcional): Um valor para usar como `this` dentro da função de callback.

Exemplo:

const numeros = [1, 2, 3];
const quadrados = numeros.map(num => num * num); // quadrados será [1, 4, 9]

Uso prático: Frequentemente usado para transformar os elementos de um array, como converter uma lista de nomes para letras maiúsculas, ou aplicar uma função matemática a cada número de um array.

O método filter() cria um *novo* array com todos os elementos que passam em um teste implementado por uma função fornecida. O array original não é modificado.

Sintaxe: array.filter(function(currentValue, index, arr), thisValue)

currentValue: O valor atual do elemento sendo processado.

index: O índice do elemento atual.

arr: O array original.

thisValue (opcional): Um valor para usar como `this` dentro da função de callback.

Exemplo:

const numeros = [1, 2, 3, 4, 5, 6];
const pares = numeros.filter(num => num % 2 === 0); // pares será [2, 4, 6]

Uso prático: Ideal para selecionar elementos específicos de um array com base em critérios, como filtrar uma lista de usuários com base na idade ou selecionar produtos com um determinado preço.

O método reduce() executa uma função reducer (uma função que você fornece) para cada elemento do array, resultando em um único valor de saída. O array original não é modificado.

Sintaxe: array.reduce(function(accumulator, currentValue, currentIndex, array), initialValue)

accumulator: O valor acumulado. No primeiro passo, é o `initialValue` (ou o primeiro elemento do array se `initialValue` não for fornecido).

currentValue: O valor atual do elemento sendo processado.

currentIndex: O índice do elemento atual.

array: O array original.

initialValue (opcional): Um valor a ser usado como o primeiro argumento para a função `reducer` na primeira iteração.

Exemplo:

const numeros = [1, 2, 3, 4, 5];
const soma = numeros.reduce((acc, num) => acc + num, 0); // soma será 15

Uso prático: Permite realizar cálculos cumulativos em um array, como somar todos os números, encontrar o maior ou menor valor, ou concatenar todas as strings em uma única string.