Javascript - Lidando com objetos e arrays

Vamos relembrar as principais funções para lider com #objetos e arrays em javascript.

1. Objetos {}

Manipulação Básica

• Object.keys({ a: 1, b: 2 }); // ['a', 'b']

• Object.values(obj)
  Retorna um array com os valores do objeto.

  Object.values({ a: 1, b: 2 }); // [1, 2]

• Object.entries(obj)
  Retorna um #array de pares [chave, valor].

  Object.entries({ a: 1, b: 2 }); // [['a', 1], ['b', 2]]

• Object.assign(target, ...sources)
  Copia propriedades de objetos para um objeto alvo.

  Object.assign({}, { a: 1 }, { b: 2 }); // { a: 1, b: 2 }

• obj.hasOwnProperty(prop)
  Verifica se o #objeto tem uma propriedade própria (não herdada).

  { a: 1 }.hasOwnProperty('a'); // true

Imutabilidade e Controle

• Object.freeze(obj)
  Impede alterações no objeto (adição/remoção/alteração de propriedades).

  const frozen = Object.freeze({ a: 1 });

  frozen.a = 2; // Ignorado (em modo strict, gera erro)

• Object.seal(obj)
  Permite alterar propriedades existentes, mas impede adicionar/remover.

  const sealed = Object.seal({ a: 1 });

  sealed.a = 2; // Permitido

  sealed.b = 3; // Ignorado

2. Arrays de Objetos [{}, {}]

Iteração e Transformação

• Array.prototype.map()
  Cria um novo array com resultados de uma função aplicada a cada elemento.

  const users = [{ id: 1, name: 'Ana' }, { id: 2, name: 'Bob' }];

  const names = users.map(user => user.name); // ['Ana', 'Bob']

• Array.prototype.filter()
  Cria um novo array com elementos que passam em um teste.

  const adults = users.filter(user => user.age >= 18);

• Array.prototype.find()
  Retorna o primeiro elemento que satisfaz uma condição.

  const user = users.find(u => u.id === 1);

• Array.prototype.findIndex()
  Retorna o índice do primeiro elemento que satisfaz uma condição.

  const index = users.findIndex(u => u.id === 1);

• Array.prototype.reduce()
  Reduz o array a um único valor (ex: soma, agrupamento).

  const totalAge = users.reduce((sum, user) => sum + user.age, 0);

Verificação e Ordenação

• Array.prototype.every()
  Verifica se todos os elementos passam em um teste.

  const allAdults = users.every(u => u.age >= 18); // true/false

• Array.prototype.some()
  Verifica se algum elemento passa em um teste.

  const hasAdult = users.some(u => u.age >= 18);

• Array.prototype.sort()
  Ordena o array (modifica o original).

  users.sort((a, b) => a.name.localeCompare(b.name)); // Ordem alfabética

3. Arrays Simples []

Manipulação de Elementos

• Array.prototype.push()
  Adiciona elementos ao final do array.

  const arr = [1, 2];

  arr.push(3); // [1, 2, 3]

• Array.prototype.pop()
  Remove o último elemento.

  arr.pop(); // [1, 2]

• Array.prototype.unshift()
  Adiciona elementos ao início do array.

  arr.unshift(0); // [0, 1, 2]

• Array.prototype.shift()
  Remove o primeiro elemento.

  arr.shift(); // [1, 2]

Busca e Verificação

• Array.prototype.includes()
  Verifica se o array contém um valor.

  [1, 2, 3].includes(2); // true

• Array.prototype.indexOf()
  Retorna o índice da primeira ocorrência de um valor.

  [1, 2, 3].indexOf(2); // 1

• Array.prototype.find()
  Retorna o primeiro elemento que satisfaz uma condição (igual a arrays de objetos).

  [1, 2, 3].find(num => num > 1); // 2

Transformação e Combinação

• Array.prototype.concat()
  Combina arrays (não modifica o original).

  [1, 2].concat([3, 4]); // [1, 2, 3, 4]

• Array.prototype.slice()
  Extrai uma parte do array (não modifica o original).

  [1, 2, 3, 4].slice(1, 3); // [2, 3]

• Array.prototype.splice()
  Adiciona/remove elementos (modifica o original).

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

  arr.splice(1, 2); // Remove 2 elementos a partir do índice 1: [1, 4]

• Array.prototype.join()
  Junta elementos em uma string.

  ['a', 'b', 'c'].join('-'); // 'a-b-c'

Iteração

• Array.prototype.forEach()
  Executa uma função para cada elemento.

  [1, 2, 3].forEach(num => console.log(num));

Resumo Rápido

Dicas Importantes:

1. Imutabilidade: Prefira métodos que não modificam o array original (ex: map(), filter(), slice()).
2. Performance: Use for...of ou forEach() para iterações simples; reduce() para operações complexas.
3. Ordenação: sort() modifica o array original. Use uma cópia com [...arr].sort() para preservar o original.
4. Arrays de Objetos: Combine métodos (ex: filter().map()) para transformações em cadeia.