Usuń duplikaty z tablicy obiektów w JavaScript

Mam obiekt, który zawiera tablicę obiektów.

things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

Zastanawiam się, jaka jest najlepsza metoda usuwania zduplikowanych obiektów z tablicy. Na przykład rzeczy. Wszystko stałoby się ...

{place:"here",name:"stuff"},
{place:"there",name:"morestuff"}

Prymitywną metodą byłoby:

var obj = {};

for ( var i=0, len=things.thing.length; i < len; i++ )
    obj[things.thing[i]['place']] = things.thing[i];

things.thing = new Array();
for ( var key in obj )
    things.thing.push(obj[key]);

Co powiesz na es6magię?

things.thing = things.thing.filter((thing, index, self) =>
  index === self.findIndex((t) => (
    t.place === thing.place && t.name === thing.name
  ))
)

Referencyjny adres URL

Bardziej ogólnym rozwiązaniem byłoby:

const uniqueArray = things.thing.filter((thing, index) => {
  const _thing = JSON.stringify(thing);
  return index === things.thing.findIndex(obj => {
    return JSON.stringify(obj) === _thing;
  });
});

Przykład Stackblitz

Jeśli możesz korzystać z bibliotek Javascript, takich jak podkreślenie lub lodash, polecam przyjrzeć się _.uniqfunkcji w ich bibliotekach. Od lodash:

_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])

Zasadniczo przekazujesz tablicę, która tutaj jest literałem obiektu, i przekazujesz atrybut, z którym chcesz usunąć duplikaty w oryginalnej tablicy danych, jak poniżej:

var data = [{'name': 'Amir', 'surname': 'Rahnama'}, {'name': 'Amir', 'surname': 'Stevens'}];
var non_duplidated_data = _.uniq(data, 'name'); 

AKTUALIZACJA : Lodash teraz również wprowadził .uniqBy.

Miałem dokładnie ten sam wymóg, aby usunąć zduplikowane obiekty w tablicy na podstawie duplikatów na jednym polu. Znalazłem kod tutaj: JavaScript: Usuń duplikaty z tablicy obiektów

Tak więc w moim przykładzie usuwam z tablicy dowolny obiekt, który ma zduplikowaną wartość ciągu licenseNum.

var arrayWithDuplicates = [
    {"type":"LICENSE", "licenseNum": "12345", state:"NV"},
    {"type":"LICENSE", "licenseNum": "A7846", state:"CA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"OR"},
    {"type":"LICENSE", "licenseNum": "10849", state:"CA"},
    {"type":"LICENSE", "licenseNum": "B7037", state:"WA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"NM"}
];

function removeDuplicates(originalArray, prop) {
     var newArray = [];
     var lookupObject  = {};

     for(var i in originalArray) {
        lookupObject[originalArray[i][prop]] = originalArray[i];
     }

     for(i in lookupObject) {
         newArray.push(lookupObject[i]);
     }
      return newArray;
 }

var uniqueArray = removeDuplicates(arrayWithDuplicates, "licenseNum");
console.log("uniqueArray is: " + JSON.stringify(uniqueArray));

Wyniki:

UniqueArray to:

[{"type":"LICENSE","licenseNum":"10849","state":"CA"},
{"type":"LICENSE","licenseNum":"12345","state":"NM"},
{"type":"LICENSE","licenseNum":"A7846","state":"CA"},
{"type":"LICENSE","licenseNum":"B7037","state":"WA"}]

Najkrótsza jedna wkładka do ES6 +

Znajdź unikalne idw tablicy.

arr.filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i)

Unikatowy dzięki wielu właściwościom ( placei name)

arr.filter((v,i,a)=>a.findIndex(t=>(t.place === v.place && t.name===v.name))===i)

Unikatowy dla wszystkich właściwości (To będzie wolne dla dużych tablic)

arr.filter((v,i,a)=>a.findIndex(t=>(JSON.stringify(t) === JSON.stringify(v)))===i)

Zachowaj ostatnie wystąpienie.

arr.slice().reverse().filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i).reverse()

Jedna wkładka przy użyciu zestawu

var things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

// assign things.thing to myData for brevity
var myData = things.thing;

things.thing = Array.from(new Set(myData.map(JSON.stringify))).map(JSON.parse);

console.log(things.thing)

Wyjaśnienie:

1. new Set(myData.map(JSON.stringify))tworzy obiekt Set przy użyciu strunowanych elementów myData.
2. Ustaw obiekt zapewni, że każdy element jest unikalny.
3. Następnie tworzę tablicę na podstawie elementów tworzonego zestawu za pomocą Array.from.
4. Na koniec używam JSON.parse, aby przekonwertować element zesznurowany z powrotem na obiekt.

Używając ES6 + w jednym wierszu, możesz uzyskać unikalną listę obiektów według klucza:

const unique = [...new Map(arr.map(item => [item[key], item])).values()]

Można go włączyć w funkcję:

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

Oto działający przykład:

const arr = [
    {place: "here",  name: "x", other: "other stuff1" },
    {place: "there", name: "x", other: "other stuff2" },
    {place: "here",  name: "y", other: "other stuff4" },
    {place: "here",  name: "z", other: "other stuff5" }
]

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

const arr1 = getUniqueListBy(arr, 'place')

console.log("Unique by place")
console.log(JSON.stringify(arr1))

console.log("\nUnique by name")
const arr2 = getUniqueListBy(arr, 'name')

console.log(JSON.stringify(arr2))

Jak to działa

Najpierw tablica jest odwzorowywana w taki sposób, że może być używana jako dane wejściowe dla mapy.

arr.map (item => [item [key], item]);

co oznacza, że ​​każdy element tablicy zostanie przekształcony w inną tablicę z 2 elementami; wybrany klucz jako pierwszego elementu i całej początkowej pozycji jako drugi element, nazywa wpisu (np. wpisy tablic , wpisy map ). A oto oficjalny dokument z przykładem pokazującym, jak dodawać wpisy tablicy w Konstruktorze map.

Przykład, kiedy kluczem jest miejsce :

[["here", {place: "here",  name: "x", other: "other stuff1" }], ...]

Po drugie, przekazujemy tę zmodyfikowaną tablicę konstruktorowi mapy i oto dzieje się magia. Mapa wyeliminuje zduplikowane wartości kluczy, zachowując tylko ostatnią wstawioną wartość tego samego klucza. Uwaga : Mapa zachowuje kolejność wstawiania. ( sprawdź różnicę między mapą a obiektem )

nowa mapa (tablica wprowadzania właśnie zamapowana powyżej)

Po trzecie, używamy wartości mapy, aby odzyskać oryginalne elementy, ale tym razem bez duplikatów.

nowa mapa (mappedArr). wartości ()

Ostatnim jest dodanie tych wartości do nowej, nowej tablicy, aby mogła wyglądać jak struktura początkowa i zwracać:

return [... nowa mapa (mappedArr) .values ​​()]

Oto kolejna opcja, aby to zrobić za pomocą metod iteracyjnych Array, jeśli potrzebujesz porównania tylko przez jedno pole obiektu:

    function uniq(a, param){
        return a.filter(function(item, pos, array){
            return array.map(function(mapItem){ return mapItem[param]; }).indexOf(item[param]) === pos;
        })
    }

    uniq(things.thing, 'place');

jedna wkładka jest tutaj

let arr = [
  {id:1,name:"sravan ganji"},
  {id:2,name:"anu"},
  {id:4,name:"mammu"},
  {id:3,name:"sanju"},
  {id:3,name:"ram"},
];

console.log(Object.values(arr.reduce((acc,cur)=>Object.assign(acc,{[cur.id]:cur}),{})))

Jeśli możesz poczekać na wyeliminowanie duplikatów, aż po wszystkich dodatkach, typowym podejściem jest najpierw posortowanie tablicy, a następnie wyeliminowanie duplikatów. Sortowanie pozwala uniknąć podejścia N * N polegającego na skanowaniu tablicy dla każdego elementu podczas ich przechodzenia.

Funkcja „eliminuj duplikaty” jest zwykle nazywana unikalną lub uniq . Niektóre istniejące implementacje mogą łączyć dwa etapy, np . Uniq prototypu

Ten post ma kilka pomysłów do wypróbowania (i niektórych, których należy unikać :-)), jeśli twoja biblioteka jeszcze go nie ma ! Osobiście uważam, że ten jest najprostszy:

    function unique(a){
        a.sort();
        for(var i = 1; i < a.length; ){
            if(a[i-1] == a[i]){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }  

    // Provide your own comparison
    function unique(a, compareFunc){
        a.sort( compareFunc );
        for(var i = 1; i < a.length; ){
            if( compareFunc(a[i-1], a[i]) === 0){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }

Najprostszym sposobem jest użycie filter:

var uniq = {}
var arr  = [{"id":"1"},{"id":"1"},{"id":"2"}]
var arrFiltered = arr.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));
console.log('arrFiltered', arrFiltered)

Jest to ogólny sposób: przekazywanie funkcji sprawdzającej, czy dwa elementy tablicy są równe. W tym przypadku porównuje wartości namei placewłaściwości dwóch porównywanych obiektów.

Odpowiedź ES5

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arr.some(function(item) { return equals(item, val); })) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

var things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

removeDuplicates(things, thingsEqual);
console.log(things);

Oryginalna odpowiedź ES3

function arrayContains(arr, val, equals) {
    var i = arr.length;
    while (i--) {
        if ( equals(arr[i], val) ) {
            return true;
        }
    }
    return false;
}

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, j, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arrayContains(arr, val, equals)) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

removeDuplicates(things.thing, thingsEqual);

Aby dodać jeszcze jeden do listy. Korzystanie z ES6 i Array.reduceprzy pomocy Array.find.
W tym przykładzie filtrowanie obiektów na podstawie guidwłaściwości.

let filtered = array.reduce((accumulator, current) => {
  if (! accumulator.find(({guid}) => guid === current.guid)) {
    accumulator.push(current);
  }
  return accumulator;
}, []);

Rozszerzenie tej opcji, aby umożliwić wybór właściwości i spakowanie jej w jedną warstwę:

const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.push(curr) && prev, []);

Aby z niego skorzystać, przekaż tablicę obiektów i nazwę klucza, który chcesz wyodrębnić jako wartość ciągu:

const result = uniqify(myArrayOfObjects, 'guid')

Możesz również użyć Map:

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

Pełna próbka:

const things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

Wynik:

[
    {
        "place": "here",
        "name": "stuff"
    },
    {
        "place": "there",
        "name": "morestuff"
    }
]

Cholera, dzieciaki, zmiażdżmy to, dlaczego nie?

let uniqIds = {}, source = [{id:'a'},{id:'b'},{id:'c'},{id:'b'},{id:'a'},{id:'d'}];
let filtered = source.filter(obj => !uniqIds[obj.id] && (uniqIds[obj.id] = true));
console.log(filtered);
// EXPECTED: [{id:'a'},{id:'b'},{id:'c'},{id:'d'}];

Rozwiązanie TypeScript

Spowoduje to usunięcie zduplikowanych obiektów, a także zachowanie typów obiektów.

function removeDuplicateObjects(array: any[]) {
  return [...new Set(array.map(s => JSON.stringify(s)))]
    .map(s => JSON.parse(s));
}

Wobec lodash.uniqWith

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

Inną opcją byłoby utworzenie niestandardowej funkcji indexOf, która porównuje wartości wybranej właściwości dla każdego obiektu i zawija ją w funkcji redukcji.

var uniq = redundant_array.reduce(function(a,b){
      function indexOfProperty (a, b){
          for (var i=0;i<a.length;i++){
              if(a[i].property == b.property){
                   return i;
               }
          }
         return -1;
      }

      if (indexOfProperty(a,b) < 0 ) a.push(b);
        return a;
    },[]);

let myData = [{place:"here",name:"stuff"}, 
 {place:"there",name:"morestuff"},
 {place:"there",name:"morestuff"}];


let q = [...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

console.log(q)

Jednowarstwowy przy użyciu ES6 i new Map().

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

Detale:-

1. Robiąc .map()na liście danych i konwertując każdy pojedynczy obiekt na [key, value]tablicę par (długość = 2), pierwszy element (klucz) byłby stringifiedwersją obiektu, a drugi (wartość) byłbyobject sam.
2. Dodanie powyżej utworzonej listy tablic do new Map()miałoby klucz jako stringifiedobiekt, a każde dodanie tego samego klucza spowodowałoby zastąpienie już istniejącego klucza.
3. Użycie .values()dałoby MapIterator ze wszystkimi wartościami na mapie (obj w naszym przypadku)
4. Na koniec spread ...operator podaje nową tablicę z wartościami z powyższego kroku.

Oto rozwiązanie dla es6, w którym chcesz tylko zatrzymać ostatni przedmiot. To rozwiązanie jest funkcjonalne i zgodne ze stylem Airbnb.

const things = {
  thing: [
    { place: 'here', name: 'stuff' },
    { place: 'there', name: 'morestuff1' },
    { place: 'there', name: 'morestuff2' }, 
  ],
};

const removeDuplicates = (array, key) => {
  return array.reduce((arr, item) => {
    const removed = arr.filter(i => i[key] !== item[key]);
    return [...removed, item];
  }, []);
};

console.log(removeDuplicates(things.thing, 'place'));
// > [{ place: 'here', name: 'stuff' }, { place: 'there', name: 'morestuff2' }]

removeDuplicates () przyjmuje tablicę obiektów i zwraca nową tablicę bez żadnych zduplikowanych obiektów (na podstawie właściwości id).

const allTests = [
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'},
  {name: 'Test2', id: '2'},
  {name: 'Test3', id: '3'}
];

function removeDuplicates(array) {
  let uniq = {};
  return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true))
}

removeDuplicates(allTests);

Spodziewany rezultat:

[
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'}
];

Najpierw ustawiamy wartość zmiennej uniq na pusty obiekt.

Następnie filtrujemy przez tablicę obiektów. Filtr tworzy nową tablicę ze wszystkimi elementami, które pomyślnie przejdą test zaimplementowany przez podaną funkcję.

return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));

Powyżej korzystamy z funkcji zwierania &&. Jeśli lewa strona && ma wartość true, to zwraca wartość po prawej stronie &&. Jeśli lewa strona jest fałszywa, zwraca to, co znajduje się po lewej stronie &&.

Dla każdego obiektu (obj) sprawdzamy uniq pod kątem właściwości o nazwie obj.id (W tym przypadku przy pierwszej iteracji sprawdzałby właściwość „1”). Chcemy, aby było odwrotnie niż to, co zwraca (prawda lub false), dlatego używamy! w! uniq [obj.id]. Jeśli uniq ma już właściwość id, zwraca true, co daje wartość false (!), Informując funkcję filtrującą, aby NIE dodawała tego obj. Jeśli jednak nie znajdzie właściwości obj.id, zwraca false, która następnie zwraca wartość true (!) I zwraca wszystko po prawej stronie && lub (uniq [obj.id] = true). Jest to prawdziwa wartość, która mówi metodzie filter, aby dodała ten obiekt do zwracanej tablicy, a także dodaje właściwość {1: true} do uniq. Dzięki temu żadna inna instancja obj o tym samym identyfikatorze nie zostanie dodana ponownie.

let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');

Uważam, że połączenie reducez, JSON.stringifyaby idealnie porównać obiekty i selektywne dodawanie tych, którzy nie są jeszcze w akumulatorze, jest eleganckim sposobem.

Należy pamiętać, że JSON.stringifymoże to stanowić problem z wydajnością w skrajnych przypadkach, gdy tablica zawiera wiele obiektów i są one złożone, ALE przez większość czasu jest to najkrótsza droga do przejścia na IMHO.

var collection= [{a:1},{a:2},{a:1},{a:3}]

var filtered = collection.reduce((filtered, item) => {
  if( !filtered.some(filteredItem => JSON.stringify(filteredItem) == JSON.stringify(item)) )
    filtered.push(item)
  return filtered
}, [])

console.log(filtered)

Inny sposób pisania tego samego (ale mniej wydajnego):

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

Kontynuacja eksploracji sposobów usuwania duplikatów z tablicy obiektów ES6: ustawienie thisArgargumentu Array.prototype.filterna new Setzapewnia przyzwoitą alternatywę:

const things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

const filtered = things.filter(function({place, name}) {

  const key =`${place}${name}`;

  return !this.has(key) && this.add(key);

}, new Set);

console.log(filtered);

Jednak nie będzie działać z funkcjami strzałek () =>, ponieważ thisjest to związane z ich zakresem leksykalnym.

Magia es6 w jednej linii ... czytelna!

// returns the union of two arrays where duplicate objects with the same 'prop' are removed
const removeDuplicatesWith = (a, b, prop) => a.filter(x => !b.find(y => x[prop] === y[prop]);

Proste rozwiązanie z metodami pomocniczymi macierzy ES6 „zmniejsz” i „znajdź”

Działa wydajnie i idealnie dobrze!

"use strict";

var things = new Object();
things.thing = new Array();
things.thing.push({
    place: "here",
    name: "stuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});

// the logic is here

function removeDup(something) {
    return something.thing.reduce(function (prev, ele) {
        var found = prev.find(function (fele) {
            return ele.place === fele.place && ele.name === fele.name;
        });
        if (!found) {
            prev.push(ele);
        }
        return prev;
    }, []);
}
console.log(removeDup(things));

Jeśli nie masz nic przeciwko posortowaniu unikalnej tablicy, byłoby to skuteczne rozwiązanie:

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

W ten sposób wystarczy porównać bieżący element z poprzednim elementem w tablicy. Sortowanie raz przed filtrowaniem ( O(n*log(n))) jest tańsze niż wyszukiwanie duplikatu w całej tablicy dla każdego elementu tablicy ( O(n²)).

Jest to prosty sposób na usunięcie duplikatu z tablicy obiektów.

Dużo pracuję z danymi i jest to dla mnie przydatne.

const data = [{name: 'AAA'}, {name: 'AAA'}, {name: 'BBB'}, {name: 'AAA'}];
function removeDuplicity(datas){
    return datas.filter((item, index,arr)=>{
    const c = arr.map(item=> item.name);
    return  index === c.indexOf(item.name)
  })
}

console.log(removeDuplicity(data))

wypisze w konsoli:

[[object Object] {
name: "AAA"
}, [object Object] {
name: "BBB"
}]

str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str to tablica obiektów. Istnieją obiekty o tej samej wartości (tutaj mały przykład, są dwa obiekty o tym samym item_id jak 2). check (id) to funkcja, która sprawdza, czy istnieje obiekt o tym samym identyfikatorze elementu. jeśli istnieje, zwróć false, w przeciwnym razie zwróć true. Zgodnie z tym wynikiem wciśnij obiekt do nowej tablicy obj . Wyjście powyższego kodu to [{"item_id":1},{"item_id":2}]

Czy słyszałeś o bibliotece Lodash? Polecam to narzędzie, gdy tak naprawdę nie chcesz zastosować swojej logiki do kodu i użyć już obecnego kodu, który jest zoptymalizowany i niezawodny.

Rozważ utworzenie takiej tablicy

things.thing.push({place:"utopia",name:"unicorn"});
things.thing.push({place:"jade_palace",name:"po"});
things.thing.push({place:"jade_palace",name:"tigress"});
things.thing.push({place:"utopia",name:"flying_reindeer"});
things.thing.push({place:"panda_village",name:"po"});

Zauważ, że jeśli chcesz zachować unikalny atrybut, możesz to zrobić za pomocą biblioteki lodash. Tutaj możesz użyć _.uniqBy

.uniqBy (tablica, [iteratee = .identity])

Ta metoda jest podobna do _.uniq (która zwraca pozbawioną duplikatów wersję tablicy, w której zachowane jest tylko pierwsze wystąpienie każdego elementu), z tym wyjątkiem, że akceptuje iterat, który jest wywoływany dla każdego elementu w tablicy w celu wygenerowania kryterium, według którego wyjątkowość jest obliczana.

Na przykład, jeśli chcesz zwrócić tablicę posiadającą unikalny atrybut „miejsce”

_.uniqBy (Things.thing, „place”)

Podobnie, jeśli chcesz unikalny atrybut jako „nazwa”

_.uniqBy (Things.thing, „name”)

Mam nadzieję że to pomoże.

Twoje zdrowie!