ลบรายการซ้ำออกจากอาร์เรย์ของวัตถุใน JavaScript

ฉันมีวัตถุที่มีอาร์เรย์ของวัตถุ

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

ฉันสงสัยว่าวิธีใดดีที่สุดในการลบวัตถุที่ซ้ำกันออกจากอาร์เรย์ ตัวอย่างเช่นทุกสิ่งทุกอย่างจะกลายเป็น ...

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

วิธีการดั้งเดิมจะเป็น:

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

ด้วยes6เวทมนตร์บางอย่าง?

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

URL อ้างอิง

วิธีแก้ปัญหาทั่วไปเพิ่มเติมจะเป็น:

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

ตัวอย่าง Stackblitz

หากคุณสามารถใช้ห้องสมุด Javascript เช่นขีดล่างหรือ lodash ฉันขอแนะนำให้ดูที่_.uniqฟังก์ชั่นในห้องสมุดของพวกเขา จากlodash:

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

โดยพื้นฐานแล้วคุณส่งผ่านอาร์เรย์ที่ในที่นี้เป็นวัตถุตามตัวอักษรและคุณส่งผ่านแอตทริบิวต์ที่คุณต้องการลบรายการที่ซ้ำด้วยในอาร์เรย์ข้อมูลดั้งเดิมเช่นนี้

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

ปรับปรุง : Lodash ตอนนี้ได้เปิดตัว.uniqByเช่นกัน

ฉันมีข้อกำหนดเดียวกันนี้แน่นอนในการลบวัตถุที่ซ้ำกันในอาร์เรย์โดยยึดตามรายการที่ซ้ำกันในเขตข้อมูลเดียว ฉันพบรหัสที่นี่: Javascript: ลบรายการที่ซ้ำออกจาก Array of Objects

ดังนั้นในตัวอย่างของฉันฉันกำลังลบวัตถุใด ๆ ออกจากอาร์เรย์ที่มีค่าสตริงที่อนุญาตซ้ำกัน

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

ผลลัพธ์ที่ได้:

uniqueArray คือ:

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

สั้นที่สุดหนึ่ง liners สำหรับ ES6 +

ค้นหาที่ไม่ซ้ำกันidในอาร์เรย์

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

ไม่ซ้ำกันโดยหลายคุณสมบัติ ( placeและname)

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

ไม่ซ้ำกันโดยคุณสมบัติทั้งหมด (ซึ่งจะช้าสำหรับอาร์เรย์ขนาดใหญ่)

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

เก็บเหตุการณ์ล่าสุดไว้

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

ซับหนึ่งชุดใช้

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)

คำอธิบาย:

1. new Set(myData.map(JSON.stringify))สร้างวัตถุชุดโดยใช้องค์ประกอบ myData stringified
2. ชุดวัตถุจะให้แน่ใจว่าองค์ประกอบทุกอย่างไม่ซ้ำกัน
3. จากนั้นฉันสร้างอาร์เรย์ตามองค์ประกอบของชุดที่สร้างขึ้นโดยใช้ Array.from
4. สุดท้ายฉันใช้ JSON.parse เพื่อแปลงองค์ประกอบที่เป็นสตริงกลับไปเป็นวัตถุ

การใช้ES6 +ในบรรทัดเดียวคุณสามารถรับรายการวัตถุที่ไม่ซ้ำกันโดยใช้คีย์:

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

มันสามารถใส่ลงในฟังก์ชั่น:

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

นี่คือตัวอย่างการทำงาน:

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

มันทำงานยังไง

ก่อนอื่นอาร์เรย์จะถูกแมปใหม่ในลักษณะที่สามารถใช้เป็นอินพุตสำหรับ แผนที่ได้

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

ซึ่งหมายความว่าแต่ละรายการของอาเรย์จะถูกเปลี่ยนในอาเรย์อื่นที่มี 2 องค์ประกอบ คีย์ที่เลือกเป็นองค์ประกอบแรกและรายการเริ่มต้นทั้งหมดเป็นองค์ประกอบที่สองนี้เรียกว่ารายการ (อดีต. รายการอาร์เรย์ , รายการแผนที่ ) และนี่คือเอกสารอย่างเป็นทางการพร้อมตัวอย่างที่แสดงวิธีเพิ่มรายการอาร์เรย์ในตัวสร้างแผนที่

ตัวอย่างเมื่อสถานที่สำคัญ:

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

ประการที่สองเราส่งอาร์เรย์ที่ปรับเปลี่ยนนี้ไปยังตัวสร้างแผนที่และนี่คือสิ่งมหัศจรรย์ที่เกิดขึ้น แผนที่จะกำจัดค่าของคีย์ที่ซ้ำกันโดยคงไว้ซึ่งค่าที่แทรกไว้ล่าสุดของคีย์เดียวกันเท่านั้น หมายเหตุ : แผนที่เก็บคำสั่งของการแทรก ( ตรวจสอบความแตกต่างระหว่างแผนที่และวัตถุ )

แผนที่ใหม่ (รายการอาร์เรย์ที่แมปไว้ด้านบน)

อันดับที่สามเราใช้ค่าแผนที่เพื่อดึงรายการต้นฉบับ แต่คราวนี้ไม่มีการทำซ้ำ

แผนที่ใหม่ (mappedArr) .values ​​()

และอันสุดท้ายคือการเพิ่มค่าเหล่านั้นลงในอาร์เรย์ใหม่ที่สดใหม่เพื่อให้มันสามารถดูเป็นโครงสร้างเริ่มต้นและกลับมาที่:

ส่งคืน [... แผนที่ใหม่ (mappedArr) .values ​​()]

นี่เป็นอีกตัวเลือกหนึ่งในการใช้ Array iterating method ถ้าคุณต้องการเปรียบเทียบโดยหนึ่งฟิลด์ของวัตถุ:

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

หนึ่งซับอยู่ที่นี่

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

หากคุณสามารถรอที่จะกำจัดรายการที่ซ้ำกันได้จนกระทั่งหลังจากการเพิ่มทั้งหมดวิธีการทั่วไปคือการเรียงลำดับอาร์เรย์ก่อนแล้วจึงกำจัดรายการที่ซ้ำกัน การเรียงลำดับหลีกเลี่ยงวิธี N * N ในการสแกนอาร์เรย์สำหรับแต่ละองค์ประกอบเมื่อคุณดำเนินการผ่าน

"การกำจัดข้อมูลซ้ำ" ฟังก์ชั่นมักจะเรียกว่าไม่ซ้ำกันหรือUNIQ การใช้งานที่มีอยู่บางอย่างอาจรวมสองขั้นตอนเช่นuniq ของต้นแบบ

โพสต์นี้มีแนวคิดไม่กี่ข้อที่จะลองใช้ (และบางอันควรหลีกเลี่ยง :-)) หากห้องสมุดของคุณยังไม่มี ! โดยส่วนตัวแล้วฉันพบว่าสิ่งนี้ตรงไปตรงมาที่สุด:

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

วิธีที่ง่ายที่สุดคือการใช้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)

นี่เป็นวิธีทั่วไปในการทำเช่นนี้: คุณส่งผ่านฟังก์ชันที่ทดสอบว่าองค์ประกอบสองอย่างของอาร์เรย์นั้นถือว่าเท่ากันหรือไม่ ในกรณีนี้มันเปรียบเทียบค่าของnameและplaceคุณสมบัติของวัตถุทั้งสองที่ถูกเปรียบเทียบ

คำตอบ 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);

คำตอบ 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);

เพื่อเพิ่มอีกหนึ่งรายการ ใช้ ES6 และมีArray.reduce ในตัวอย่างนี้การกรองวัตถุตามคุณสมบัติ Array.find
guid

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

การขยายอันนี้เพื่อให้สามารถเลือกคุณสมบัติและบีบอัดมันเป็นหนึ่งซับ:

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

หากต้องการใช้มันจะผ่านอาร์เรย์ของวัตถุและชื่อของคีย์ที่คุณต้องการยกเลิกการดักฟังเป็นค่าสตริง:

const result = uniqify(myArrayOfObjects, 'guid')

คุณสามารถใช้Map:

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

ตัวอย่างเต็มรูปแบบ:

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

ผลลัพธ์:

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

แดงเด็ก ๆ มาทำลายสิ่งนี้ลงทำไมเราไม่ทำล่ะ

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

โซลูชั่น TypeScript

สิ่งนี้จะลบวัตถุที่ซ้ำกันและยังคงประเภทของวัตถุ

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

พิจารณา 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 }]

อีกตัวเลือกหนึ่งคือการสร้างฟังก์ชั่น indexOf ที่กำหนดเองซึ่งจะเปรียบเทียบค่าของคุณสมบัติที่คุณเลือกสำหรับแต่ละวัตถุและตัดสิ่งนี้ในฟังก์ชันลด

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)

หนึ่งซับใช้ ES6 new Map()และ

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

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

รายละเอียด: -

1. การทำ.map()รายการข้อมูลและแปลงวัตถุแต่ละชิ้นให้เป็น[key, value]อาร์เรย์คู่ (length = 2) องค์ประกอบแรก (คีย์) จะเป็นstringifiedรุ่นของวัตถุและวินาที (ค่า) จะเป็นobjectตัวของมันเอง
2. การเพิ่มรายการอาร์เรย์ที่สร้างขึ้นข้างต้นเพื่อให้new Map()มีคีย์เป็นstringifiedวัตถุและการเพิ่มคีย์เดียวกันใด ๆ จะส่งผลให้มีการแทนที่คีย์ที่มีอยู่แล้ว
3. การใช้.values()จะให้ MapIterator กับค่าทั้งหมดในแผนที่ (objในกรณีของเรา)
4. ในที่สุดspread ...ผู้ประกอบการที่จะให้อาร์เรย์ใหม่ที่มีค่าจากขั้นตอนข้างต้น

นี่คือทางออกสำหรับ es6 ที่คุณต้องการเก็บรายการสุดท้ายเท่านั้น โซลูชันนี้ใช้งานได้และสอดคล้องกับสไตล์ 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 () ใช้เวลาในอาร์เรย์ของวัตถุและส่งกลับอาร์เรย์ใหม่โดยไม่ต้องวัตถุที่ซ้ำกันใด ๆ (ขึ้นอยู่กับคุณสมบัติ 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);

ผลลัพธ์ที่คาดหวัง:

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

อันดับแรกเราตั้งค่าตัวแปร uniq เป็นวัตถุว่าง

ต่อไปเราจะกรองอาร์เรย์ของวัตถุ ตัวกรองสร้างอาร์เรย์ใหม่พร้อมองค์ประกอบทั้งหมดที่ผ่านการทดสอบที่ใช้งานโดยฟังก์ชันที่มีให้

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

ข้างต้นเราใช้ฟังก์ชันการลัดวงจรของ && หากด้านซ้ายของ && ประเมินเป็นจริงก็จะส่งคืนค่าทางด้านขวาของ && หากด้านซ้ายเป็นเท็จจะส่งคืนสิ่งที่อยู่ทางด้านซ้ายของ &&

สำหรับแต่ละวัตถุ (obj) เราตรวจสอบ uniq สำหรับคุณสมบัติที่มีชื่อว่าค่าของ obj.id (ในกรณีนี้ในการทำซ้ำครั้งแรกมันจะตรวจสอบคุณสมบัติ '1') เราต้องการตรงกันข้ามกับสิ่งที่มันคืน (จริง หรือเท็จ) ซึ่งเป็นเหตุผลที่เราใช้! ใน! uniq [obj.id] ถ้า uniq มีคุณสมบัติ id อยู่แล้วมันจะคืนค่าจริงซึ่งประเมินว่าเป็นเท็จ (!) แจ้งให้ฟังก์ชั่นตัวกรองไม่ต้องเพิ่ม obj นั้น อย่างไรก็ตามหากไม่พบคุณสมบัติ obj.id จะส่งคืนค่าเท็จซึ่งจะประเมินเป็นจริง (!) และส่งกลับทุกอย่างทางด้านขวาของ && หรือ (uniq [obj.id] = true) นี่เป็นค่าจริงบอกวิธีการกรองเพื่อเพิ่ม obj นั้นไปยังอาร์เรย์ที่ส่งคืนและยังเพิ่มคุณสมบัติ {1: true} ให้กับ uniq สิ่งนี้ทำให้มั่นใจได้ว่าอินสแตนซ์ obj อื่น ๆ ที่มี id เดียวกันนั้นจะไม่ถูกเพิ่มอีก

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

ฉันเชื่อว่าการรวมกันของreduceกับJSON.stringifyเพื่อเปรียบเทียบวัตถุอย่างสมบูรณ์และเลือกผู้ที่ไม่ได้อยู่ในการสะสมเป็นวิธีที่สง่างาม

โปรดทราบว่าJSON.stringifyอาจกลายเป็นปัญหาด้านประสิทธิภาพในกรณีที่มีอาร์เรย์ที่มีวัตถุจำนวนมากและมีความซับซ้อน แต่ส่วนใหญ่แล้วนี่เป็นวิธีที่สั้นที่สุดในการไป 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)

อีกวิธีในการเขียนเหมือนกัน (แต่มีประสิทธิภาพน้อยกว่า):

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

สำรวจวิธี ES6 ในการลบรายการที่ซ้ำกันออกจากอาร์เรย์ของวัตถุอย่างต่อเนื่อง: การตั้งค่าthisArgอาร์กิวเมนต์เป็นArray.prototype.filterเพื่อnew Setเป็นทางเลือกที่เหมาะสม:

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

อย่างไรก็ตามมันจะไม่ทำงานกับฟังก์ชั่นลูกศร() =>เนื่องจากthisถูกผูกไว้กับขอบเขตของคำศัพท์

es6 magic ในหนึ่งบรรทัด ... อ่านได้ที่!

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

วิธีง่ายๆด้วย ES6 'ลด' และ 'ค้นหา' วิธีการของอาเรย์

ทำงานได้อย่างมีประสิทธิภาพและดีอย่างสมบูรณ์!

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

หากคุณไม่คำนึงถึงอาเรย์ที่ไม่เหมือนใครของคุณจะถูกจัดเรียงหลังจากนั้นสิ่งนี้จะเป็นโซลูชันที่มีประสิทธิภาพ:

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

ด้วยวิธีนี้คุณจะต้องเปรียบเทียบองค์ประกอบปัจจุบันกับองค์ประกอบก่อนหน้าในอาร์เรย์ การเรียงหนึ่งครั้งก่อนการกรอง ( O(n*log(n))) จะถูกกว่าการค้นหาซ้ำในอาร์เรย์ทั้งหมดสำหรับทุกองค์ประกอบของอาร์เรย์ ( O(n²))

นี่เป็นวิธีง่ายๆในการลบความซ้ำซ้อนออกจากอาร์เรย์ของวัตถุ

ฉันทำงานกับข้อมูลเยอะและมันมีประโยชน์สำหรับฉัน

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

จะพิมพ์ลงในคอนโซล:

[[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เป็นอาร์เรย์ของวัตถุ มีวัตถุที่มีค่าเท่ากัน (นี่คือตัวอย่างเล็ก ๆ มีวัตถุสองรายการที่มี item_id เดียวกันกับ 2) check (id)เป็นฟังก์ชันที่ตรวจสอบว่ามีวัตถุใด ๆ ที่มี item_id เดียวกันหรือไม่ ถ้ามันมีอยู่กลับเท็จมิฉะนั้นกลับเป็นจริง ตามผลลัพธ์นั้นให้ผลักวัตถุเข้าไปในอาร์เรย์ใหม่obj ผลลัพธ์ของโค้ดด้านบนคือ [{"item_id":1},{"item_id":2}]

คุณเคยได้ยินของห้องสมุด Lodash หรือไม่? ฉันขอแนะนำให้คุณใช้ยูทิลิตี้นี้เมื่อคุณไม่ต้องการใช้ตรรกะของคุณกับรหัสและใช้รหัสที่มีอยู่แล้วซึ่งได้รับการปรับปรุงและน่าเชื่อถือ

ลองสร้างอาร์เรย์แบบนี้

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

โปรดทราบว่าหากคุณต้องการคงไว้ซึ่งคุณลักษณะที่ไม่ซ้ำใครคุณสามารถทำได้โดยใช้ lodash library ที่นี่คุณสามารถใช้_.uniqBy

.uniqBy (อาร์เรย์, [iteratee = .identity])

วิธีนี้เปรียบเสมือน_.uniq (ซึ่งจะส่งกลับอาร์เรย์รุ่นที่ไม่ซ้ำกันซึ่งจะเกิดขึ้นครั้งแรกของแต่ละองค์ประกอบเท่านั้น) ยกเว้นว่าจะยอมรับ iteratee ซึ่งถูกเรียกใช้สำหรับแต่ละองค์ประกอบในอาร์เรย์เพื่อสร้างเกณฑ์โดยที่ มีการคำนวณเอกลักษณ์

ตัวอย่างเช่นหากคุณต้องการส่งคืนอาร์เรย์ที่มีแอตทริบิวต์ที่ไม่ซ้ำกันของ 'สถานที่'

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

ในทำนองเดียวกันหากคุณต้องการแอตทริบิวต์ที่ไม่ซ้ำกันเป็น 'ชื่อ'

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

หวังว่านี่จะช่วยได้

ไชโย!