如果你想保持原始数组不变，

您需要第二个数组来包含第一个-的唯一元素

大多数浏览器都有Array.prototype.filter:

const unique = array1.filter((item, index, array) => array.indexOf(item) === index);


//if you need a 'shim':
Array.prototype.filter= Array.prototype.filter || function(fun, scope){
    var T= this, A= [], i= 0, itm, L= T.length;
    if(typeof fun== 'function'){
        while(i<L){
            if(i in T){
                itm= T[i];
                if(fun.call(scope, itm, i, T)) A[A.length]= itm;
            }
            ++i;
        }
    }
    return A;
}
 Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
        if(!i || typeof i!= 'number') i= 0;
        var L= this.length;
        while(i<L){
            if(this[i]=== what) return i;
            ++i;
        }
        return -1;
    }

或者对于那些寻找与当前浏览器兼容的一行程序(简单而实用)的人:

Let a = ["1"， "1"， "2"， "3"， "3"， "1"]; let unique = a.filter((item, i, ar) => ar. indexof (item) === i); console.log(独特的);

更新2021 我建议你去看看Charles Clayton的答案，在JS的最新修改中，甚至有更简洁的方法来做到这一点。

更新18-04-2017

它看起来就像'Array.prototype。Includes '现在在主流浏览器的最新版本中得到了广泛支持(兼容性)

更新29-07-2015:

目前正在计划让浏览器支持标准化的“Array.prototype”。方法，虽然没有直接回答这个问题;往往是相关的。

用法:

["1", "1", "2", "3", "3", "1"].includes("2");     // true

polyfill(浏览器支持，来自mozilla):

// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, 'includes', {
    value: function(searchElement, fromIndex) {

      // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      //    (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      //  a. Let k be n.
      // 6. Else n < 0,
      //  a. Let k be len + n.
      //  b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        // c. Increase k by 1.
        // NOTE: === provides the correct "SameValueZero" comparison needed here.
        if (o[k] === searchElement) {
          return true;
        }
        k++;
      }

      // 8. Return false
      return false;
    }
  });
}

既然我在@Rocket的回答的评论中谈到了它，我不妨提供一个不使用库的示例。这需要两个新的原型功能，包含和唯一

Array.prototype.contains =函数(v) { For (var I = 0;I < this.length;我+ +){ If (this[i] === v)返回true; ｝ 返回错误; }; Array.prototype.unique = function() { Var arr = []; For (var I = 0;I < this.length;我+ +){ If (!arr.contains(this[i])) { arr.push(这[我]); ｝ ｝ 返回arr; ｝ Var duplicate = [1,3,4,2,1,2,3,8]; Var uniques = duplicate .unique();// result = [1,3,4,2,8] console.log(独立);

为了获得更高的可靠性，您可以用MDN的indexOf shim替换contains，并检查每个元素的indexOf是否等于-1:documentation

下面是一个可定制的equals函数的方法，它可以用于原语以及自定义对象:

Array.prototype.pushUnique = function(element, equalsPredicate = (l, r) => l == r) {
    let res = !this.find(item => equalsPredicate(item, element))
    if(res){
        this.push(element)
    }
    return res
}

用法:

//with custom equals for objects
myArrayWithObjects.pushUnique(myObject, (left, right) => left.id == right.id)

//with default equals for primitives
myArrayWithPrimitives.pushUnique(somePrimitive)

快速，紧凑，无嵌套循环，适用于任何对象，不只是字符串和数字，接受谓词，只有5行代码!!

function findUnique(arr, predicate) {
  var found = {};
  arr.forEach(d => {
    found[predicate(d)] = d;
  });
  return Object.keys(found).map(key => found[key]); 
}

示例:按类型查找唯一项:

var things = [
  { name: 'charm', type: 'quark'},
  { name: 'strange', type: 'quark'},
  { name: 'proton', type: 'boson'},
];

var result = findUnique(things, d => d.type);
//  [
//    { name: 'charm', type: 'quark'},
//    { name: 'proton', type: 'boson'}
//  ] 

如果你想让它找到第一个唯一的项目，而不是最后一个，在那里添加一个find . hasownproperty()检查。

一行代码，纯JavaScript

使用ES6语法

List = List。filter((x, i, a) => a. indexof (x) === i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

使用ES5语法

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) === i; 
});

浏览器兼容性:IE9+