我有一个非常简单的JavaScript数组,可能包含也可能不包含重复项。
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
我需要删除重复项并将唯一值放入新数组。
我可以指出我尝试过的所有代码,但我认为它们没有用,因为它们不起作用。我也接受jQuery解决方案。
类似的问题:
获取数组中的所有非唯一值(即:重复/多次出现)
我有一个非常简单的JavaScript数组,可能包含也可能不包含重复项。
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
我需要删除重复项并将唯一值放入新数组。
我可以指出我尝试过的所有代码,但我认为它们没有用,因为它们不起作用。我也接受jQuery解决方案。
类似的问题:
获取数组中的所有非唯一值(即:重复/多次出现)
当前回答
因此,选项如下:
let a = [11,22,11,22];
let b = []
b = [ ...new Set(a) ];
// b = [11, 22]
b = Array.from( new Set(a))
// b = [11, 22]
b = a.filter((val,i)=>{
return a.indexOf(val)==i
})
// b = [11, 22]
其他回答
下面的测试比列出的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
for (i=0; i<originalArray.length; i++) {
if (!newArray.includes(originalArray[i])) {
newArray.push(originalArray[i]);
}
}
ES2015,1-liner,它与map链接良好,但仅适用于整数:
[1, 4, 1].sort().filter((current, next) => current !== next)
[1, 4]
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”会发生什么?为什么
使用array.filter和.indexOf函数的单行版本:
arr = arr.filter(function (value, index, array) {
return array.indexOf(value) === index;
});