ES2016.includes（）一种方法简单答案：

var arr = [1,5,2,4,1,6]
function getOrigs(arr) {
  let unique = []
  arr && arr.forEach(number => {
    !unique.includes(number) && unique.push(number)
    if (number === arr[arr.length - 1]) {
      console.log('unique: ', unique)
    }
  })
}
getOrigs(arr)

请改用此选项：

更新的ES版本简单问题不应使用多个高级JS方法，push（）、length（）和forEach（）是常见的使用闭包更容易阅读在内存、垃圾收集和性能方面似乎比其他产品更好更少的代码行：如果您根据行结尾的位置分隔行，则只需要一行逻辑（因此您可以根据需要调用或重构这一行）：

var arr = [1,5,2,4,1,6];
function getOrigs(arr) {let unique = []; 
  arr && arr.forEach(number => !unique.includes(number) && unique.push(number) && ((number === arr[arr.length - 1]) && console.log('unique: ', unique)))};
getOrigs(arr);

如果只想获取唯一元素并删除重复一次的元素，可以执行以下操作：

设数组=[2，3，4，1，2，8，1，1，5，9，3，5，3，3，8，4]；函数removeDucplicates（inputArray）{让输出=[]；让countObject＝｛｝；for（数组的值）{countObject[value]=（countObject[value]||0）+1；}for（countObject中的键）{if（countObject[key]==1）{output.push（按键）；}}返回输出；}console.log（removeDucplicates（数组））；

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

这里的许多答案可能对初学者没有帮助。如果数组的重复数据消除很困难，他们真的会知道原型链，甚至jQuery吗？

在现代浏览器中，一个干净而简单的解决方案是将数据存储在一个集合中，该集合被设计为一个唯一值列表。

const cars=[“沃尔沃”、“吉普”、“沃尔沃”，“林肯”、“林肯”和“福特”]；constuniqueCars=Array.from（新集合（cars））；console.log（uniqueCars）；

Array.from用于将Set转换回Array，以便您可以轻松访问数组所具有的所有很棒的方法（功能）。同样的事情还有其他方法。但您可能根本不需要Array.from，因为Sets有很多有用的功能，比如forEach。

如果您需要支持旧的Internet Explorer，因此无法使用Set，那么一种简单的方法是将项目复制到新阵列中，同时预先检查它们是否已在新阵列中。

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

为了使其立即可重用，让我们将其放在函数中。

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

所以为了消除重复，我们现在就这样做。

var uniqueCars = deduplicate(cars);

当函数完成时，重复数据消除（cars）部分将成为我们命名为result的部分。

只需将您喜欢的任何数组的名称传递给它即可。

我将所有答案分成4种可能的解决方案：

使用对象｛｝防止重复使用助手数组[]使用筛选器+indexOf奖金ES6设置方法。

以下是答案中的示例代码：

使用对象｛｝防止重复

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

使用助手数组[]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

使用筛选器+indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

使用ES6[…新集合（a）]

function uniqueArray4(a) {
  return [...new Set(a)];
}

我想知道哪一个更快。我已经制作了测试功能的GoogleSheet样本。注意：ECMA 6在Google Sheets中不可用，所以我无法测试它。

以下是测试结果：

我希望看到使用对象｛｝的代码将获胜，因为它使用哈希。因此，我很高兴测试在Chrome和IE中显示了该算法的最佳结果。感谢@rab的代码。

2020年更新

启用谷歌脚本的ES6引擎。现在我用Sets测试了最后一段代码，它看起来比对象方法更快。

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);