Remover duplicatas de um array

Remover duplicatas de arrays é uma tarefa comum em JavaScript. Abaixo vão alguns métodos bem eficazes para fazer isso.

Método 1: usando Set (recomendado)

A forma mais simples e geralmente mais rápida de remover duplicatas é usando Set:

const array = [1, 2, 2, 3, 4, 4, 5]
const uniqueArray = [...new Set(array)]
console.log(uniqueArray) // [1, 2, 3, 4, 5]

Prós:

• Limpo e direto
• Boa performance O(n)
• Funciona bem com valores primitivos

Contras:

• Só funciona com valores primitivos (números, strings, booleanos)
• Objetos são comparados por referência

Método 2: usando Filter

Útil em cenários mais específicos, ou quando você quer manter a primeira ocorrência:

const array = [1, 2, 2, 3, 4, 4, 5]
const uniqueArray = array.filter((value, index, self) => {
  return self.indexOf(value) === index
})
console.log(uniqueArray) // [1, 2, 3, 4, 5]

Prós:

• Mais flexível para lógica customizada
• Fácil de entender

Contras:

• Menos performático O(n²) por causa do indexOf

Método 3: usando Reduce

Uma abordagem funcional usando reduce:

const array = [1, 2, 2, 3, 4, 4, 5]
const uniqueArray = array.reduce((acc, current) => {
  if (!acc.includes(current)) {
    acc.push(current)
  }
  return acc
}, [])
console.log(uniqueArray) // [1, 2, 3, 4, 5]

Prós:

• Estilo de programação funcional
• Pode ser combinado com outras transformações

Contras:

• Menos performático por causa do includes
• Mais verboso

Método 4: para objetos (usando Map)

Quando você está lidando com objetos, geralmente precisa comparar por uma propriedade específica:

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Alice' },
  { id: 3, name: 'Charlie' }
]

const uniqueUsers = Array.from(new Map(users.map((user) => [user.id, user])).values())

console.log(uniqueUsers)
// [
//   { id: 1, name: 'Alice' },
//   { id: 2, name: 'Bob' },
//   { id: 3, name: 'Charlie' }
// ]

Prós:

• Funciona com objetos
• Você escolhe qual propriedade define a unicidade
• Boa performance

Contras:

• Sintaxe um pouco mais complexa
• Mantém a última ocorrência (dá pra ajustar para manter a primeira)

Comparação de performance

Em arrays grandes (10.000+ itens):

1. Set: ~1ms (mais rápido)
2. Map (para objetos): ~2ms
3. Reduce: ~50ms
4. Filter: ~100ms (mais lento)

Recomendação

• Use Set para valores primitivos (números, strings, booleanos)
• Use Map para objetos quando precisar remover duplicatas por uma propriedade específica
• Use Filter ou Reduce só quando você precisar de lógica customizada ou estiver lidando com arrays pequenos

Nota: todos esses métodos criam um array novo. Se você precisa modificar o array original no lugar, vai precisar de uma abordagem diferente.