获取数组中的所有非唯一值（即：重复/多次出现）

时间：2009-05-08 16:48:31

标签： javascript arrays

我需要检查JavaScript数组以查看是否存在任何重复值。最简单的方法是什么？我只需要找到重复的值是什么 - 我实际上并不需要它们的索引或重复它们的次数。

我知道我可以遍历数组并检查匹配的所有其他值，但似乎应该有一个更简单的方法。有任何想法吗？谢谢！

类似的问题：

86 个答案:

答案 0 :(得分：260)

您可以对数组进行排序，然后运行它，然后查看下一个（或上一个）索引是否与当前索引相同。假设您的排序算法很好，这应该小于O（n 2 ）：

var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
var 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)
var results = [];
for (var i = 0; i < sorted_arr.length - 1; i++) {
    if (sorted_arr[i + 1] == sorted_arr[i]) {
        results.push(sorted_arr[i]);
    }
}

console.log(results);

答案 1 :(得分：203)

如果您想消除重复项，请尝试以下解决方案：

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

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

答案 2 :(得分：150)

这是我在重复帖子（！）中的答案：

撰写此条目2014时 - 所有示例都是for循环或jQuery。 Javascript有完美的工具：排序，映射和减少。

查找重复项

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 duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1)

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

更多功能语法：

@ Dmytro-Laptin指出要删除一些代码。这是相同代码的更紧凑版本。使用一些ES6技巧和更高阶函数：

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

const count = names =>
  names.reduce((a, b) => ({ ...a,
    [b]: (a[b] || 0) + 1
  }), {}) // don't forget to initialize the accumulator

const duplicates = dict =>
  Object.keys(dict).filter((a) => dict[a] > 1)

console.log(count(names)) // { Mike: 1, Matt: 1, Nancy: 2, Adam: 1, Jenny: 1, Carl: 1 }
console.log(duplicates(count(names))) // [ 'Nancy' ]

答案 3 :(得分：43)

在数组中查找重复值

这应该是在数组中实际查找重复值的最短方法之一。正如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()（或更清楚：strict comparision operator）支持。

由于reduce()和indexOf()，它至少需要IE 9。

答案 4 :(得分：29)

您可以添加此功能，或调整它并将其添加到Javascript的Array原型中：

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

答案 5 :(得分：27)

更新：以下使用优化的组合策略。它优化了原始查找以从散列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 Collections，那么版本更简单，速度更快。 （对于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;
    }
  });
}

答案 6 :(得分：17)

这应该可以得到你想要的东西，只需要重复一遍。

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.

答案 7 :(得分：16)

var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})

答案 8 :(得分：13)

使用underscore.js 

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

答案 9 :(得分：6)

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

它首先搜索非唯一元素，然后使用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))]
);

答案 10 :(得分：6)

当您需要检查every()中没有重复项时，您可以使用[1, 2, 3].every(function(elem, i, array){return array.lastIndexOf(elem) === i}) // true [1, 2, 1].every(function(elem, i, array){return array.lastIndexOf(elem) === i}) // false 方法：

every()

请注意，lastIndexOf()不适用于IE 8及更低版本。

我使用indexOf()，因为如果every()进行的函数回调是按索引顺序进行的，那么它可能比Array::duplicates = -> not @every((elem, i, array) -> array.lastIndexOf(elem) is i) [1, 2, 3].duplicates() // false [1, 2, 1].duplicates() // true 更有效，但是这没有得到证实。

在 CoffeeScript 中，我正在使用它：

NSArray

答案 11 :(得分：6)

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

或添加到Array的prototype.chain 

//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

答案 12 :(得分：6)

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

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

arr.indexOf(item) 将始终返回给定元素可以位于的第一个索引 找到

答案 13 :(得分：6)

从3个数组（或更多）中查找唯一值：

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

    return arr;
}

var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    unique = arr.concat(arr2, arr3).unique();

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

只是旧浏览器的数组indexOf的polyfill：

if (!Array.prototype.indexOf){
   Array.prototype.indexOf = function(elt /*, from*/){
     var len = this.length >>> 0;

     var from = Number(arguments[1]) || 0;
     from = (from < 0) ? Math.ceil(from) : Math.floor(from);
     if (from < 0)
        from += len;

     for (; from < len; from++){
        if (from in this && this[from] === elt)
           return from;
     }
     return -1;
  };
}

使用“inArray”的jQuery解决方案：

if( $.inArray(this[i], arr) == -1 )

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],
    unique;

// Combine all the arrays to a single one
unique = arr.concat(arr2, arr3);
// create a new (dirty) Array with only the unique items
unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' )
// Cleanup - remove duplicate & empty items items 
unique = [...new Set(unique)].filter(n => n);

console.log(unique);

而不是添加'Array.prototype.indexOf'

答案 14 :(得分：5)

使用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']

答案 15 :(得分：5)

这是我的建议（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]

答案 16 :(得分：4)

这是我能想到的最简单的解决方案：

    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' ]

就是这样。

注意：

  1. 它适用于任何数字，包括0，字符串和负数，例如-1- 相关问题： Get all unique values in a JavaScript array (remove duplicates)

  2. 原始数组arr被保留（filter返回新数组，而不是修改原始数组）

  3. filtered数组包含所有个重复项；它可以也包含一个以上的相同值（例如，此处的过滤数组为[ 2, 2, 0, 0, -1, 'a', 'a' ]）

  4. 如果您只想获取重复的 值（您不希望具有相同值的多个重复项），则可以使用[...new Set(filtered)]（ES6具有一个对象 Set （只能存储唯一值）

希望这会有所帮助。

答案 17 :(得分：4)

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

答案 18 :(得分：4)

使用ES6（或使用Babel或Typescipt），您只需执行以下操作：

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

https://es6console.com/j58euhbt/

答案 19 :(得分：3)

以下函数（已经提到过的eliminateDuplicates函数的变体）似乎可以解决问题，返回test2,1,7,5作为输入[“test”，“test2”，“test2”，1,1， 1,2,3,4,5,6,7,7,10,22,43,1,5,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;
}

答案 20 :(得分：3)

＆＃13;
＆＃13; 
var arr = [2, 1, 2, 2, 4, 4, 2, 5];

function returnDuplicates(arr) {
  return arr.reduce(function(dupes, val, i) {
    if (arr.indexOf(val) !== i && dupes.indexOf(val) === -1) {
      dupes.push(val);
    }
    return dupes;
  }, []);
}

alert(returnDuplicates(arr));
＆＃13;
＆＃13;
＆＃13;

此函数避免了排序步骤，并使用reduce（）方法将重复项推送到新数组（如果它尚未存在）。

答案 21 :(得分：3)

使用＆＃34;包括＆＃34;测试元素是否已存在。

＆＃13;
＆＃13; 
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);
＆＃13; 
<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>
＆＃13;
＆＃13;
＆＃13;

答案 22 :(得分：3)

此答案也可能有用，它利用js class Currency(models.Model): ... # your code def __str__(self): try: return self.Primary_Currency.Currency_Name except AttributeError: return self.Currency_Name 操作员/方法从数组中删除重复项。

reduce

答案 23 :(得分：3)

这是一种非常轻松的方式：

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

答案 24 :(得分：3)

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

答案 25 :(得分：3)

我刚刚找到了一种使用数组过滤器实现此目的的简单方法

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

答案 26 :(得分：2)

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

答案 27 :(得分：2)

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

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

Snackbar.make(view, "Not Data Found", Snackbar.LENGTH_LONG).show();

答案 28 :(得分：2)

只是为上面添加一些理论。

在比较模型中找到重复数据的下限为O（n * log（n）。从理论上讲，你不能做比第一次排序更好的经历 列表按顺序删除您找到的任何重复项。

如果您想在线性（O（n））预期时间内找到重复项，您可以 哈希列表中的每个元素;如果发生碰撞，请将其删除/标记为副本， 并继续。

答案 29 :(得分：2)

以O（n）时间复杂度解决上述问题（无需排序）。

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

var obj={};

for(var i=0;i<arr.length;i++){
    if(!obj[arr[i]]){
        obj[arr[i]]=1;
    } else {
        obj[arr[i]]=obj[arr[i]]+1;
    }
}
var result=[]
for(var key in obj){
    if(obj[key]>1){
        result.push(Number(key)) // change this to result.push(key) to find duplicate strings in an array
    }
}

console.log(result)

答案 30 :(得分：2)

一个班轮

＆＃13;
＆＃13; 
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
＆＃13;
＆＃13;
＆＃13;

答案 31 :(得分：2)

以下逻辑将更容易，更快 

// @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));
      }

优势：

  1. 单行:-P
  2. 所有内置数据结构有助于提高效率
  3. 更快

    4. 逻辑描述：

    1. 转换为设置以删除所有重复项
    2. 迭代设定值
    3. 使用每个设置值检查源数组中的条件＆＃34;值第一个索引不等于最后一个索引＆＃34; ==＆gt;然后推断为重复，否则它是唯一的＆＃39;

      4. 注意： map（）和filter（）方法效率高，速度快。

答案 32 :(得分：2)

我更喜欢这样做的功能方式。

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

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

答案 33 :(得分：2)

最简单快捷的方法是使用 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);
    } else {
        return item;
    }
});

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

答案 34 :(得分：2)

仅限ES5（即，它需要IE8及更低版本的filter（）polyfill）：

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

答案 35 :(得分：2)

这可能是永久删除数组中重复项的最快方法之一 比这里的大多数功能快10倍。＆amp;野生动物园快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)
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];
toUnique(array);
console.log(array);
  1. 测试：http://jsperf.com/wgu
  2. 演示：http://jsfiddle.net/46S7g/
  3. 更多：https://stackoverflow.com/a/25082874/2450730

    4. 如果您无法阅读上面的代码，请阅读javascript书或这里有一些关于更短代码的解释。 https://stackoverflow.com/a/21353032/2450730

    修改 如注释中所述，此函数确实返回带有唯一身份的数组，但问题是要求查找重复项。在这种情况下，对此函数的简单修改允许将重复项推送到数组中，然后使用前一个函数toUnique删除重复项的副本。 

    function theDuplicates(a,b,c,d){//array,placeholder,placeholder
 b=a.length,d=[];
 while(c=--b)while(c--)a[b]!==a[c]||d.push(a.splice(c,1))
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

toUnique(theDuplicates(array));

答案 36 :(得分：2)

我不喜欢大多数答案。

为什么呢？太复杂，代码太多，代码效率低下，很多都没有回答问题，即找到重复项（而不是给出没有重复项的数组）。

下一个函数返回所有重复项：

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

也许别人也这么认为。

答案 37 :(得分：2)

修改@ 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！

答案 38 :(得分：2)

我认为以下是最简单，最快速的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;
  }, []);
}

答案 39 :(得分：2)

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

答案 40 :(得分：2)

排名较高的答案存在一些固有的问题，包括使用旧版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。

答案 41 :(得分：1)

这是我能想到的简单的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] */

答案 42 :(得分：1)

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

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

答案 43 :(得分：1)

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

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

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

有关集合的更多信息： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

注意： IE中不完全支持。

答案 44 :(得分：1)

最快的解决方法是使用旗帜

＆＃13;
＆＃13; 
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))
＆＃13;
＆＃13;
＆＃13;

答案 45 :(得分：1)

我认为这是最有效的方法，因为其中不包含复杂度为O（n）的Array.indexOf()或Array.lastIndexOf()，并且在复杂度为O（n）的任何循环中使用复杂度O（n ^ 2）。

我的第一个循环的复杂度为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]));

答案 46 :(得分：1)

魔术

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]]。说明here，唯一值here 

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

答案 47 :(得分：1)

基于@bluemoon，但更短，仅一次返回所有重复项！

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']

答案 48 :(得分：1)

使用下划线的另一种方式。 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;
}, []);

答案 49 :(得分：1)

＆＃13;
＆＃13; 
//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]
＆＃13;
＆＃13;
＆＃13;

答案 50 :(得分：1)

  1. 打印重复值

 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)

答案 51 :(得分：1)

与其他一些答案类似，但我使用forEach()使其更漂亮：

function find_duplicates(data) {

    var track = {};
    var duplicates = [];

    data.forEach(function (item) {
        !track[item] ? track[item] = true : duplicates.push(item);
    });

    return duplicates;
}

如果某个值重复多次，则返回其所有重复项，如下所示：

find_duplicates(['foo', 'foo', 'bar', 'bar', 'bar']);
// returns ['foo', 'bar', 'bar']

这可能是你想要的，否则你只需要跟随＆＃34;独特的＆＃34;过滤

答案 52 :(得分：0)

公认的答案是最完美的答案，但正如一些用户指出的那样，对于元素重复两次以上的情况，它将为我们提供具有重复元素的数组：

此解决方案也涵盖了这些情况：

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

答案 53 :(得分：0)

非常简单的方法：

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>

答案 54 :(得分：0)

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

答案 55 :(得分：0)

您可以使用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);

答案 56 :(得分：0)

返回重复项并保留数据类型。

具有O（4n）性能

sort​(byte[] a)
sort​(char[] a)
sort​(double[] a)
sort​(float[] a)
sort​(int[] a)
sort​(long[] a)
sort​(short[] a)
sort​(Object[] a)
sort​(T[] a, Comparator<? super T> c)

具有O（2n）性能

#include <iostream>
#include <iterator>
#include <algorithm>

int main () {
  int myints[]={10,20,30,40,50,60,70};
  std::vector<int> *myvector (7);
  std::copy ( myints, myints+7, *myvector->begin() );
}

答案 57 :(得分：0)

最短的香草JS ：

arr.filter((v,i,a) => a.indexOf(v) !== i) // [9, 4]

答案 58 :(得分：0)

这是一种具有哈希表的单循环方法，用于对元素进行计数并在计数为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);

答案 59 :(得分：0)

有一种非常简单的方法可以解决此问题。如果您使用新式的“设置” javascript命令。 Set可以将数组作为输入，并输出仅包含唯一值的新“ Set”。然后，通过比较数组的长度和集合的'size'属性，可以看到它们是否不同。如果它们不同，那一定是由于重复输入。

get_ls_files <- .... #gives me list of all csv files in S3 folder

for (i in 1:length(get_ls_files)){

    filename = get_ls_files[i]

    tmp = s3read_using(FUN=read.csv, object=paste("my_folder/",filename),
               sep = ",",stringsAsFactors = F, header=T)

    .....
}

如果运行上述代码段，您将获得此输出。

array1包含重复项= true

array2包含重复项= false

答案 60 :(得分：0)

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

Insert into table2(column1, column2)
Select @foreignId as foreignId, name from table1 where id = @id

答案 61 :(得分：0)

这将从数组中返回重复项作为重复项数组。

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

答案 62 :(得分：0)

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

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

答案 63 :(得分：0)

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

答案 64 :(得分：0)

从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的浏览器。

答案 65 :(得分：0)

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

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

  2. hash['hello']将返回[0,3]，因为在arr[]中的节点0和3中找到了'hello'。

    注意： [0,3]的长度用于确定它是否重复。

  3. 使用for(var key in hash){ if (hash.hasOwnProperty(key)){ alert(key); } }会提醒每个唯一值。

答案 66 :(得分：0)

这是避免重复进入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;
}

检查此fiddle ..

答案 67 :(得分：0)

我正在尝试改进@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);

答案 68 :(得分：0)

这是使用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,]));

答案 69 :(得分：0)

这是一个简单的小片段，用于查找唯一且重复的值，不带排序和两个循环。

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

答案 70 :(得分：0)

您可以使用以下结构：

xindex2.php

答案 71 :(得分：0)

使用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);
}

答案 72 :(得分：0)

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

答案 73 :(得分：0)

这里我们每次输出只复制一次。

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

答案 74 :(得分：0)

这就是我用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）。

答案 75 :(得分：-1)

我们将使用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/

答案 76 :(得分：-1)

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

});

答案 77 :(得分：-1)

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

enter image description here

答案 78 :(得分：-1)

＆＃13;
＆＃13; 
var arr = [4,5,1,1,2,3,4,4,7,5,2,6,10,9];
var sorted_arr = arr.sort();
var len = arr.length;
var results = [];
for (var i = 0; i < len; i++) {
  if (sorted_arr[i + 1] !== sorted_arr[i]) {
    results.push(sorted_arr[i]);
  }
}
document.write(results);
＆＃13;
＆＃13;
＆＃13;

答案 79 :(得分：-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>

答案 80 :(得分：-1)

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

答案 81 :(得分：-1)

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

答案 82 :(得分：-1)

您可以通过比较索引来继续：

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

答案 83 :(得分：-1)

这是一个没有使用临时数组存储非重复数据的人：

// 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;
};

答案 84 :(得分：-3)

//program to find the duplicate elements in arraylist

import java.util.ArrayList;
import java.util.Scanner;

public class DistinctEle 
{ 
    public static void main(String args[])
    {
        System.out.println("Enter elements");
        ArrayList<Integer> abc=new ArrayList<Integer>();
        ArrayList<Integer> ab=new ArrayList<Integer>();
        Scanner a=new Scanner(System.in);
        int b;
        for(int i=0;i<=10;i++)
        {
            b=a.nextInt();
            if(!abc.contains(b))
            {
                abc.add(b);
            }
            else
            {
                System.out.println("duplicate elements"+b);
            }
        }
    }
}

答案 85 :(得分：-3)

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

How to find the duplicates in an array using 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!         }     });
相关问题
最新问题