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

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

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

在数组中查找重复的值

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

Var输入= [1,2,3,1,3,1]; Var duplicate =输入。Reduce(函数(acc, el, i, arr) { if (arr.indexOf(el) !== i && ac . indexof (el) < 0) ac .push(el);返回acc; },[]); document . write(副本);// = 1,3(实际数组= [1,3])

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

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

在这篇文章是有用的重复检查，如果你正在使用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!         }     });

更新:以下使用一个优化的组合策略。它优化了原语查找，以受益于散列O(1)查找时间(在原语数组上惟一地运行是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适用于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;
    }
  });
}