# hur man tar bort Array dubbletter i ES6

här är 3 sätt att filtrera bort dubbletter från en array och returnera endast de unika värdena. Min favorit använder Set eftersom det är det kortaste och enklaste 😁

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. Använda set

Låt mig börja först med att förklara vad Set är:

Set är ett nytt dataobjekt introducerat i ES6. Eftersom Set bara låter dig lagra unika värden. När du passerar i en array tar den bort alla dubbla värden.

Okej, låt oss gå tillbaka till vår kod och bryta ner vad som händer. Det finns 2 saker som händer:

1. först skapar vi en ny Set genom att skicka en array. Eftersom Set endast tillåter unika värden tas alla dubbletter bort.
2. nu är dubbletterna borta, vi kommer att konvertera det tillbaka till en array med hjälp av spridningsoperatören ...

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

# konvertera Set till en Array med Array.från

Alternativt kan du också använda Array.from för att konvertera en Set till en array:

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

# 2: Använda filter

för att förstå detta alternativ, låt oss gå igenom vad dessa två metoder gör: indexOf och filter

# indexOf

metoden indexOf returnerar det första indexet som det hittar av det medföljande elementet från vår array.

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

# filter

metoden filter() skapar en ny uppsättning element som passerar det villkorliga vi tillhandahåller. Med andra ord, om elementet passerar och returnerar true, kommer det att inkluderas i den filtrerade arrayen. Och alla element som misslyckas eller returnerar false, kommer det inte att vara i den filtrerade arrayen.

Låt oss gå in och gå igenom vad som händer när vi slingrar genom matrisen.

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;});

nedan är utgången från konsolen.log visade ovan. Dubbletterna är där indexet inte matchar indexOf. Så i dessa fall kommer villkoret att vara falskt och kommer inte att inkluderas i vår filtrerade array.

# Hämta dubblettvärdena

vi kan också använda filtermetoden för att hämta dubblettvärdena från matrisen. Vi kan göra detta genom att helt enkelt justera vårt tillstånd så:

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

återigen, låt gå igenom detta och se utgången:

# 3: Använda reduce

reduce – metoden används för att minska elementen i arrayen och kombinera dem till en slutlig array baserad på någon reduceringsfunktion som du passerar.

i det här fallet kontrollerar vår reduceringsfunktion om vår slutliga array innehåller objektet. Om det inte gör det, tryck det objektet i vår slutliga array. Annars hoppar du över det elementet och returnerar bara vår slutliga array som det är (i huvudsak hoppar över det elementet).

minska är alltid lite mer knepigt att förstå, så låt oss också gå in i varje fall och se utgången:

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:// ;

och här är utgången från konsolen.logga in:

# Gemenskapens bidrag

• @smokkku: array.includes(item) är mer idiomatiskt sätt att testa om array innehåller objektet

• @riquelkovsky: Just idag gjorde jag detta genom att göra följande.Object.keys(array.reduce((map, next) => ({...map, : true}), {}))

-@luisiacc2: visst, Set() kommer att göra susen för primitve värden, med objekt en icke O(n^2) lösning skulle först utföra en sort() på arrayen(som fungerar i O(nlogn)), och sedan söka efter adjacents lika poster(som är O(n)), så du fick O(n + nlogn).

• @iamdipankarj: också, Array.from(new Set()), men detta fungerar bara på primitiva. För filtrering dubbletter i array av anpassade objekt Array.filter() är vägen att gå.

• @benawad: filter körtid är O(n^2)