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

Const duplicate = function(arr) { //让我们试着两人一组。也许会有用 let dups = new Set()， R = [] arr.sort () 加勒比海盗。Reduce ((pv, cv) => { If (pv === cv) { dups.add (pv) ｝ 返回的简历 }) For (let m of dpps .values()) { r.push (m) ｝ 返回r ｝ console.log(副本([1、3、5、6、7、4、4、5、1、4、6、3、8、9日5 0]))

下面的函数(前面提到的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;
}

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

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);

／* 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;
}

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]);

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

Var arr = [1,1,4,5,5]， darr = []， duplicate = []; For (var I = 0;I < arrr .length;我+ +){ If (darr.includes(arr[i]) && !重复。includes(arr[i])) duplicates.push (arr[我]) 其他的 darr.push (arr[我]); ｝ console.log(副本); <h3>重复数组</h3> <p>[1,1,4,5,5]</p> <h3>具有不同元素的数组</h3> <p>[1,4,5]</p> <h3>重复值</h3> (1、5)< p > < / p >