小开

最佳答案

您可以对数组进行排序，然后遍历它，然后查看下一个(或上一个)索引是否与当前索引相同。假设你的排序算法是好的，这应该小于O(n²):

const findDuplicates = (arr) => {
let sorted_arr = arr.slice().sort(); // You can define the comparing function here.
// JS by default uses a crappy string compare.
// (we use slice to clone the array so the
// original array won't be modified)
let results = [];
for (let i = 0; i < sorted_arr.length - 1; i++) {
if (sorted_arr[i + 1] == sorted_arr[i]) {
results.push(sorted_arr[i]);
}
}
return results;
}


let duplicatedArray = [9, 9, 111, 2, 3, 4, 4, 5, 7];
console.log(`The duplicates in ${duplicatedArray} are ${findDuplicates(duplicatedArray)}`);

在这种情况下，如果你要返回一个重复的函数。这是为类似类型的情况。

参考:https://stackoverflow.com/a/57532964/8119511

小开

Prototype库有一个uniq函数，它返回不包含dupes的数组。但这只是工作的一半。

小开

你可以添加这个函数，或者调整它并将其添加到Javascript的数组原型中:

Array.prototype.unique = function () {
var r = new Array();
o:for(var i = 0, n = this.length; i < n; i++)
{
for(var x = 0, y = r.length; x < y; x++)
{
if(r[x]==this[i])
{
alert('this is a DUPE!');
continue o;
}
}
r[r.length] = this[i];
}
return r;
}


var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);

小开

如果你想消除重复，试试这个好方法:

function eliminateDuplicates(arr) {
var i,
len = arr.length,
out = [],
obj = {};


for (i = 0; i < len; i++) {
obj[arr[i]] = 0;
}
for (i in obj) {
out.push(i);
}
return out;
}


console.log(eliminateDuplicates([1,6,7,3,6,8,1,3,4,5,1,7,2,6]))

来源: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/

小开

这应该能得到你想要的，只是副本。

function find_duplicates(arr) {
var len=arr.length,
out=[],
counts={};


for (var i=0;i<len;i++) {
var item = arr[i];
counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
if (counts[item] === 2) {
out.push(item);
}
}


return out;
}


find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.

小开

只是在上面的基础上补充一些理论。

在比较模型中，查找重复项的下界为O(n*log(n))。所以理论上，你不能做得比先排序然后再进行

.

. 如果你想在线性(O(n)) 预期时间内找到重复项，你可以哈希列表的每个元素;如果有冲突，删除/标记为重复，并继续。

小开

下面的函数(前面提到的eliminateduplates函数的变体)似乎可以做到这一点，它为输入["test"， "test2"， "test2"， 1,1,2,3,4,5,6,7,7,10,22,43,1,5,5,8]返回test2,1,7,7,8]。

请注意，这个问题在JavaScript中比在大多数其他语言中更奇怪，因为JavaScript数组几乎可以容纳任何东西。注意，使用排序的解决方案可能需要提供适当的排序函数——我还没有尝试过这种方法。

这个特殊的实现(至少)适用于字符串和数字。

function findDuplicates(arr) {
var i,
len=arr.length,
out=[],
obj={};


for (i=0;i<len;i++) {
if (obj[arr[i]] != null) {
if (!obj[arr[i]]) {
out.push(arr[i]);
obj[arr[i]] = 1;
}
} else {
obj[arr[i]] = 0;
}
}
return out;
}

小开

/ * Array对象的indexOf方法用于比较数组项。 IE是唯一一个原生不支持它的主流浏览器，但它很容易实现: * /

Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
i= i || 0;
var L= this.length;
while(i<L){
if(this[i]=== what) return i;
++i;
}
return -1;
}


function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1 && dups.indexOf(itm)== -1){
dups[dups.length]= itm;
}
}
return dups;
}

var a1 =[1, 22岁,3、2、2、3、3、4、1、22日7,8,9);

警报(getarrayduplicates (a1));

对于非常大的数组，可以更快地从数组中删除找到的重复项，这样就不会再次查看它们:

function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1){
dups[dups.length]= itm;
while(A.indexOf(itm)!= -1){
A.splice(A.indexOf(itm), 1);
}
}
}
return dups;
}

小开

从3个数组(或更多)中查找非唯一值:

ES2015

//          🚩🚩  🚩   🚩             🚩
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
arr2 = [1,2,511,12,50],
arr3 = [22,0],
merged,
nonUnique;


// Combine all the arrays to a single one
merged = arr.concat(arr2, arr3)


// create a new (dirty) Array with only the non-unique items
nonUnique = merged.filter((item,i) => merged.includes(item, i+1))


// Cleanup - remove duplicate & empty items items
nonUnique = [...new Set(nonUnique)]


console.log(nonUnique)

PRE-ES2015:

在下面的例子中，我选择在Array 原型之上叠加一个unique方法，允许从任何地方访问，并且有更多的“declarative"语法。我不建议在大型项目中使用这种方法，因为它很可能与另一个具有相同自定义名称的方法发生冲突。

Array.prototype.unique = function () {
var arr = this.sort(), i=arr.length; // input must be sorted for this to work
while(i--)
arr[i] === arr[i-1] && arr.splice(i,1) // remove duplicate item
return arr
}


Array.prototype.nonunique = function () {
var arr = this.sort(), i=arr.length, res = []; // input must be sorted for this to work
while(i--)
arr[i] === arr[i-1] && (res.indexOf(arr[i]) == -1) && res.push(arr[i])
return res
}


//          🚩🚩  🚩    🚩            🚩
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
arr2 = [1,2,511,12,50],
arr3 = [22,0],
// merge all arrays & call custom Array Prototype - "unique"
unique = arr.concat(arr2, arr3).unique(),
nonunique = arr.concat(arr2, arr3).nonunique()


console.log(unique)     // [1,12,2,22,3,4,5,50,511,6,7,8]
console.log(nonunique)  // [1,12,2,22,3,4,5,50,511,6,7,8]

小开

从Raphael Montanaro的回答，它可以改进使用数组/对象项如下。

function eliminateDuplicates(arr) {
var len = arr.length,
out = [],
obj = {};


for (var key, i=0; i < len; i++) {
key = JSON.stringify(arr[i]);
obj[key] = (obj[key]) ? obj[key] + 1 : 1;
}
for (var key in obj) {
out.push(JSON.parse(key));
}
return [out, obj];
}

注意:对于不支持JSON的浏览器，需要使用JSON库。

小开

下面是一个没有使用临时数组来存储非重复的数组:

// simple duplicate removal for non-object types
Array.prototype.removeSimpleDupes = function() {
var i, cntr = 0, arr = this, len = arr.length;


var uniqueVal = function(val,n,len) { // remove duplicates
var dupe = false;
for (i = n; i < len; i++) {
if (typeof arr[i]!=="undefined" && val===arr[i]) { arr.splice(i,1); dupe = true; }
}
return (dupe) ? arr.length : len;
};


while (cntr < len) {
len = uniqueVal(arr[cntr],cntr+1,len);
cntr++;
}


return arr;
};

小开

我更喜欢函数法。

function removeDuplicates(links) {
return _.reduce(links, function(list, elem) {
if (list.indexOf(elem) == -1) {
list.push(elem);
}
return list;
}, []);
}

它使用下划线，但Array也有reduce函数

小开

http://jsfiddle.net/vol7ron/gfJ28/

var arr  = ['hello','goodbye','foo','hello','foo','bar',1,2,3,4,5,6,7,8,9,0,1,2,3];
var hash = [];


// build hash
for (var n=arr.length; n--; ){
if (typeof hash[arr[n]] === 'undefined') hash[arr[n]] = [];
hash[arr[n]].push(n);
}




// work with compiled hash (not necessary)
var duplicates = [];
for (var key in hash){
if (hash.hasOwnProperty(key) && hash[key].length > 1){
duplicates.push(key);
}
}
alert(duplicates);

结果将是hash数组，它将包含一组唯一的值和这些值的位置。因此，如果有2个或更多的位置，我们可以确定该值有一个重复的值。因此，每一个hash[<value>].length > 1的位置都表示一个副本。

hash['hello']将返回[0,3]，因为在arr[]的节点0和3中发现了'hello'。

注意: [0,3]的长度是用来确定它是否是一个重复的。
使用for(var key in hash){ if (hash.hasOwnProperty(key)){ alert(key); } }将提醒每个唯一的值。

小开

var a = [324,3,32,5,52,2100,1,20,2,3,3,2,2,2,1,1,1].sort();
a.filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});

或者当添加到原型时。阵列链

//copy and paste: without error handling
Array.prototype.unique =
function(){return this.sort().filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});}

看这里:https://gist.github.com/1305056

小开

更新:以下使用一个优化的组合策略。它优化了原语查找，以受益于散列O(1)查找时间(在原语数组上运行unique是O(n))。对象查找通过在遍历对象时用唯一id标记对象来优化，因此识别重复对象也是每个项目O(1)，整个列表O(n)。唯一的例外是被冻结的项目，但这种情况很少见，并且使用数组和indexOf提供了一个回退。

var unique = function(){
var hasOwn = {}.hasOwnProperty,
toString = {}.toString,
uids = {};


function uid(){
var key = Math.random().toString(36).slice(2);
return key in uids ? uid() : uids[key] = key;
}


function unique(array){
var strings = {}, numbers = {}, others = {},
tagged = [], failed = [],
count = 0, i = array.length,
item, type;


var id = uid();


while (i--) {
item = array[i];
type = typeof item;
if (item == null || type !== 'object' && type !== 'function') {
// primitive
switch (type) {
case 'string': strings[item] = true; break;
case 'number': numbers[item] = true; break;
default: others[item] = item; break;
}
} else {
// object
if (!hasOwn.call(item, id)) {
try {
item[id] = true;
tagged[count++] = item;
} catch (e){
if (failed.indexOf(item) === -1)
failed[failed.length] = item;
}
}
}
}


// remove the tags
while (count--)
delete tagged[count][id];


tagged = tagged.concat(failed);
count = tagged.length;


// append primitives to results
for (i in strings)
if (hasOwn.call(strings, i))
tagged[count++] = i;


for (i in numbers)
if (hasOwn.call(numbers, i))
tagged[count++] = +i;


for (i in others)
if (hasOwn.call(others, i))
tagged[count++] = others[i];


return tagged;
}


return unique;
}();

如果你有ES6集合可用，那么有一个更简单、更快的版本。(shim for IE9+和其他浏览器:https://github.com/Benvie/ES6-Harmony-Collections-Shim)

function unique(array){
var seen = new Set;
return array.filter(function(item){
if (!seen.has(item)) {
seen.add(item);
return true;
}
});
}

小开

function remove_dups(arrayName){
var newArray = new Array();


label:for(var i=0; i<arrayName.length; i++ ){


for(var j=0; j<newArray.length;j++ ){
if(newArray[j]==arrayName[i]){
continue label;
}
}


newArray[newArray.length] = arrayName[i];


}


return newArray;
}

小开

在这篇文章是有用的重复检查，如果你正在使用Jquery。

如何使用jquery找到数组中的重复项

var unique_values = {}; var list_of_values = []; $('input[name$="recordset"]').     each(function(item) {          if ( ! unique_values[item.value] ) {             unique_values[item.value] = true;             list_of_values.push(item.value);         } else {             // We have duplicate values!         }     });

小开

仅ES5(即，它需要一个filter() polyfill用于IE8及以下):

var arrayToFilter = [ 4, 5, 5, 5, 2, 1, 3, 1, 1, 2, 1, 3 ];


arrayToFilter.
sort().
filter( function(me,i,arr){
return (i===0) || ( me !== arr[i-1] );
});

小开

使用underscore.js

function hasDuplicate(arr){
return (arr.length != _.uniq(arr).length);
}

小开

var input = ['a', 'b', 'a', 'c', 'c'],
duplicates = [],
i, j;
for (i = 0, j = input.length; i < j; i++) {
if (duplicates.indexOf(input[i]) === -1 && input.indexOf(input[i], i+1) !== -1) {
duplicates.push(input[i]);
}
}


console.log(duplicates);

小开

这是一个方法，以避免重复到javascript数组…它支持字符串和数字…

 var unique = function(origArr) {
var newArray = [],
origLen = origArr.length,
found,
x = 0; y = 0;


for ( x = 0; x < origLen; x++ ) {
found = undefined;
for ( y = 0; y < newArray.length; y++ ) {
if ( origArr[x] === newArray[y] ) found = true;
}
if ( !found) newArray.push( origArr[x] );
}
return newArray;
}

检查这个小提琴..

小开

我试图改善@swilliams的答案，这将返回一个没有重复的数组。

// arrays for testing
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];


// ascending order
var sorted_arr = arr.sort(function(a,b){return a-b;});


var arr_length = arr.length;
var results = [];
if(arr_length){
if(arr_length == 1){
results = arr;
}else{
for (var i = 0; i < arr.length - 1; i++) {
if (sorted_arr[i + 1] != sorted_arr[i]) {
results.push(sorted_arr[i]);
}
// for last element
if (i == arr.length - 2){
results.push(sorted_arr[i+1]);
}
}
}
}


alert(results);

小开

还有一种方法是使用下划线。Numbers是源数组，dupes可能有重复的值。

var itemcounts = _.countBy(numbers, function (n) { return n; });
var dupes = _.reduce(itemcounts, function (memo, item, idx) {
if (item > 1)
memo.push(idx);
return memo;
}, []);

小开

这里有一个非常简单的方法:

var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
if (codes.indexOf(codes[i]) != i) {
codes.splice(i,1);
}
}

小开

我认为下面是完成你要求的最简单和最快的O(n)方法:

function getDuplicates( arr ) {
var i, value;
var all = {};
var duplicates = [];


for( i=0; i<arr.length; i++ ) {
value = arr[i];
if( all[value] ) {
duplicates.push( value );
all[value] = false;
} else if( typeof all[value] == "undefined" ) {
all[value] = true;
}
}


return duplicates;
}

对于ES5或更高版本:

function getDuplicates( arr ) {
var all = {};
return arr.reduce(function( duplicates, value ) {
if( all[value] ) {
duplicates.push(value);
all[value] = false;
} else if( typeof all[value] == "undefined" ) {
all[value] = true;
}
return duplicates;
}, []);
}

小开

下面是使用sort()和JSON.stringify()实现的一个

https://gist.github.com/korczis/7598657

function removeDuplicates(vals) {
var res = [];
var tmp = vals.sort();


for (var i = 0; i < tmp.length; i++) {
res.push(tmp[i]);
while (JSON.stringify(tmp[i]) == JSON.stringify(tmp[i + 1])) {
i++;
}
}


return res;
}
console.log(removeDuplicates([1,2,3,4,5,4,3,3,2,1,]));

小开

奇怪的是没有人发布this solution。

<!DOCTYPE html>
<html>
<head>
<meta charset=utf-8 />
<title>
</title>
</head>
<body>
<script>
var list = [100,33,45,54,9,12,80,100];
var newObj = {};
var newArr = [];
for(var i=0; i<list.length; i++){
newObj[list[i]] = i;
}
for(var j in newObj){
newArr.push(j);
}
console.log(newArr);
</script>
</body>
</html>

小开

修改@RaphaelMontanaro的解决方案，借鉴@Nosredna的博客，如果你只想从数组中识别重复的元素，下面是你可以做的事情。

function identifyDuplicatesFromArray(arr) {
var i;
var len = arr.length;
var obj = {};
var duplicates = [];


for (i = 0; i < len; i++) {


if (!obj[arr[i]]) {


obj[arr[i]] = {};


}


else
{
duplicates.push(arr[i]);
}


}
return duplicates;
}

感谢你优雅的解决方案，@Nosredna!

小开

大多数答案我都不喜欢。

为什么?太复杂，代码太多，效率低下，许多代码没有回答问题，即找到重复项(而不是给出一个没有重复项的数组)。

Next函数返回所有副本:

function GetDuplicates(arr) {
var i, out=[], obj={};
for (i=0; i < arr.length; i++)
obj[arr[i]] == undefined ? obj[arr[i]] ++ : out.push(arr[i]);
return out;
}

因为在大多数情况下，返回所有重复值是没有用的，而只是告诉存在哪些重复值。在这种情况下，返回一个具有唯一重复项的数组;-)

function GetDuplicates(arr) {
var i, out=[], obj={};
for (i=0; i < arr.length; i++)
obj[arr[i]] == undefined ? obj[arr[i]] ++ : out.push(arr[i]);
return GetUnique(out);
}


function GetUnique(arr) {
return $.grep(arr, function(elem, index) {
return index == $.inArray(elem, arr);
});
}

也许其他人也这么想。

小开

这是我在重复线程(!)中的回答:

当写这个条目2014 -所有的例子都是for-loops或jQuery。JavaScript有完美的工具:sort， map和reduce。

找到重复的物品

var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']


const uniq = names
.map((name) => {
return {
count: 1,
name: name
};
})
.reduce((result, b) => {
result[b.name] = (result[b.name] || 0) + b.count;


return result;
}, {});
const duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1);


console.log(duplicates); // [ 'Nancy' ]

在数组中查找重复的值

这应该是在数组中找到重复值的最短方法之一。正如OP特别要求的那样，这不是删除重复项，而是查找重复项。

var input = [1, 2, 3, 1, 3, 1];


var duplicates = input.reduce(function(acc, el, i, arr) {
if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
}, []);


document.write(duplicates); // = 1,3 (actual array == [1, 3])

这不需要排序或任何第三方框架。它也不需要手动循环。它适用于indexOf ()(或更清楚地说:严格比较运算符)支持的所有值。

因为reduce ()和indexOf ()，它至少需要ie9。

小开

下面是一个简单的小片段，用于查找唯一的和重复的值，无需排序和两个循环。

.

var _unique = function (arr) {
var h = [], t = [];
arr.forEach(function (n) {
if (h.indexOf(n) == -1)
h.push(n);
else t.push(n);
});
return [h, t];
}
var result = _unique(["test",1,4,2,34,6,21,3,4,"test","prince","th",34]);
console.log("Has duplicate values : " + (result[1].length > 0))  //and you can check count of duplicate values
console.log(result[0]) //unique values
console.log(result[1]) //duplicate values

小开

使用“includes”测试元素是否已经存在。

var arr = [1, 1, 4, 5, 5], darr = [], duplicates = [];


for(var i = 0; i < arr.length; i++){
if(darr.includes(arr[i]) && !duplicates.includes(arr[i]))
duplicates.push(arr[i])
else
darr.push(arr[i]);
}


console.log(duplicates);

<h3>Array with duplicates</h3>
<p>[1, 1, 4, 5, 5]</p>
<h3>Array with distinct elements</h3>
<p>[1, 4, 5]</p>
<h3>duplicate values are</h3>
<p>[1, 5]</p>

小开

function GetDuplicates(arr) {
var i = 0, m = [];
return arr.filter(function (n) {
return !m[n] * ~arr.indexOf(n, m[n] = ++i);
});
}

小开

ES6提供了Set数据结构，它基本上是一个不接受重复的数组。使用Set数据结构，有一种非常简单的方法来查找数组中的重复项(只使用一个循环)

这是我的代码

function findDuplicate(arr) {
var set = new Set();
var duplicates = new Set();
for (let i = 0; i< arr.length; i++) {
var size = set.size;
set.add(arr[i]);
if (set.size === size) {
duplicates.add(arr[i]);
}
}
return duplicates;
}

小开

var a= [1, 2,2,3,3,4,4,4];
var m=[];
var n = [];
a.forEach(function(e) {
if(m.indexOf(e)=== -1) {
m.push(e);
}else if(n.indexOf(e)=== -1){
n.push(e);
}


});

小开

你可以使用下面的结构:

var arr = [1,2,3,4,5,6,7,8,9,0,5];
var duplicate = arr.filter(function(item, i, arr) {
return -1 !== arr.indexOf(item, i + 1);
})

小开

我觉得最简单的解决方案就是使用indexOf

仅将唯一元素推入数组的完整示例。

var arr = ['a','b','c','d','a','b','c','d'];
var newA = [];
for(var i = 0; i < arr.length; i++){
if(newA.indexOf(arr[i]) === -1){
newA.push(arr[i]);
}
}

小开

使用Pure Js

function arr(){
var a= [1,2,3,4,5,34,2,5,7,8,6,4,3,25,8,34,56,7,8,76,4,23,34,46,575,8564,53,5345657566];
var b= [];
b.push(a[0]);
var z=0;


for(var i=0; i< a.length; i++){
for(var j=0; j< b.length; j++){
if(b[j] == a[i]){
z = 0;
break;
}
else
z = 1;
}
if(z)
b.push(a[i]);
}
console.log(b);
}

小开

var isUnique = true;
for (var i= 0; i< targetItems.length; i++) {
var itemValue = $(targetItems[i]).val();
if (targetListValues.indexOf(itemValue) >= 0) {
isUnique = false;
break;
}
targetListValues.push(itemValue);
if (!isUnique) {
//raise any error msg
return false;
}
}

小开

使用ES6(或使用Babel或Typescipt)，你可以简单地做:

var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);

https://es6console.com/j58euhbt/

小开

最快的解决方法是用一面旗子

var values = [4,2,3,1,4]


// solution
const checkDuplicate = list => {
var hasDuplicate = false;
list.sort().sort((a, b) => {
if (a === b) hasDuplicate = true
})
return hasDuplicate
}


console.log(checkDuplicate(values))

小开

我刚刚想出了一个简单的方法来实现这一点，使用数组过滤器

    var list = [9, 9, 111, 2, 3, 4, 4, 5, 7];
    

// Filter 1: to find all duplicates elements
var duplicates = list.filter(function(value,index,self) {
return self.indexOf(value) !== self.lastIndexOf(value) && self.indexOf(value) === index;
});
    

console.log(duplicates);

小开

这也可以用Set()来解决。

Set中的一个值只能出现一次;在集合中是唯一的。

    Array.prototype.hasDuplicates = function () {
if (arr.length !== (new Set(arr).size)) {
return true;
}
return false;
}

IE中不完全支持注意:集合

小开

在这里，每个dupe只输出一次副本。

var arr = [9, 9, 9, 9, 111, 2, 3, 4, 4, 5, 7];
arr.sort();


var results = [];
for (var i = 0; i < arr.length - 1; i++) {
if (arr[i + 1] == arr[i]) {
results.push(arr[i]);
}
}


results = Array.from(new Set(results))


console.log(results);

小开

ES6语法的简单代码(返回重复的排序数组):

let duplicates = a => {d=[]; a.sort((a,b) => a-b).reduce((a,b)=>{a==b&&!d.includes(a)&&d.push(a); return b}); return d};

使用方法:

duplicates([1,2,3,10,10,2,3,3,10]);

小开

这是我能想到的最简单的ES5解决方案之一

function duplicates(arr) {
var duplicatesArr = [],
uniqueObj = {};


for (var i = 0; i < arr.length; i++) {
if( uniqueObj.hasOwnProperty(arr[i]) && duplicatesArr.indexOf( arr[i] ) === -1) {
duplicatesArr.push( arr[i] );
}
else {
uniqueObj[ arr[i] ] = true;
}
}


return duplicatesArr;
}
/* Input Arr: [1,1,2,2,2,1,3,4,5,3] */
/* OutPut Arr: [1,2,3] */

小开

简单的一行方式

var arr = [9,1,2,4,3,4,9]
console.log(arr.filter((ele,indx)=>indx!==arr.indexOf(ele))) //get the duplicates
console.log(arr.filter((ele,indx)=>indx===arr.indexOf(ele))) //remove the duplicates

小开

这是基于出现次数的更高级的函数。

function getMostDuplicated(arr, count) {
const result = [];
arr.forEach((item) => {
let i = 0;
arr.forEach((checkTo) => {
if (item === checkTo) {
i++;
if (i === count && result.indexOf(item) === -1) {
result.push(item);
}
}
});
});
return result;
}


arr = [1,1,1,2,5,67,3,2,3,2,3,1,2,3,4,1,4];
result = getMostDuplicated(arr, 5); // result is 1
result = getMostDuplicated(arr, 2); // result 1, 2, 3, 4
console.log(result);

小开

遵循逻辑会更容易、更快

// @Param:data:Array that is the source
// @Return : Array that have the duplicate entries
findDuplicates(data: Array<any>): Array<any> {
return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
}

优点:

单行:-P
所有内置的数据结构有助于提高效率
快

逻辑描述:

转换为集以删除所有重复项
遍历设置的值
对于每个设置值，在源数组中检查条件"值的第一个索引不等于最后一个索引" == >则推断为重复否则为'唯一'

注意: map()和filter()方法更高效、更快。

小开

快速和优雅的方式使用es6对象解构和减少

它在O(n)(对数组进行1次迭代)中运行，并且不会重复出现超过2次的值

const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
dup
} = arr.reduce(
(acc, curr) => {
acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
if (acc.items[curr] === 2) acc.dup.push(curr)
return acc
}, {
items: {},
dup: []
},
)


console.log(dup)
// ['hi', 'bye']

小开

//find duplicates:
//sort, then reduce - concat values equal previous element, skip others


//input
var a = [1, 2, 3, 1, 2, 1, 2]


//short version:
var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, [])
console.log(duplicates); //[1, 1, 2, 2]


//readable version:
var duplicates = a.sort().reduce((output, element, index, input) => {
if ((index > 0) && (element === input[index - 1]))
return output.concat(element)
return output
}, [])
console.log(duplicates); //[1, 1, 2, 2]

小开

打印重复值

 var arr = [1,2,3,4,13,2,3,4,3,4];


// non_unique Printing
function nonUnique(arr){
var result = [];
for(var i =0;i<arr.length;i++){
if(arr.indexOf(arr[i],i+1) > -1){
result.push(arr[i]);
}
}
console.log(result);
}nonUnique(arr);


// unique Printing
function uniqueDuplicateVal(arr){
var result = [];
for(var i =0;i<arr.length;i++){
if(arr.indexOf(arr[i],i+1) > -1){
if(result.indexOf(arr[i]) === -1]){
result.push(arr[i]);
}
}
}
}
uniqueDuplicateVal(arr)

小开

这是我的简单和一行解决方案。

它首先搜索不是唯一的元素，然后使用Set使所找到的数组是唯一的。

最后我们有一个重复的数组。

var array = [1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 7, 8, 5, 22, 1, 2, 511, 12, 50, 22];


console.log([...new Set(
array.filter((value, index, self) => self.indexOf(value) !== index))]
);

小开

这是我用map实现的。它应该运行在O(n)时间，应该有点容易喘气。

    var first_array=[1,1,2,3,4,4,5,6];
var find_dup=new Map;


for (const iterator of first_array) {
// if present value++
if(find_dup.has(iterator)){
find_dup.set(iterator,find_dup.get(iterator)+1);
}else{
// else add it
find_dup.set(iterator,1);
}
}
console.log(find_dup.get(2));

然后你可以find_dup.get(key)来查找它是否有重复(它应该给> 1)。

小开

这是我的建议(ES6):

let a = [1, 2, 3, 4, 2, 2, 4, 1, 5, 6]
let b = [...new Set(a.sort().filter((o, i) => o !== undefined && a[i + 1] !== undefined && o === a[i + 1]))]


// b is now [1, 2, 4]

小开

这应该是在数组中查找重复值的最短和最简单的方法之一。

var arr = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var data = arr.filter(function(item,index,arr){
return arr.indexOf(item) != arr.lastIndexOf(item) && arr.indexOf(item) == index;
})


console.log(data );

小开

你可以通过比较index:

function getDuplicate(array) {
return array.filter((value, index) => array.value !== index)
}

小开

返回副本并保留数据类型。

具有O(4n)性能

const dupes = arr => {
const map = arr.reduce((map, curr) => {
return (map.set(curr, (map.get(curr) || 0) + 1), map)
}, new Map());


return Array.from(map).filter(([key, val])=> val > 1).map(([key, val]) => key)
}

具有O(2n)性能

const dupes = arr => {
const map = arr.reduce((map, curr) => {
return (map.set(curr, (map.get(curr) || 0) + 1), map)
}, new Map());


const dupes_ = [];
for (let [key, val] of map.entries()) {
if (val > 1) dupes_.push(key);
}
return dupes_;
}

小开

这是我能想到的最有效的方法，因为它不包括Array.indexOf()或Array.lastIndexOf()，它们的复杂度为O(n)，并且在复杂度为O(n)的任何循环中使用将使完整的复杂度为O(n²)。

我的第一个循环的复杂度是O(n/2)或O((n/2) + 1)，因为在哈希中搜索的复杂度是O(1)。当数组中没有重复元素时，第二个循环的最差复杂度为O(n)，当每个元素都有重复元素时，最佳复杂度为O(n/2)。

function duplicates(arr) {
let duplicates = [],
d = {},
i = 0,
j = arr.length - 1;


// Complexity O(n/2)
while (i <= j) {
if (i === j)
d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1;  // Complexity O(1)
else {
d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1;  // Complexity O(1)
d[arr[j]] ? d[arr[j]] += 1 : d[arr[j]] = 1;  // Complexity O(1)
}


++i;
--j;
}


// Worst complexity O(n), best complexity O(n/2)
for (let k in d) {
if (d[k] > 1)
duplicates.push(k);
}


return duplicates;


}


console.log(duplicates([5,6,4,9,2,3,5,3,4,1,5,4,9]));
console.log(duplicates([2,3,4,5,4,3,4]));
console.log(duplicates([4,5,2,9]));
console.log(duplicates([4,5,2,9,2,5,9,4]));

小开

魔法

a.filter(( t={}, e=>!(1-(t[e]=++t[e]|0)) ))

O (n)的性能;我们假设你的数组在a中，它包含的元素可以以唯一的方式强制转换为.toString()(这是由JS在t[e]中隐式完成的)，例如numbers=[4,5,4]， strings=["aa"，"bb"，"aa"]， arraysNum=[[1,2,3]，[43,2,3]，[1,2,3]]。解释在这里，唯一值在这里

var a1 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
var a2 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];
var a3 = [5,6,4,9,2,3,5,3,4,1,5,4,9];


let nd = (a) => a.filter((t={},e=>!(1-(t[e]=++t[e]|0))))




// Print
let c= x => console.log(JSON.stringify(x));
c( nd(a1) );
c( nd(a2) );
c( nd(a3) );

小开

这是一个单循环方法，使用哈希表来计数元素，并在计数为2时过滤数组，因为它返回第一个找到的重复元素。

优势:

单回路
在闭包中使用对象进行计数

var array = [5, 0, 2, 1, 2, 3, 3, 4, 4, 8, 6, 7, 9, 4],
duplicates = array.filter((h => v => (h[v] = (h[v] || 0) + 1) === 2)({}));
    

console.log(duplicates);

小开

我们将使用Javascript ES6功能来做魔术!

var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
const filtered = arr.filter((value, index) => {
return arr.indexOf(value) >= index;
});


console.log(filtered);

https://jsfiddle.net/97Lxupnz/

小开

从数组/字符串中获取重复/重复值的最简单方法:

function getDuplicates(param) {
var duplicates = {}


for (var i = 0; i < param.length; i++) {
var char = param[i]
if (duplicates[char]) {
duplicates[char]++
} else {
duplicates[char] = 1
}
}
return duplicates
}


console.log(getDuplicates("aeiouaeiou"));
console.log(getDuplicates(["a", "e", "i", "o", "u", "a", "e"]));
console.log(getDuplicates([1, 2, 3, 4, 5, 1, 1, 2, 3]));

小开

这将从数组中返回副本作为副本数组。

    const duplicates = function(arr) {
// let try moving in pairs.. maybe that will work
let dups = new Set(),
r = []
arr.sort()
arr.reduce((pv, cv) => {
if (pv === cv) {
dups.add(pv)
}
return cv
})
for (let m of dups.values()) {
r.push(m)
}
return r
}
    

console.log(duplicates([1,3,5,6,7,4,4,5,1,4,6,3,8,9,5,0]))

小开

var arr = ['a','b','c','a'];


arr.filter( (item , index ) => {
console.log(item , index , arr.indexOf(item) , arr.indexOf( item ) == index);
return index == arr.indexOf(item)
} );

小开

这是我能想到的最简单的解决办法:

const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']


const filtered = arr.filter((el, index) => arr.indexOf(el) !== index)
// => filtered = [ 2, 2, 0, 0, -1, 'a', 'a' ]


const duplicates = [...new Set(filtered)]


console.log(duplicates)
// => [ 2, 0, -1, 'a' ]

就是这样。

注意:

它适用于任何数字，包括0，字符串和负数，例如-1 - 相关问题: 获取JavaScript数组中所有唯一的值(删除重复值)
原始数组arr被保留(filter返回新数组而不是修改原始数组)
filtered数组包含所有重复项;它可以也包含多个相同的值(例如，这里的过滤数组是[ 2, 2, 0, 0, -1, 'a', 'a' ])
如果你想获得重复的只有值(你不想有多个重复的相同值)，你可以使用[...new Set(filtered)] (ES6有一个对象集，它只能存储唯一的值)。

希望这能有所帮助。

小开

有一个非常简单的方法来解决这个问题。如果你使用新的'Set' javascript命令。Set可以接受一个数组作为输入，并输出一个只包含唯一值的新“Set”。然后通过比较数组的长度和集合的'size'属性，你可以看到它们是否不同。如果它们不同，一定是由于重复的条目。

var array1 = ['value1','value2','value3','value1']; // contains duplicates
var array2 = ['value1','value2','value3','value4']; // unique values


console.log('array1 contains duplicates = ' + containsDuplicates(array1));
console.log('array2 contains duplicates = ' + containsDuplicates(array2));




function containsDuplicates(passedArray) {
let mySet = new Set(passedArray);
if (mySet.size !== passedArray.length) {
return true;
}
return false;
}

如果运行上面的代码片段，将得到以下输出。

Array1包含duplicate = true

Array2包含重复项= false

小开

这个答案可能也有帮助，它利用js reduce 操作员/方法从数组中删除重复的。

const result = [1, 2, 2, 3, 3, 3, 3].reduce((x, y) => x.includes(y) ? x : [...x, y], []);


console.log(result);

小开

最短的香草JS:

[1,1,2,2,2,3].filter((v,i,a) => a.indexOf(v) !== i) // [1, 2, 2]

小开

你可以使用sort， filter和sets来做到这一点。

var numbers = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var numbersSorted = numbers.sort();
let result = numbers.filter((e, i) => numbers[i] == numbers[i+1]);
result = [...new Set(result)];
console.log(result);

小开

var array = ['a', 'b', 'c', 'a'];


function unique(array) {
var unique_arr = [];
array.forEach(function(i, e) {
if (unique_arr.indexOf(i)===-1) unique_arr.push(i);
});
return unique_arr;
}
console.log(unique(array));

小开

排名较高的答案有一些固有的问题，包括使用遗留的javascript，不正确的排序或只支持2个重复的项目。

这里有一个解决这些问题的现代解决方案:

const arrayNonUniq = array => {
if (!Array.isArray(array)) {
throw new TypeError("An array must be provided!")
}


return array.filter((value, index) => array.indexOf(value) === index && array.lastIndexOf(value) !== index)
}


arrayNonUniq([1, 1, 2, 3, 3])
//=> [1, 3]


arrayNonUniq(["foo", "foo", "bar", "foo"])
//=> ['foo']

你也可以使用npm包array-non-uniq。

小开

非常简单的方法:

function getDuplicateValues(someArray) {
const duplicateValues = new Set([])
const check = new Set([])
someArray.forEach(v => {
if (check.has(v)) {
duplicateValues.add(v)
} else {
check.add(v)
}
})
return Array.from(duplicateValues);
}


const result = getDuplicateValues(['coffee', 'soda', 'water', 'juice', 'water', 'water', 'coffee'])


repeated_values.textContent = JSON.stringify(result, null, '  ')

<pre id="repeated_values"></pre>

小开

基于@ blumoon但更短，返回所有副本一次!

function checkDuplicateKeys(arr) {
const counts = {}
return arr.filter((item) => {
counts[item] = counts[item] || 1
if (counts[item]++ === 2) return true
})
}


// [1,2,2,2,2,2,2] => [1,2]
// ['dog', 'dog', 'cat'] => ['dog']

小开

公认的答案是最完美的，但正如一些用户指出的那样，对于一个元素重复超过2次的情况，它将给出具有重复元素的数组:

这个解决方案也涵盖了这些场景:

const peoples = [
{id: 1, name:"Arjun"},
{id: 2, name:"quinze"},
{id: 3, name:"catorze"},
{id: 1, name:"Arjun"},
{id: 4, name:"dezesseis"},
{id: 1, name:"Arjun"},
{id: 2, name:"quinze"},
{id: 3, name:"catorzee"}
]




function repeated(ppl){


const newppl = ppl.slice().sort((a,b) => a.id -b.id);


let rept = [];
for(let i = 0; i < newppl.length-1 ; i++){
if (newppl[i+1].id == newppl[i].id){
rept.push(newppl[i+1]);
}
}


return [...new Set(rept.map(el => el.id))].map(rid =>
rept.find(el => el.id === rid)
);


}


repeated(peoples);

小开

您可以使用filter方法和indexOf()来获取所有重复的值

function duplicate(arr) {
return duplicateArray = arr.filter((item, index) => arr.indexOf(item) !== index)
}

arr.indexOf(项)将始终返回给定元素所在的第一个索引找到

小开

最简单和最快的方法是使用Set对象:

const numbers = [1, 2, 3, 2, 4, 5, 5, 6];


const set = new Set(numbers);


const duplicates = numbers.filter(item => {
if (set.has(item)) {
set.delete(item);
return false;
} else {
return true;
}
});


// OR more concisely


const duplicates = numbers.filter(item => !set.delete(item));


console.log(duplicates);
// [ 2, 5 ]

小开

const names = [
"Alex",
"Matt",
12,
"You",
"Me",
12,
"Carol",
"Bike",
"Carol",
];


const count = (names) =>
names.reduce((a, b) => ({ ...a, [b]: (a[b] || 0) + 1 }), {});


let obj = count(names);
let objectKeys = Object.keys(obj);


let repetitiveElements = [];
let answer = objectKeys.map((value) => {
if (obj[value] > 1) {
return repetitiveElements.push(value);
}
});
console.log(repetitiveElements);

小开

已经有很多答案了，但不幸的是，有些太长了，有些太短了，但对我来说太神秘了，而另一些则超出了我的知识范围……不过，我真的很喜欢我提出的这个解决方案。希望它仍然对一些人有帮助!

尽管最初的帖子说他/她实际上不需要重复的索引，也不需要重复多少次，但我认为仍然需要清楚地计算它们。

带有注释的代码。

function findDuplicates(array, count = {}) {
// with count declared in the parameter, initialized as an empty object,
// it can store the counts of all elements in array
  

// using the forEach loop to iterate through the input array,
// also using the conditional ternary operators
// (works just like a normal if-else statement, but just a bit cleaner)
// we can store all occurrences of each element from array in count
array.forEach(el => count[el] ? count[el]++ : count[el] = 1)
  

// using Object.keys, we get an array of all keys from count (all numbers)
// (sorted as well, though of no specific importance here)
// using filter to find all elements with a count (value) > 1 (duplicates!)
return Object.keys(count).filter(key => count[key] > 1);
}

只有代码(带有测试用例)。

function findDuplicates(array, count = {}) {
array.forEach(el => count[el] ? count[el]++ : count[el] = 1);
return Object.keys(count).filter(key => count[key] > 1);
}


let arr1 = [9, 9, 111, 2, 3, 4, 4, 5, 7];
let arr2 = [1,6,7,3,6,8,1,3,4,5,1,7,2,6];
console.log(findDuplicates(arr1)); // => ['4', '9']
console.log(findDuplicates(arr2)); // => ['1', '3', '6', '7']

小开

这个问题有这么多错误的答案，或者答案像Set一样需要很多额外的内存，这实际上是一个遗憾。干净简单的解决方案:

function findDuplicates<T>(arr: Array<T>): T[] {
//If the array has less than 2 elements there are no duplicates
const n = arr.length;
if (n < 2)
return [];
  

const sorted = arr.sort();
const result = [];


//Head
if (sorted[0] === sorted[1])
result.push(sorted[0]);


//Inner (Head :: Inner :: Tail)
for (let i = 1; i < n-1; i++) {
const elem = sorted[i];
if (elem === sorted[i - 1] || elem === sorted[i+1])
result.push(elem)
}


//Tail
if (sorted[n - 1] == sorted[n - 2])
result.push(sorted[n - 1]);


return result;
}


console.dir(findDuplicates(['a', 'a', 'b', 'b']));
console.dir(findDuplicates(['a', 'b']));
console.dir(findDuplicates(['a', 'a', 'a']));
console.dir(findDuplicates(['a']));
console.dir(findDuplicates([]));

小开

在一次采访中有人问我这个问题，我的回答是，

List<int> getDublicates(List<int> x)
{
List<int> result = new List<int>();
while (x.Count>0)
{
int d = x[0];
x.Remove(x[0]);
if (x.Contains(d))
result.Add(d);
}
return result;
}

它的性能很好

小开

删除重复项的最短方法是使用集和传播的语法

const remove = (array) => [...new Set(array)];
console.log(remove([1,1,2,2,3]); //1,2,3

小开

[1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 50, 8, 5, 22, 1, 2, 511, 12, 50, 22].reduce(function (total, currentValue, currentIndex, arr) {
if (total.indexOf(currentValue) === -1 && arr.indexOf(currentValue) !== currentIndex)
total.push(currentValue);
return total;
}, [])

小开

const a = ['a', 'b', 'b']


function findDuplicates(a) {
return Object.keys(_.pickBy(_.countBy(a), x => x > 1))
}

https://runkit.com/nitzanav/62659f09bd2d5f0008ef46d4

小开

你可以使用下面的代码来获取给定数组中的重复元素:

let name = ['satya', 'amit', 'aditya', 'abhay', 'satya', 'amit'];
let dup = [];
let uniq = [];
name.forEach((item, index) => {
if(!uniq.includes(item)) {
uniq[index] = item;
}
if (name.indexOf(item, index + 1) != -1) {
dup[index] = item;
}
})

小开

这是用ES6语法找到重复元素的最简单方法

const arr =[1,2,3,3,21,3, 21,34]
const duplicates = Array.from(new Set(arr.filter((eg, i, ar)=> i !==ar.indexOf(eg))))
console.log(duplicates)

小开

我只需要找到复制的值是什么——实际上我不需要它们的索引，也不需要它们复制了多少次。

这是一个有趣而简单的任务，有许多难以阅读的答案……

打印稿

function getDuplicatedItems<T>(someArray: T[]): T[] {
// create a set to iterate through (we only need to check each value once)
const itemSet = new Set<T>(someArray);


// from that Set, we check if any of the items are duplicated in someArray
const duplicatedItems = [...itemSet].filter(
(item) => someArray.indexOf(item) !== someArray.lastIndexOf(item)
);


return duplicatedItems;
}

JavaScript

function getDuplicatedItems(someArray) {
// check for misuse if desired
// if (!Array.isArray(someArray)) {
//     throw new TypeError(`getDuplicatedItems requires an Array type, received ${typeof someArray} type.`);
// }
const itemSet = new Set(someArray);
const duplicatedItems = [...itemSet].filter(
(item) => someArray.indexOf(item) !== someArray.lastIndexOf(item)
);
return duplicatedItems;
}

小开

我试过了，你会得到唯一的元素和在两个不同数组中重复的元素。

复杂度O (n)

let start = [1,1,2,1,3,4,5,6,5,5];
start.sort();
const unique=[];
const repeat = [];
let ii=-1 ;
for(let i =0 ; i<start.length; i++){
if(start[i]===start[i-1]){
if(repeat[ii]!==start[i-1]){
repeat.push(start[i-1]);
ii++;
}
}
else {
if(i+1<start.length){
if(start[i]!==start[i+1]){
unique.push(start[i]);
}
}
else if(i===start.length-1){
unique.push(start[i]);
}
}
}
console.log(unique) ;
console.log(repeat);

获取数组中所有非唯一的值(即:重复/不止一次出现)

类似的问题: