最好的方法似乎是使用ES6和Set.Single Line，而且比上面的 * 根据fiddle更快

const myList = [1,4,5,1,2,4,5,6,7];
const unique = [...new Set(myList)];
    
console.log(unique);

• 在safari中测试

2021年答案：

const unique = (arr) => [...new Set(arr)];
unique([1, 2, 2, 3, 4, 4, 5, 1]); // [1, 2, 3, 4, 5]

在这里，您只需从给定的数组创建一个set，然后将其转换回数组。我测量了性能，现在它几乎比我之前发布的旧答案中提出的方法快两倍。而且，它只是一行程序。
Updated fiddle

旧答案仅供参考

一般来说，你使用的方法是一个好主意。但是我可以提出一个解决方案，这将使算法快得多。

function unique(arr) {
    var u = {}, a = [];
    for(var i = 0, l = arr.length; i < l; ++i){
        if(!u.hasOwnProperty(arr[i])) {
            a.push(arr[i]);
            u[arr[i]] = 1;
        }
    }
    return a;
}

如您所见，这里只有一个循环。
我已经做了一个example来测试你和我的解决方案。试着玩一下。

另一种适合小列表的方法是模仿sort | uniq的Unix命令行方法：

function unique(a) {
        return a.sort().filter(function(value, index, array) {
            return (index === 0) || (value !== array[index-1]);
        });
    }

此函数对参数进行排序，然后筛选结果以忽略与其前导项相等的任何项。
基于键的方法很好，并且对于大量的条目有更好的性能特征（将n个条目插入哈希表的时间复杂度为O（n），而对数组排序的时间复杂度为O（n log n））。然而，这在小列表中不太可能被注意到。此外，在这个版本中，如果需要的话，您可以修改它以使用不同的排序或等式函数;使用散列键时，您会被JavaScript中的键相等概念所束缚。

这应该适用于任何对象，而不仅仅是字符串：

export const getUniqueList =  (a: Array<any>) : Array<any> => {

  const set = new Set<any>();

  for(let v of a){
      set.add(v);
  }

  return Array.from(set);

};

上述内容可以简化为：

export const getUniqueValues = (a: Array<any>) => {
   return Array.from(new Set(a));
};

：）

要获取唯一对象，可以使用JSON.stringify和JSON.parse：

const arr = [{test: "a"}, {test: "a"}];
const unique = Array.from(new Set(arr.map(JSON.stringify))).map(JSON.parse);
console.log(unique);

使用Object.keys可以给予字符串，如果你输入整型参数（uniq（[1，2，3]）=〉['1'，'2'，'3 ']。下面是一个使用Array.reduce的例子：

function uniq(list) {
    return list.reduce((acc, d) => acc.includes(d) ? acc : acc.concat(d), []);
}

这是一个老问题，我知道。但是，它是在一些谷歌搜索的顶部，所以我想补充说，你可以合并从@RobHague和@EugeneNaydenov的答案使用以下：

function unique(arr) {
  const u = {};
  return arr.filter((v) => {
    return u[v] = !u.hasOwnProperty(v);
  });
};

您还可以通过添加以下内容来忽略 undefined 值（通常很方便）：

function unique(arr) {
  const u = {};
  return arr.filter((v) => {
    return u[v] = (v !== undefined && !u.hasOwnProperty(v));
  });
};

您可以在此处使用此解决方案：https://jsfiddle.net/s8d14v5n/

我发现其他的答案是相当复杂的没有收获，我可以看到。
我们可以使用Array的indexOf方法在推入之前验证项目是否存在于其中：

const duplicated_values = ['one', 'one', 'one', 'one', 'two', 'three', 'three', 'four'];
const unique_list = [];

duplicated_values.forEach(value => {
  if (unique_list.indexOf(value) === -1) {
    unique_list.push(value);
  }
});

console.log(unique_list);

这也适用于任何类型的变量，甚至是对象（假设标识符实际上引用了同一个实体，仅仅是等价的对象并不被视为相同）。

怎么样

function unique(list) {
      for (i = 0; i<list.length; i++) {
        for (j=i+1; j<list.length; j++) {
          if (list[i] == list[j]) {
            list.splice(j, 1);
          }
        }
      }
    }