我有一个非常简单的JavaScript数组,可能包含也可能不包含重复项。
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
我需要删除重复项并将唯一值放入新数组。
我可以指出我尝试过的所有代码,但我认为它们没有用,因为它们不起作用。我也接受jQuery解决方案。
类似的问题:
获取数组中的所有非唯一值(即:重复/多次出现)
我有一个非常简单的JavaScript数组,可能包含也可能不包含重复项。
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
我需要删除重复项并将唯一值放入新数组。
我可以指出我尝试过的所有代码,但我认为它们没有用,因为它们不起作用。我也接受jQuery解决方案。
类似的问题:
获取数组中的所有非唯一值(即:重复/多次出现)
当前回答
厌倦了使用for循环或jQuery的所有糟糕示例。Javascript现在有了完美的工具:排序、映射和减少。
统一减少,同时保持现有订单
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
var uniq = names.reduce(function(a,b){
if (a.indexOf(b) < 0 ) a.push(b);
return a;
},[]);
console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
// one liner
return names.reduce(function(a,b){if(a.indexOf(b)<0)a.push(b);return a;},[]);
排序更快的uniq
可能有更快的方法,但这一方法相当不错。
var uniq = names.slice() // slice makes copy of array before sorting it
.sort(function(a,b){
return a > b;
})
.reduce(function(a,b){
if (a.slice(-1)[0] !== b) a.push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
return a;
},[]); // this empty array becomes the starting value for a
// one liner
return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.push(b);return a;},[]);
2015年更新:ES6版本:
在ES6中,您有集合和排列,这使删除所有重复项变得非常容易和高效:
var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
根据发生情况排序:
有人询问如何根据有多少个唯一名称来排序结果:
var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']
var uniq = names
.map((name) => {
return {count: 1, name: name}
})
.reduce((a, b) => {
a[b.name] = (a[b.name] || 0) + b.count
return a
}, {})
var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])
console.log(sorted)
其他回答
这里非常简单,可以在任何地方(甚至在PhotoshopScript中)理解和工作代码。检查一下!
var peoplenames = new Array("Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl");
peoplenames = unique(peoplenames);
alert(peoplenames);
function unique(array){
var len = array.length;
for(var i = 0; i < len; i++) for(var j = i + 1; j < len; j++)
if(array[j] == array[i]){
array.splice(j,1);
j--;
len--;
}
return array;
}
//*result* peoplenames == ["Mike","Matt","Nancy","Adam","Jenny","Carl"]
下面的测试比列出的jQuery方法快80%以上(请参见下面的测试)。这是几年前一个类似问题的答案。如果我遇到最初提出这个建议的人,我会记下学分。纯JS。
var temp = {};
for (var i = 0; i < array.length; i++)
temp[array[i]] = true;
var r = [];
for (var k in temp)
r.push(k);
return r;
我的测试用例比较:http://jsperf.com/remove-duplicate-array-tests
TL;博士
使用Set构造函数和排列语法:
uniq = [...new Set(array)];
(注意var uniq将是一个数组…new Set()将其转换为一个集合,但[…]将其再次转换为数组)
“聪明”但幼稚的方式
uniqueArray = a.filter(function(item, pos) {
return a.indexOf(item) == pos;
})
基本上,我们遍历数组,并检查每个元素在数组中的第一个位置是否等于当前位置。显然,对于重复的元素,这两个位置是不同的。
使用过滤器回调的第三个(“this array”)参数,我们可以避免数组变量的关闭:
uniqueArray = a.filter(function(item, pos, self) {
return self.indexOf(item) == pos;
})
虽然简洁,但该算法对于大型阵列(二次时间)不是特别有效。
拯救的桥段
function uniq(a) {
var seen = {};
return a.filter(function(item) {
return seen.hasOwnProperty(item) ? false : (seen[item] = true);
});
}
通常是这样做的。其想法是将每个元素放置在哈希表中,然后立即检查其是否存在。这给了我们线性时间,但至少有两个缺点:
由于哈希键在JavaScript中只能是字符串或符号,因此该代码不区分数字和“数字字符串”。也就是说,uniq([1,“1”])将只返回[1]出于同样的原因,所有对象都将被视为相等:uniq(〔{foo:1},{foo:2}〕)将只返回〔{foo:1}〕。
也就是说,如果数组只包含基元,而不关心类型(例如,总是数字),那么这个解决方案是最佳的。
两个世界中最好的
通用解决方案结合了这两种方法:它使用哈希查找原语和线性搜索对象。
function uniq(a) {
var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];
return a.filter(function(item) {
var type = typeof item;
if(type in prims)
return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
else
return objs.indexOf(item) >= 0 ? false : objs.push(item);
});
}
排序| uniq
另一个选项是先对数组进行排序,然后删除与前一个元素相等的每个元素:
function uniq(a) {
return a.sort().filter(function(item, pos, ary) {
return !pos || item != ary[pos - 1];
});
}
同样,这不适用于对象(因为排序时所有对象都是相等的)。此外,我们默默地改变了原始数组,这是一个副作用——不好!然而,如果您的输入已经排序,这就是方法(只需从上面删除排序)。
唯一依据。。。
有时需要根据一些标准而不仅仅是相等来取消列表的限定,例如,过滤出不同但共享某些属性的对象。这可以通过传递回调来实现。此“key”回调应用于每个元素,并删除具有相等“key”的元素。由于键需要返回一个原语,所以哈希表在这里可以正常工作:
function uniqBy(a, key) {
var seen = {};
return a.filter(function(item) {
var k = key(item);
return seen.hasOwnProperty(k) ? false : (seen[k] = true);
})
}
一个特别有用的键()是JSON.stringify,它将删除物理上不同但“看起来”相同的对象:
a = [[1,2,3], [4,5,6], [1,2,3]]
b = uniqBy(a, JSON.stringify)
console.log(b) // [[1,2,3], [4,5,6]]
如果密钥不是原始的,则必须使用线性搜索:
function uniqBy(a, key) {
var index = [];
return a.filter(function (item) {
var k = key(item);
return index.indexOf(k) >= 0 ? false : index.push(k);
});
}
在ES6中,您可以使用集合:
function uniqBy(a, key) {
let seen = new Set();
return a.filter(item => {
let k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
或地图:
function uniqBy(a, key) {
return [
...new Map(
a.map(x => [key(x), x])
).values()
]
}
这两个键也可以使用非基本键。
第一个还是最后一个?
通过键删除对象时,可能需要保留“相等”对象中的第一个或最后一个。
使用上面的Set变量保留第一个,使用Map保留最后一个:
函数uniqByKeepFirst(a,key){let seen=new Set();返回a.filter(项=>{设k=密钥(项);看见了吗?false:见。添加(k);});}函数uniqByKeepLast(a,key){返回[…新建地图(a.map(x=>[键(x),x])).values()]}//数据=[{a:1,u:1},{a:2,u:2},{a:3,u:3},{a:4,u:1},{a:5,u:2},{a:6,u:3},];console.log(uniqByKeepFirst(data,it=>it.u))console.log(uniqByKeepLast(data,it=>it.u))
图书馆
下划线和Lo Dash都提供uniq方法。他们的算法基本上类似于上面的第一段,归结起来就是:
var result = [];
a.forEach(function(item) {
if(result.indexOf(item) < 0) {
result.push(item);
}
});
这是二次的,但还有一些很好的附加好处,比如包装原生indexOf,通过键进行uniqify(用他们的话说是迭代)的能力,以及对已排序数组的优化。
如果您正在使用jQuery,并且无法忍受前面没有一美元的任何东西,则情况如下:
$.uniqArray = function(a) {
return $.grep(a, function(item, pos) {
return $.inArray(item, a) === pos;
});
}
这也是第一片段的变体。
表演
JavaScript中的函数调用非常昂贵,因此上述解决方案虽然简洁,但效率并不高。为了获得最大的性能,用循环替换过滤器,并消除其他函数调用:
function uniq_fast(a) {
var seen = {};
var out = [];
var len = a.length;
var j = 0;
for(var i = 0; i < len; i++) {
var item = a[i];
if(seen[item] !== 1) {
seen[item] = 1;
out[j++] = item;
}
}
return out;
}
这段丑陋的代码与上面的第3段代码相同,但速度快了一个数量级(截至2017年,速度只有两倍-JS核心人员做得很好!)
函数uniq(a){var seen={};return a.filter(函数(项){返回已查看。hasOwnProperty(项)?假:(见[项目]=真);});}函数uniq_fast(a){var seen={};var out=[];var len=a.length;变量j=0;对于(var i=0;i<len;i++){var项目=a[i];if(参见[项目]!==1){见[项目]=1;out[j++]=项目;}}返回;}/////变量r=[0,1,2,3,4,5,6,7,8,9],a=[],LEN=1000,回路=1000;而(LEN-)a=交流电(r);var d=新日期();对于(var i=0;i<回路;i++)uniq(a);document.write('<br>uniq,ms/loop:'+(new Date()-d)/LOOPS)var d=新日期();对于(var i=0;i<回路;i++)uniq_fast(a);document.write('<br>uniq_fast,ms/loop:'+(new Date()-d)/LOOPS)
ES6
ES6提供了Set对象,这使事情变得更加简单:
function uniq(a) {
return Array.from(new Set(a));
}
or
let uniq = a => [...new Set(a)];
注意,与python不同,ES6集合是按插入顺序迭代的,因此这段代码保留了原始数组的顺序。
然而,如果您需要具有唯一元素的数组,为什么不从一开始就使用集合呢?
发电机
可以在相同的基础上构建uniq的“懒惰”、基于生成器的版本:
从参数中获取下一个值如果已经看到了,就跳过它否则,生成它并将其添加到已看到的值集合中
函数*uniqIter(a){let seen=new Set();for(设a的x){如果(!seed.has(x)){见添加(x);产量x;}}}//示例:函数*randomsBelow(极限){而(1)yield Math.floor(Math.random()*limit);}//注意randomsBelow是无穷无尽的计数=20;极限=30;for(uniqIter(randomsBelow(limit))的let r){控制台日志(r);如果(--count==0)打破}//读者练习:如果我们将“limit”设置为小于“count”会发生什么?为什么
var uniqueCompnies = function(companyArray) {
var arrayUniqueCompnies = [],
found, x, y;
for (x = 0; x < companyArray.length; x++) {
found = undefined;
for (y = 0; y < arrayUniqueCompnies.length; y++) {
if (companyArray[x] === arrayUniqueCompnies[y]) {
found = true;
break;
}
}
if ( ! found) {
arrayUniqueCompnies.push(companyArray[x]);
}
}
return arrayUniqueCompnies;
}
var arr = [
"Adobe Systems Incorporated",
"IBX",
"IBX",
"BlackRock, Inc.",
"BlackRock, Inc.",
];
这可能是从阵列中永久删除重复项的最快方法之一比这里的大多数功能快10倍。&狩猎速度快78倍
function toUnique(a,b,c){ //array,placeholder,placeholder
b=a.length;while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1)
}
测试:http://jsperf.com/wgu演示:http://jsfiddle.net/46S7g/更多信息:https://stackoverflow.com/a/25082874/2450730
如果你看不懂上面的代码,请看一本javascript书,或者这里有一些关于较短代码的解释。https://stackoverflow.com/a/21353032/2450730