我试图找出一种有效的方法来从数组中删除重复的对象并寻找最有效的答案。我环顾互联网，一切似乎都在使用原始数据...或者不能扩展到大型数组。这是我目前的实现，可以改进，并希望尝试避免标签。
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请不要libs。
回答：
答案 0 :(得分：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];
}
更新以包含保罗的评论。谢谢！的
答案 1 :(得分：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");
答案 2 :(得分：2)
基本排序 - 然后是唯一的实现，小提琴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.log，因此您可以看到它的工作原理。
修改
为了节省使用该函数的空间，我在最后做了for循环，但似乎没有正确找到唯一的结果（depsite它通过我的简单的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;
答案 3 :(得分：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，＆＃34;＆＃34;，＆＃34;＆＃34;，＆＃34;＆＃34;， ＆＃34;＆＃34;，＆＃34; a＆＃34;，＆＃34; b＆＃34;]; console.log（unique（ar））; //这将生成[1,2,3，＆＃34;＆＃34;，＆＃34; a＆＃34;，＆＃34; b＆＃34;]全部独特的元素。
答案 4 :(得分：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)
答案 5 :(得分：0)
下面的代码将对象与JSON作为String格式进行比较，并删除重复项，并且可以使用简单的数组。
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
})
答案 6 :(得分：0)
如果您使用下划线js，则很容易删除重复的对象。 http://underscorejs.org/#uniq
答案 7 :(得分：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;
}
答案 8 :(得分：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)
以上示例仅适用于唯一的title或id。基本上，它会为标题重复的歌曲创建新的地图。