Hapus duplikat dari array objek dalam JavaScript

Saya memiliki objek yang berisi array objek.

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

Saya bertanya-tanya apa metode terbaik untuk menghapus objek duplikat dari array. Jadi misalnya, segalanya akan menjadi ...

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

Metode primitif adalah:

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

Bagaimana dengan es6sihir?

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

URL referensi

Solusi yang lebih umum adalah:

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

Contoh Stackblitz

Jika Anda dapat menggunakan pustaka Javascript seperti garis bawah atau lodash, saya sarankan melihat _.uniqfungsi di pustaka mereka. Dari lodash:

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

Pada dasarnya, Anda meneruskan dalam array yang di sini adalah objek literal dan Anda meneruskan atribut yang ingin Anda hapus duplikat dengan dalam array data asli, seperti ini:

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

UPDATE : Lodash sekarang telah memperkenalkan .uniqByjuga.

Saya memiliki persyaratan yang sama persis ini, untuk menghapus objek duplikat dalam array, berdasarkan duplikat pada satu bidang. Saya menemukan kode di sini: Javascript: Hapus Duplikat dari Array Objek

Jadi dalam contoh saya, saya menghapus objek apa pun dari array yang memiliki nilai string licenseNum duplikat.

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

Hasil:

uniqueArray adalah:

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

Satu liner terpendek untuk ES6 +

Temukan unik iddalam array.

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

Unik oleh beberapa properti ( placedan name)

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

Unik oleh semua properti (Ini akan lambat untuk array besar)

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

Pertahankan kejadian terakhir.

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

Satu liner menggunakan Set

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)

Penjelasan:

1. new Set(myData.map(JSON.stringify))menciptakan Set objek menggunakan elemen myData stringified.
2. Tetapkan objek akan memastikan bahwa setiap elemen unik.
3. Lalu saya membuat array berdasarkan elemen set yang dibuat menggunakan Array.from.
4. Akhirnya, saya menggunakan JSON.parse untuk mengubah elemen yang dirubah kembali menjadi sebuah objek.

Menggunakan ES6 + dalam satu baris Anda bisa mendapatkan daftar objek unik dengan kunci:

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

Itu dapat dimasukkan ke dalam fungsi:

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

Berikut ini contoh kerjanya:

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

bagaimana cara kerjanya

Pertama array ini dipetakan ulang sedemikian rupa sehingga dapat digunakan sebagai input untuk Peta.

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

yang berarti setiap item array akan ditransformasikan dalam array lain dengan 2 elemen; tombol yang dipilih sebagai elemen pertama dan seluruh item awal sebagai elemen kedua, ini disebut entri (mis. entri array , entri peta ). Dan sini adalah dokumen resmi dengan contoh yang menunjukkan cara menambahkan entri array di konstruktor Peta.

Contoh ketika kunci ditempatkan :

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

Kedua, kami meneruskan array yang dimodifikasi ini ke konstruktor Peta dan inilah keajaiban yang terjadi. Peta akan menghilangkan nilai kunci duplikat, menjaga hanya nilai yang dimasukkan terakhir dari kunci yang sama. Catatan : Peta menjaga urutan penyisipan. ( periksa perbedaan antara Peta dan objek )

Peta baru (array entri baru saja dipetakan di atas)

Ketiga, kami menggunakan nilai peta untuk mengambil item asli, tapi kali ini tanpa duplikat.

Peta baru (mappedArr) .nilai ()

Dan yang terakhir adalah menambahkan nilai-nilai itu ke dalam array baru yang baru sehingga dapat terlihat sebagai struktur awal dan mengembalikannya:

return [... Map baru (mappedArr) .values ​​()]

Berikut opsi lain untuk melakukannya menggunakan metode pengulangan Array jika Anda hanya perlu membandingkan dengan satu bidang objek:

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

satu liner ada di sini

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}),{})))

Jika Anda bisa menunggu untuk menghilangkan duplikat sampai setelah semua penambahan, pendekatan khasnya adalah mengurutkan array terlebih dahulu dan kemudian menghilangkan duplikat. Penyortiran menghindari pendekatan N * N memindai array untuk setiap elemen saat Anda berjalan melalui mereka.

The "menghilangkan duplikasi" fungsi biasanya disebut unik atau uniq . Beberapa implementasi yang ada dapat menggabungkan dua langkah, misalnya, uniq prototipe

Posting ini memiliki beberapa ide untuk dicoba (dan beberapa untuk menghindari :-)) jika perpustakaan Anda belum memilikinya ! Secara pribadi saya menemukan ini yang paling mudah:

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

Cara paling sederhana adalah menggunakan 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)

Ini adalah cara umum untuk melakukan ini: Anda meneruskan fungsi yang menguji apakah dua elemen array dianggap sama. Dalam hal ini, ia membandingkan nilai-nilai namedan placeproperti dari dua objek yang dibandingkan.

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

Jawaban ES3 asli

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

Untuk menambahkan satu lagi ke daftar. Menggunakan ES6 dan Array.reducedengan Array.find.
Dalam contoh ini, memfilter objek berdasarkan guidproperti.

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

Memperluas yang ini untuk memungkinkan pemilihan properti dan kompres menjadi satu liner:

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

Untuk menggunakannya, lewati array objek dan nama kunci yang ingin Anda hapus sebagai nilai string:

const result = uniqify(myArrayOfObjects, 'guid')

Anda juga dapat menggunakan Map:

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

Sampel lengkap:

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

Hasil:

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

Sial, anak-anak, ayo hancurkan benda ini, kenapa kita tidak?

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'}];

Solusi TypeScript

Ini akan menghapus objek duplikat dan juga melestarikan jenis objek.

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

Mengingat 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 }]

Pilihan lain adalah membuat fungsi indexOf kustom, yang membandingkan nilai properti yang Anda pilih untuk setiap objek dan membungkusnya dalam fungsi pengurangan.

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)

Satu-liner menggunakan ES6 dan new Map().

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

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

Detail: -

1. Melakukan .map()pada daftar data dan mengubah masing-masing objek menjadi [key, value]array pasangan (panjang = 2), elemen pertama (kunci) akan menjadi stringifiedversi objek dan yang kedua (nilai) akan menjadiobject dirinya sendiri.
2. Menambahkan daftar array yang dibuat di atas new Map()akan memiliki kunci sebagaistringified objek dan penambahan kunci yang sama akan mengakibatkan menimpa kunci yang sudah ada.
3. Menggunakan .values()akan memberi MapIterator dengan semua nilai dalam Peta (obj dalam kasus kami)
4. Akhirnya, spread ...operator memberikan Array baru dengan nilai dari langkah di atas.

Ini adalah solusi untuk es6 di mana Anda hanya ingin menyimpan item terakhir. Solusi ini fungsional dan sesuai dengan gaya 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 () mengambil dalam array objek dan mengembalikan array baru tanpa objek duplikat (berdasarkan properti 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);

Hasil yang diharapkan:

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

Pertama, kita menetapkan nilai variabel uniq ke objek kosong.

Selanjutnya, kami memfilter melalui array objek. Filter membuat array baru dengan semua elemen yang lulus tes diimplementasikan oleh fungsi yang disediakan.

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

Di atas, kami menggunakan fungsi hubungan singkat &&. Jika sisi kiri && dievaluasi ke true, maka ia mengembalikan nilai di sebelah kanan &&. Jika sisi kiri salah, ia mengembalikan apa yang ada di sisi kiri &&.

Untuk setiap objek (obj) kami memeriksa uniq untuk sebuah properti bernama nilai obj.id (Dalam hal ini, pada iterasi pertama ia akan memeriksa properti '1'.) Kami ingin kebalikan dari apa yang dikembalikan (baik benar atau salah) yang mengapa kami menggunakan! di! uniq [obj.id]. Jika uniq sudah memiliki properti id, ia mengembalikan true yang mengevaluasi false (!) Memberitahu fungsi filter TIDAK untuk menambahkan objek itu. Namun, jika tidak menemukan properti obj.id, ia mengembalikan false yang kemudian dievaluasi menjadi true (!) Dan mengembalikan semuanya ke kanan &&, atau (uniq [obj.id] = true). Ini adalah nilai kebenaran, memberi tahu metode filter untuk menambahkan objek ke array yang dikembalikan, dan juga menambahkan properti {1: true} ke uniq. Ini memastikan bahwa instance obj lain dengan id yang sama tidak akan ditambahkan lagi.

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

Saya percaya kombinasi reducedengan JSON.stringifyuntuk membandingkan Objek secara sempurna dan secara selektif menambahkan mereka yang belum berada di akumulator adalah cara yang elegan.

Perlu diingat bahwa JSON.stringifymungkin menjadi masalah kinerja dalam kasus ekstrim di mana array memiliki banyak Objek dan mereka kompleks, TAPI untuk sebagian besar waktu , ini adalah cara terpendek untuk pergi 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)

Cara penulisan yang sama (tapi kurang efisien):

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

Terus mengeksplorasi cara-cara ES6 untuk menghapus duplikat dari berbagai objek: menetapkan thisArgargumen Array.prototype.filteruntuk new Setmemberikan alternatif yang layak:

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

Namun, itu tidak akan berfungsi dengan fungsi panah () =>, karena thisterikat dengan ruang lingkup leksikal mereka.

es6 magic dalam satu baris ... dapat dibaca pada saat itu!

// 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]);

Solusi sederhana dengan metode bantu pengurangan ES6 'Perkecil' dan 'Temukan'

Bekerja dengan efisien dan sangat baik!

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

Jika Anda tidak keberatan array unik Anda diurutkan setelahnya, ini akan menjadi solusi yang efisien:

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

Dengan cara ini, Anda hanya perlu membandingkan elemen saat ini dengan elemen sebelumnya dalam array. Mengurutkan sekali sebelum memfilter ( O(n*log(n))) lebih murah daripada mencari duplikat di seluruh array untuk setiap elemen array ( O(n²)).

Ini adalah cara sederhana cara menghapus duplikat dari berbagai objek.

Saya banyak bekerja dengan data dan ini berguna bagi saya.

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

akan dicetak ke konsol:

[[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 adalah array objek. Ada objek yang memiliki nilai yang sama (di sini contoh kecil, ada dua objek yang memiliki item_id sama dengan 2). check (id) adalah fungsi yang memeriksa apakah ada objek yang memiliki item_id yang sama ada atau tidak. jika ada return false jika tidak return true. Menurut hasil itu, mendorong objek ke array baru obj Output dari kode di atas adalah [{"item_id":1},{"item_id":2}]

Pernahkah Anda mendengar tentang perpustakaan Lodash? Saya sarankan Anda utilitas ini, ketika Anda tidak benar-benar ingin menerapkan logika Anda ke kode, dan gunakan kode yang sudah ada yang dioptimalkan dan dapat diandalkan.

Pertimbangkan untuk membuat array seperti ini

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

Perhatikan bahwa jika Anda ingin membuat satu atribut unik, Anda dapat melakukannya dengan menggunakan pustaka lodash. Di sini, Anda dapat menggunakan _.uniqBy

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

Metode ini seperti _.uniq (yang mengembalikan versi bebas duplikat dari array, di mana hanya kejadian pertama dari setiap elemen disimpan) kecuali bahwa ia menerima iteratee yang dipanggil untuk setiap elemen dalam array untuk menghasilkan kriteria yang dengannya Keunikan dihitung.

Jadi, misalnya, jika Anda ingin mengembalikan array yang memiliki atribut unik 'tempat'

_.uniqBy (things.thing, 'place')

Demikian pula, jika Anda ingin atribut unik sebagai 'nama'

_.uniqBy (things.thing, 'name')

Semoga ini membantu.

Bersulang!