19

我试图找出一种有效的方法来从数组中删除重复的对象并寻找最有效的答案。我环顾互联网，一切似乎都在使用原始数据……或者对于大型阵列来说不可扩展。这是我当前的实现，可以改进并且想尽量避免标签。

 Test.prototype.unique = function (arr, artist, title, cb) {
        console.log(arr.length);
        var n, y, x, i, r;
        r = [];      
        o: for (i = 0, n = arr.length; i < n; i++) {

          for (x = 0, y = r.length; x < y; x++) {

                if (r[x].artist == arr[i].artist && r[x].title == arr[i].title) {
                    continue o;
                }
            }
            r.push(arr[i]);
        }

        cb(r);
    };

数组看起来像这样：

[{title: sky, artist: jon}, {title: rain, artist: Paul}, ....]

顺序无关紧要，但如果排序使它更有效，那么我准备迎接挑战......

对于不知道 o 是标签的人来说，它只是说跳回循环而不是推送到新数组。

纯 javascript 请不要使用库。

到目前为止的答案：

以下答案的性能测试：http: //jsperf.com/remove-duplicates-for-loops

4

9 回答 9

30

我明白了，问题在于复杂性是平方的。有一个技巧可以做到这一点，它只是通过使用“关联数组”。

您可以获取数组，对其进行循环，并将数组的值作为键添加到关联数组中。由于它不允许重复键，因此您将自动摆脱重复键。

由于您在比较时正在寻找标题和艺术家，因此您实际上可以尝试使用以下内容：

var arrResult = {};
for (i = 0, n = arr.length; i < n; i++) {
    var item = arr[i];
    arrResult[ item.title + " - " + item.artist ] = item;
}

然后你只需再次循环 arrResult，并重新创建数组。

var i = 0;
var nonDuplicatedArray = [];    
for(var item in arrResult) {
    nonDuplicatedArray[i++] = arrResult[item];
}

更新以包括保罗的评论。谢谢！

于 2013-10-21T18:07:08.573 回答
3

这是一个适合我的解决方案。

辅助功能：

// sorts an array of objects according to one field
// call like this: sortObjArray(myArray, "name" );
// it will modify the input array
sortObjArray = function(arr, field) {
    arr.sort(
        function compare(a,b) {
            if (a[field] < b[field])
                return -1;
            if (a[field] > b[field])
                return 1;
            return 0;
        }
    );
}

// call like this: uniqueDishes = removeDuplicatesFromObjArray(dishes, "dishName");
// it will NOT modify the input array
// input array MUST be sorted by the same field (asc or desc doesn't matter)
removeDuplicatesFromObjArray = function(arr, field) {
    var u = [];
    arr.reduce(function (a, b) {
        if (a[field] !== b[field]) u.push(b);
        return b;
    }, []);
    return u;
}

然后简单地调用：

        sortObjArray(dishes, "name");
        dishes = removeDuplicatesFromObjArray(dishes, "name");
于 2015-09-25T13:23:14.770 回答
2

基本的 sort-then-unique 实现，小提琴HERE：

function unique(arr) {
    var comparer = function compareObject(a, b) {
        if (a.title == b.title) {
            if (a.artist < b.artist) {
                return -1;
            } else if (a.artist > b.artist) {
                return 1;
            } else {
                return 0;
            }
        } else {
            if (a.title < b.title) {
                return -1;
            } else {
                return 1;
            }
        }
    }

    arr.sort(comparer);
    console.log("Sorted: " + JSON.stringify(arr));
    for (var i = 0; i < arr.length - 1; ++i) {
        if (comparer(arr[i], arr[i+1]) === 0) {
            arr.splice(i, 1);
            console.log("Splicing: " + JSON.stringify(arr));
        }
    }
    return arr;
}

它可能是也可能不是最有效的，并且应该是完全可扩展的。我添加了一些console.logs，以便您可以看到它的工作原理。

编辑

为了节省函数使用的空间，我最后做了那个for循环，但似乎没有正确找到唯一的结果（尽管它通过了我的简单 jsfiddle 测试）。请尝试用for以下内容替换我的循环：

var checker;
var uniqueResults = [];
for (var i = 0; i < arr.length; ++i) {
    if (!checker || comparer(checker, arr[i]) != 0) {
        checker = arr[i];
        uniqueResults.push(checker);
    }
}
return uniqueResults;
于 2013-10-21T18:25:18.550 回答
1

我使用这个功能。它不做任何排序，但会产生结果。不能说性能，因为从不衡量它。

var unique = function(a){
    var seen = [], result = [];
    for(var len = a.length, i = len-1; i >= 0; i--){
        if(!seen[a[i]]){
            seen[a[i]] = true;
            result.push(a[i]);
        }
    }
    return result;
}

var ar = [1,2,3,1,1,1,1,1,"", "","","", "a", "b"]; console.log(unique(ar));// 这将产生 [1,2,3,"", "a", "b"] 所有唯一元素。

于 2015-03-03T14:15:36.067 回答
1

以下是 Henrique Feijo 的回答，其中有充分的解释和一个可以剪切和粘贴的示例：

目标：转换包含重复对象的对象数组（如这个）...

[
    {
        "id": 10620,
        "name": "Things to Print"
    },
    {
        "id": 10620,
        "name": "Things to Print"
    },
    {
        "id": 4334,
        "name": "Interesting"
    }
]

...进入一个没有重复对象的对象数组（比如这个）：

[
    {
        "id": 10620,
        "name": "Things to Print"
    },
    {
        "id": 4334,
        "name": "Interesting"
    }
]

评论中提供的解释：

    var allContent = [{
      "id": 10620,
      "name": "Things to Print"
    }, {
      "id": 10620,
      "name": "Things to Print"
    }, {
      "id": 4334,
      "name": "Interesting"
    }]

     //Put Objects Into As Associative Array. Each key consists of a composite value generated by each set of values from the objects in allContent.
    var noDupeObj = {} //Create an associative array. It will not accept duplicate keys.
    for (i = 0, n = allContent.length; i < n; i++) {
      var item = allContent[i]; //Store each object as a variable. This helps with clarity in the next line.
      noDupeObj[item.id + "|" + item.name] = item; //This is the critical step.
      //Here, you create an object within the associative array that has a key composed of the two values from the original object. 
      // Use a delimiter to not have foo+bar handled like fo+obar
      //Since the associative array will not allow duplicate keys, and the keys are determined by the content, then all duplicate content are removed. 
      //The value assigned to each key is the original object which is along for the ride and used to reconstruct the list in the next step.
    }

     //Recontructs the list with only the unique objects left in the doDupeObj associative array
    var i = 0;
    var nonDuplicatedArray = [];
    for (var item in noDupeObj) {
      nonDuplicatedArray[i++] = noDupeObj[item]; //Populate the array with the values from the noDupeObj.
    }

    console.log(nonDuplicatedArray)

于 2016-06-22T23:02:21.253 回答
0

下面的代码将对象与 JSON 作为字符串格式进行比较，并删除重复项，并与简单数组一起正常工作。

    Array.prototype.unique=function(a){
     return function(){
        return this.filter(a)
     }
   }(
   function(a,b,c){
     var tmp=[]; 
     c.forEach(function(el){
        tmp.push(JSON.stringify(el))
    }); 
    return tmp.indexOf(JSON.stringify(a),b+1)<0
  })
于 2014-07-05T09:27:48.683 回答
0

如果您使用的是下划线 js，则很容易删除重复的对象。 http://underscorejs.org/#uniq

于 2015-03-01T19:05:52.543 回答
0 
function remove_duplicates(objectsArray) {
    var arr = [], collection = []; 
    $.each(objectsArray, function (index, value) {
        if ($.inArray(value.id, arr) == -1) { 
            arr.push(value.id);
            collection.push(value);
        }
    });
    return collection;
}
于 2015-07-24T12:35:30.043 回答
0

对于那些喜欢 ES6 和简短的东西的人来说，这是一个解决方案：

const arr = [
  { title: "sky", artist: "Jon" },
  { title: "rain", artist: "Paul" },
  { title: "sky", artist: "Jon" }
];

Array.from(arr.reduce((a, o) => a.set(o.title, o), new Map()).values());


const arr = [
  { title: "sky", artist: "Jon" },
  { title: "rain", artist: "Paul" },
  { title: "sky", artist: "Jon" },
  { title: "rain", artist: "Jon" },
  { title: "cry", artist: "Jon" }
];

const unique = Array.from(arr.reduce((a, o) => a.set(o.title, o), new Map()).values());

console.log(`New array length: ${unique.length}`)

console.log(unique)

上面的示例仅适用于唯一的titleor id。基本上，它为具有重复标题的歌曲创建了一个新地图。

于 2019-09-03T16:59:11.150 回答