# Como remover duplicados de matriz em ES6

Aqui estão 3 maneiras de filtrar duplicados de uma matriz e retornar apenas os valores únicos. Meu favorito é usar Set porque é o mais curto e mais simples 😁

const array = ;// 1: "Set";// 2: "Filter"array.filter((item, index) => array.indexOf(item) === index);// 3: "Reduce"array.reduce( (unique, item) => (unique.includes(item) ? unique : ), ,);// RESULT:// ;

# 1. Usando o conjunto

deixe-me começar por explicar qual é o conjunto:

Set é um novo objeto de dados introduzido no ES6. Porque Set só lhe permite armazenar valores únicos. Quando você passa em um array, ele irá remover quaisquer valores duplicados.Muito bem, vamos voltar ao nosso código e decifrar o que está a acontecer. Há duas coisas a acontecer.:

1. primeiro, estamos criando um novo Set passando um array. Como Set só permite valores únicos, todos os duplicados serão removidos.
2. agora que os duplicados desapareceram, nós vamos convertê – lo de volta para um array usando o operador de spread...

const array = ;// Step 1const uniqueSet = new Set(array);// Set { '🐑', 1, 2, 3 }// Step 2const backToArray = ;// 

# converter o conjunto para uma matriz usando Array.a partir de

Alternativamente, você também pode usar Array.from para converter um Set em uma matriz:

const array = ;Array.from(new Set(array));// 

# 2: Usando o filtro

para entender esta opção, vamos ver o que estes dois métodos estão fazendo: indexOf e filter

# indexOf

O indexOf método retorna o primeiro índice de encontrar a elemento da matriz.

const array = ;array.indexOf('🐑'); // 0array.indexOf(1); // 1array.indexOf(2); // 2array.indexOf(3); // 5

# filtro

o método filter() cria um novo conjunto de elementos que passam pelo condicional que nós fornecemos. Em outras palavras, se o elemento passa e retorna true, ele será incluído no array filtrado. E qualquer elemento que falhar ou retornar false, não estará na matriz filtrada.

vamos entrar e caminhar através do que acontece enquanto fazemos um loop através da matriz.

const array = ;array.filter((item, index) => { console.log( // a. Item item, // b. Index index, // c. indexOf array.indexOf(item), // d. Condition array.indexOf(item) === index, ); return array.indexOf(item) === index;});

abaixo está a saída da consola.o registo foi mostrado acima. Os duplicados são onde o índice não corresponde ao indexOf. Então, nesses casos, a condição será falsa e não será incluída em nossa matriz filtrada.

# Recuperar os valores duplicados

também podemos usar o método do filtro para recuperar os valores duplicados do array. Podemos fazer isso simplesmente ajustando nossa condição assim:

const array = ;array.filter((item, index) => array.indexOf(item) !== index);// 

mais uma vez, deixe passar por isso e ver a saída:

# 3: Usando reduce

o método reduce é usado para reduzir os elementos do array e combiná-los em um array final baseado em alguma função redutora que você passa.

neste caso, a nossa função redutora está a verificar se a nossa matriz final contém o item. Se não funcionar, introduza esse item na nossa matriz final. Caso contrário, pular esse elemento e retornar apenas a nossa matriz final como é (essencialmente saltando sobre esse elemento).

Reduzir é sempre um pouco mais complicado de entender, então vamos também entrar em cada caso e ver a saída:

const array = ;array.reduce((unique, item) => { console.log( // a. Item item, // b. Final Array (Accumulator) unique, // c. Condition (Remember it only get pushed if this returns `false`) unique.includes(item), // d. Reducer Function Result unique.includes(item) ? unique : , ); return unique.includes(item) ? unique : ;}, ); // 👈 The initial value of our Accumulator is an empty array// RESULT:// ;

e aqui está a saída da consola.registo:

# Contribuição comunitária

• @smokkku: array.includes(item) é uma forma mais idiomática de testar se o array contém o item

• @riquelkovsky: ainda hoje fiz isso fazendo o seguinte.Object.keys(array.reduce((map, next) => ({...map, : true}), {}))

-@luisiacc2 : com Certeza, Set() irá fazer o truque para primitve valores, com objetos não O(n^2) solução seria executar primeiro um sort() na matriz(que opera em O(nlogn)) e, em seguida, procure o adjascentes itens iguais(o que é O(n)) , então você tem O(n + nlogn).

• @iamdipankarj: também, Array.from(new Set()), mas isso só funciona em primitivos. Para filtrar os duplicados na lista de objectos personalizados.filter() é o caminho a seguir.

• @benawad: filter o tempo de execução é O(n^2)