Xóa các bản sao khỏi một mảng các đối tượng trong JavaScript

Tôi có một đối tượng có chứa một mảng các đối tượng.

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

Tôi đang tự hỏi đâu là phương pháp tốt nhất để loại bỏ các đối tượng trùng lặp khỏi một mảng. Vì vậy, ví dụ, mọi thứ. Mọi thứ sẽ trở thành ...

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

Một phương pháp nguyên thủy sẽ là:

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

Làm thế nào với một số es6phép thuật?

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

URL tham chiếu

Một giải pháp chung hơn sẽ là:

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

Ví dụ về Stackblitz

Nếu bạn có thể sử dụng các thư viện Javascript như gạch dưới hoặc lodash, tôi khuyên bạn nên xem _.uniqchức năng trong thư viện của họ. Từ lodash:

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

Về cơ bản, bạn truyền vào mảng mà ở đây là một đối tượng bằng chữ và bạn chuyển vào thuộc tính mà bạn muốn loại bỏ trùng lặp trong mảng dữ liệu gốc, như sau:

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

CẬP NHẬT : Lodash bây giờ cũng đã giới thiệu một .uniqBy.

Tôi đã có yêu cầu chính xác này, để loại bỏ các đối tượng trùng lặp trong một mảng, dựa trên các bản sao trên một trường duy nhất. Tôi đã tìm thấy mã ở đây: Javascript: Loại bỏ trùng lặp khỏi mảng đối tượng

Vì vậy, trong ví dụ của tôi, tôi đang xóa bất kỳ đối tượng nào khỏi mảng có giá trị chuỗi LicenseNum trùng lặp.

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

Kết quả:

UniqueArray là:

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

Một lớp lót ngắn nhất cho ES6 +

Tìm duy nhất idtrong một mảng.

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

Duy nhất bởi nhiều thuộc tính ( placevà name)

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

Duy nhất bởi tất cả các thuộc tính (Điều này sẽ chậm đối với các mảng lớn)

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

Giữ lần xuất hiện cuối cùng

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

Một lớp lót sử dụng 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)

Giải trình:

1. new Set(myData.map(JSON.stringify))tạo một đối tượng Set bằng cách sử dụng các phần tử myData được xâu chuỗi.
2. Đặt đối tượng sẽ đảm bảo rằng mọi phần tử là duy nhất.
3. Sau đó, tôi tạo một mảng dựa trên các phần tử của tập đã tạo bằng Array.from.
4. Cuối cùng, tôi sử dụng JSON.parse để chuyển đổi phần tử được xâu chuỗi trở lại một đối tượng.

Sử dụng ES6 + trong một dòng duy nhất, bạn có thể nhận được một danh sách các đối tượng duy nhất theo khóa:

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

Nó có thể được đưa vào một chức năng:

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

Dưới đây là một ví dụ hoạt động:

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

Làm thế nào nó hoạt động

Đầu tiên, mảng được ánh xạ lại theo cách nó có thể được sử dụng làm đầu vào cho Bản đồ.

mảng.map (mục => [mục [khóa], mục]);

có nghĩa là mỗi mục của mảng sẽ được chuyển đổi trong một mảng khác có 2 phần tử; các khóa đã chọn như yếu tố đầu tiên và toàn bộ mục ban đầu như Yếu tố thứ hai, điều này được gọi là (ví dụ. entry mục mảng , mục bản đồ ). Và đây là tài liệu chính thức với một ví dụ chỉ ra cách thêm các mục mảng trong hàm tạo Map.

Ví dụ khi khóa được đặt :

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

Thứ hai, chúng tôi chuyển mảng đã sửa đổi này cho hàm tạo Map và đây là điều kỳ diệu xảy ra. Bản đồ sẽ loại bỏ các giá trị khóa trùng lặp, chỉ giữ giá trị được chèn cuối cùng của cùng một khóa. Lưu ý : Bản đồ giữ thứ tự chèn. ( kiểm tra sự khác biệt giữa Bản đồ và đối tượng )

Bản đồ mới (mảng nhập vừa được ánh xạ ở trên)

Thứ ba, chúng tôi sử dụng các giá trị bản đồ để lấy các mục gốc, nhưng lần này không có sự trùng lặp.

Bản đồ mới (mappedArr) .values ​​()

Và cuối cùng là thêm các giá trị đó vào một mảng mới để nó có thể trông giống như cấu trúc ban đầu và trả về:

trả về [... Bản đồ mới (mappedArr) .values ​​()]

Đây là một tùy chọn khác để thực hiện bằng các phương pháp lặp Array nếu bạn chỉ cần so sánh theo một trường của một đối tượng:

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

một lớp lót ở đây

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ếu bạn có thể chờ để loại bỏ các bản sao cho đến sau tất cả các bổ sung, cách tiếp cận điển hình là trước tiên sắp xếp mảng và sau đó loại bỏ các bản sao. Việc sắp xếp sẽ tránh cách tiếp cận N * N khi quét mảng cho từng phần tử khi bạn đi qua chúng.

Hàm "loại bỏ trùng lặp" thường được gọi là duy nhất hoặc uniq . Một số triển khai hiện có có thể kết hợp hai bước, ví dụ: uniq nguyên mẫu

Bài đăng này có một vài ý tưởng để thử (và một số để tránh :-)) nếu thư viện của bạn chưa có ! Cá nhân tôi thấy điều này là thẳng nhất:

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

Cách đơn giản nhất là sử dụng 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)

Đây là một cách chung để làm điều này: bạn truyền vào một hàm kiểm tra xem hai phần tử của một mảng có được coi là bằng nhau hay không. Trong trường hợp này, nó so sánh các giá trị của namevàplace thuộc tính của hai đối tượng được so sánh.

Câu trả lời 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);

Câu trả lời ES3 gốc

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

Để thêm một danh sách nữa. Sử dụng ES6 và Array.reducevới Array.find.
Trong ví dụ này lọc các đối tượng dựa trên một thuộc guidtính.

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

Mở rộng cái này để cho phép lựa chọn một thuộc tính và nén nó vào một lớp lót:

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

Để sử dụng, nó vượt qua một mảng các đối tượng và tên của khóa mà bạn muốn hủy mã thành một giá trị chuỗi:

const result = uniqify(myArrayOfObjects, 'guid')

Bạn cũng có thể sử dụng Map:

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

Mẫu đầy đủ:

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

Kết quả:

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

Dang, bọn trẻ, chúng ta hãy nghiền nát thứ này, tại sao chúng ta không?

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

Một giải pháp TypeScript

Điều này sẽ loại bỏ các đối tượng trùng lặp và cũng bảo tồn các loại đối tượng.

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

Xem xét 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 }]

Một tùy chọn khác là tạo một hàm indexOf tùy chỉnh, so sánh các giá trị của thuộc tính bạn đã chọn cho từng đối tượng và bọc hàm này trong hàm giảm.

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)

Một lớp lót sử dụng ES6 và new Map().

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

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

Chi tiết:-

1. Thực hiện .map()trên danh sách dữ liệu và chuyển đổi từng đối tượng riêng lẻ thành một [key, value]mảng cặp (length = 2), phần tử đầu tiên (khóa) sẽ làstringified phiên bản của đối tượng và thứ hai (giá trị) sẽ là mộtobject chính nó.
2. Thêm danh sách mảng đã tạo ở trên new Map()sẽ có khóa nhưstringified đối tượng và bất kỳ phép cộng khóa nào tương tự sẽ dẫn đến ghi đè khóa đã tồn tại.
3. Việc sử dụng .values()sẽ cung cấp cho MapIterator với tất cả các giá trị trong Bản đồ (obj trong trường hợp của chúng tôi)
4. Cuối cùng, spread ...toán tử đưa ra Mảng mới với các giá trị từ bước trên.

Đây là một giải pháp cho es6, nơi bạn chỉ muốn giữ mục cuối cùng. Giải pháp này phù hợp với chức năng và kiểu 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' }]

removeD repeatates () nhận một mảng các đối tượng và trả về một mảng mới mà không có bất kỳ đối tượng trùng lặp nào (dựa trên thuộc tính 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);

Kết quả dự kiến:

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

Đầu tiên, chúng ta đặt giá trị của biến uniq thành một đối tượng trống.

Tiếp theo, chúng tôi lọc qua mảng các đối tượng. Bộ lọc tạo ra một mảng mới với tất cả các yếu tố vượt qua bài kiểm tra được thực hiện bởi hàm được cung cấp.

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

Ở trên, chúng tôi sử dụng chức năng ngắn mạch của &&. Nếu bên trái của && ước tính là đúng, thì nó sẽ trả về giá trị ở bên phải của &&. Nếu bên trái là sai, nó sẽ trả về những gì ở bên trái của &&.

Đối với mỗi đối tượng (obj), chúng tôi kiểm tra uniq cho một thuộc tính có tên là giá trị của obj.id (Trong trường hợp này, trong lần lặp đầu tiên, nó sẽ kiểm tra thuộc tính '1'.) Chúng tôi muốn ngược lại với những gì nó trả về (đúng hoặc sai) đó là lý do tại sao chúng tôi sử dụng! trong! uniq [obj.id]. Nếu uniq đã có thuộc tính id, nó sẽ trả về true, ước lượng thành false (!) Nói với hàm bộ lọc KHÔNG thêm obj đó. Tuy nhiên, nếu nó không tìm thấy thuộc tính obj.id, nó sẽ trả về false, sau đó đánh giá là true (!) Và trả lại mọi thứ ở bên phải của &&, hoặc (uniq [obj.id] = true). Đây là một giá trị trung thực, nói cho phương thức bộ lọc thêm obj đó vào mảng được trả về và nó cũng thêm thuộc tính {1: true} vào uniq. Điều này đảm bảo rằng bất kỳ trường hợp obj nào khác có cùng id đó sẽ không được thêm lại.

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

Tôi tin rằng sự kết hợp reducevới JSON.stringifyđể so sánh hoàn hảo các Đối tượng và thêm chọn lọc những người chưa có trong bộ tích lũy là một cách thanh lịch.

Hãy nhớ rằng JSON.stringifycó thể trở thành một vấn đề hiệu năng trong các trường hợp cực đoan trong đó mảng có nhiều Đối tượng và chúng rất phức tạp, NHƯNG trong phần lớn thời gian , đây là cách ngắn nhất để đi 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)

Một cách viết khác giống nhau (nhưng kém hiệu quả hơn):

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

Tiếp tục khám phá các cách ES6 để loại bỏ các bản sao khỏi mảng các đối tượng: thiết lập thisArgđối số Array.prototype.filterđể new Setcung cấp một sự thay thế hợp lý:

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

Tuy nhiên, nó sẽ không hoạt động với các hàm mũi tên () =>, như thisbị ràng buộc với phạm vi từ vựng của chúng.

ma thuật es6 trong một dòng ... có thể đọc được ở đó!

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

Giải pháp đơn giản với các phương thức trợ giúp mảng ES6 'giảm' và 'tìm'

Hoạt động hiệu quả và hoàn toàn tốt!

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

Nếu bạn không nhớ mảng duy nhất của mình sẽ được sắp xếp sau đó, đây sẽ là một giải pháp hiệu quả:

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

Bằng cách này, bạn chỉ phải so sánh phần tử hiện tại với phần tử trước đó trong mảng. Sắp xếp một lần trước khi lọc ( O(n*log(n))) rẻ hơn so với tìm kiếm một bản sao trong toàn bộ mảng cho mọi phần tử mảng ( O(n²)).

Đây là cách đơn giản để loại bỏ sự trùng lặp khỏi mảng các đối tượng.

Tôi làm việc với dữ liệu rất nhiều và điều này hữu ích cho tôi.

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

sẽ in ra bàn điều khiển:

[[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 là một mảng các đối tượng. Tồn tại các đối tượng có cùng giá trị (ở đây một ví dụ nhỏ, có hai đối tượng có cùng item_id là 2). check (id) là một hàm kiểm tra xem có đối tượng nào có cùng item_id tồn tại hay không. nếu nó tồn tại trả về false nếu không trả về true. Theo kết quả đó, đẩy đối tượng vào một mảng mới obj Đầu ra của đoạn mã trên là [{"item_id":1},{"item_id":2}]

Bạn đã nghe nói về thư viện Lodash? Tôi khuyên bạn nên sử dụng tiện ích này, khi bạn không thực sự muốn áp dụng logic của mình vào mã và sử dụng mã đã có sẵn được tối ưu hóa và đáng tin cậy.

Hãy xem xét việc tạo một mảng như thế này

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

Lưu ý rằng nếu bạn muốn giữ một thuộc tính duy nhất, bạn rất có thể làm điều đó bằng cách sử dụng thư viện lodash. Tại đây, bạn có thể sử dụng _.uniqBy

.uniqBy (mảng, [iteratee = .identity])

Phương thức này giống như _.uniq (trả về một phiên bản không có bản sao của một mảng, trong đó chỉ có lần xuất hiện đầu tiên của mỗi phần tử được giữ) ngoại trừ việc nó chấp nhận iteratee được gọi cho mỗi phần tử trong mảng để tạo tiêu chí theo đó tính độc đáo được tính toán.

Vì vậy, ví dụ, nếu bạn muốn trả về một mảng có thuộc tính duy nhất là 'địa điểm'

_.uniqBy (điều. mọi thứ, 'địa điểm')

Tương tự, nếu bạn muốn thuộc tính duy nhất là 'tên'

_.uniqBy (điều. mọi thứ, 'tên')

Hi vọng điêu nay co ich.

Chúc mừng!