Xóa các đối tượng trùng lặp với Underscore cho Javascript

Tôi có loại mảng này:

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];

Tôi muốn lọc nó để có:

var bar = [ { "a" : "1" }, { "b" : "2" }];

Tôi đã thử sử dụng _.uniq, nhưng tôi đoán vì { "a" : "1" }không bằng chính nó, nó không hoạt động. Có cách nào để cung cấp unicore uniq với hàm overriden bằng không?

.uniq / .unique chấp nhận gọi lại

var list = [{a:1,b:5},{a:1,c:5},{a:2},{a:3},{a:4},{a:3},{a:2}];

var uniqueList = _.uniq(list, function(item, key, a) { 
    return item.a;
});

// uniqueList = [Object {a=1, b=5}, Object {a=2}, Object {a=3}, Object {a=4}]

Ghi chú:

1. Giá trị gọi lại được sử dụng để so sánh
2. Đối tượng so sánh đầu tiên với giá trị trả về duy nhất được sử dụng là duy nhất
3. underscorejs.org chứng minh không sử dụng gọi lại
4. lodash.com cho thấy việc sử dụng

Một ví dụ khác: sử dụng phương thức gọi lại để trích xuất xe, màu sắc từ danh sách

Nếu bạn đang tìm cách xóa các bản sao dựa trên id, bạn có thể làm một cái gì đó như thế này:

var res = [
  {id: 1, content: 'heeey'},
  {id: 2, content: 'woah'}, 
  {id: 1, content:'foo'},
  {id: 1, content: 'heeey'},
];
var uniques = _.map(_.groupBy(res,function(doc){
  return doc.id;
}),function(grouped){
  return grouped[0];
});

//uniques
//[{id: 1, content: 'heeey'},{id: 2, content: 'woah'}]

Thực hiện câu trả lời của Shiplu.

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];

var x = _.uniq( _.collect( foo, function( x ){
    return JSON.stringify( x );
}));

console.log( x ); // returns [ { "a" : "1" }, { "b" : "2" } ]

Khi tôi có id thuộc tính, đây là cách được đặt trước của tôi trong dấu gạch dưới:

var x = [{i:2}, {i:2, x:42}, {i:4}, {i:3}];
_.chain(x).indexBy("i").values().value();
// > [{i:2, x:42}, {i:4}, {i:3}]

Sử dụng lib dưới đây duy nhất làm việc cho tôi, tôi đang tạo danh sách duy nhất dựa trên _id sau đó trả về giá trị Chuỗi của _id:

var uniqueEntities = _.uniq(entities, function (item, key, a) {
                                    return item._id.toString();
                                });

Đây là một giải pháp đơn giản, sử dụng so sánh đối tượng sâu để kiểm tra các bản sao (mà không dùng đến việc chuyển đổi sang JSON, không hiệu quả và hacky)

var newArr = _.filter(oldArr, function (element, index) {
    // tests if the element has a duplicate in the rest of the array
    for(index += 1; index < oldArr.length; index += 1) {
        if (_.isEqual(element, oldArr[index])) {
            return false;
        }
    }
    return true;
});

Nó lọc ra tất cả các phần tử nếu chúng có một bản sao sau này trong mảng - sao cho phần tử trùng lặp cuối cùng được giữ lại.

Việc kiểm tra các mục đích sử dụng trùng lặp _.isEqualthực hiện so sánh sâu được tối ưu hóa giữa hai đối tượng, xem tài liệu isEqual gạch dưới để biết thêm thông tin.

chỉnh sửa: cập nhật để sử dụng _.filterđó là một cách tiếp cận sạch hơn

Các tài liệu lodash 4.6.1 có ví dụ này cho sự bằng nhau của khóa đối tượng:

_.uniqWith(objects, _.isEqual);

https://lodash.com/docs#uniqWith

Hãy thử chức năng lặp

Ví dụ: bạn có thể trả về phần tử đầu tiên

x = [['a',1],['b',2],['a',1]]

_.uniq(x,false,function(i){  

   return i[0]   //'a','b'

})

=> [['a', 1], ['b', 2]]

đây là giải pháp của tôi (coffeescript):

_.mixin
  deepUniq: (coll) ->
    result = []
    remove_first_el_duplicates = (coll2) ->

      rest = _.rest(coll2)
      first = _.first(coll2)
      result.push first
      equalsFirst = (el) -> _.isEqual(el,first)

      newColl = _.reject rest, equalsFirst

      unless _.isEmpty newColl
        remove_first_el_duplicates newColl

    remove_first_el_duplicates(coll)
    result

thí dụ:

_.deepUniq([ {a:1,b:12}, [ 2, 1, 2, 1 ], [ 1, 2, 1, 2 ],[ 2, 1, 2, 1 ], {a:1,b:12} ]) 
//=> [ { a: 1, b: 12 }, [ 2, 1, 2, 1 ], [ 1, 2, 1, 2 ] ]

với dấu gạch dưới, tôi đã phải sử dụng String () trong hàm iteratee

function isUniq(item) {
    return String(item.user);
}
var myUniqArray = _.uniq(myArray, isUniq);

Tôi muốn giải quyết giải pháp đơn giản này bằng cách viết đơn giản, với một chút đau đớn về chi phí tính toán ... nhưng đó không phải là một giải pháp tầm thường với định nghĩa biến tối thiểu, phải không?

function uniq(ArrayObjects){
  var out = []
  ArrayObjects.map(obj => {
    if(_.every(out, outobj => !_.isEqual(obj, outobj))) out.push(obj)
  })
  return out
}

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];
var bar = _.map(_.groupBy(foo, function (f) { 
        return JSON.stringify(f); 
    }), function (gr) { 
        return gr[0]; 
    }
);

Hãy phá vỡ điều này. Đầu tiên cho phép nhóm các mục mảng theo giá trị được xâu chuỗi của chúng

var grouped = _.groupBy(foo, function (f) { 
    return JSON.stringify(f); 
});

grouped giống như:

{
    '{ "a" : "1" }' = [ { "a" : "1" } { "a" : "1" } ],
    '{ "b" : "2" }' = [ { "b" : "2" } ]
}

Sau đó, hãy lấy phần tử đầu tiên từ mỗi nhóm

var bar = _.map(grouped, function(gr)
    return gr[0]; 
});

bar giống như: [ { "a" : "1" }, { "b" : "2" } ]

Đặt nó tất cả cùng nhau:

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];
var bar = _.map(_.groupBy(foo, function (f) { 
        return JSON.stringify(f); 
    }), function (gr) { 
        return gr[0]; 
    }
);

Bạn có thể làm điều đó trong một tốc ký như:

_.uniq(foo, 'a')