function dedupe(arr = [], fnCheck = _ => _) {const set = new Set();let len = arr.length;
for (let i = 0; i < len; i++) {const primitive = fnCheck(arr[i]);if (set.has(primitive)) {// duplicate, cut itarr.splice(i, 1);i--;len--;} else {// new item, add itset.add(primitive);}}
return arr;}
const test = [{video:{slug: "a"}},{video:{slug: "a"}},{video:{slug: "b"}},{video:{slug: "c"}},{video:{slug: "c"}}]console.log(dedupe(test, x => x.video.slug));
// [{video:{slug: "a"}}, {video:{slug: "b"}}, {video:{slug: "c"}}]

const uniqArray = array.filter((obj, idx, arr) => (arr.findIndex((o) => o.id === obj.id) === idx))

我们可以使用ES6集来做到这一点：

var duplicatesArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];var uniqueArray = [...new Set(duplicatesArray)];
console.log(uniqueArray); // [1,2,3,4,5]

如果您可以接受额外的依赖项，或者您的代码库中已经有一个库，您可以使用LoDash（或Underscore）从现有的数组中删除重复项。

用法

如果您的代码库中还没有它，请使用npm安装它：

npm install lodash

然后按如下方式使用它：

import _ from 'lodash';let idArray = _.uniq ([1,2,3,3,3]);console.dir(idArray);

外出：

[ 1, 2, 3 ]

您可以使用Ramda.js，一个功能性的javascript库来执行此操作：

var unique = R.uniq([1, 2, 1, 3, 1, 4])console.log(unique)

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.js"></script>

使用豆沙和标识lambda函数来做，只需在使用对象之前定义它

const _ = require('lodash');..._.uniqBy([{a:1,b:2},{a:1,b:2},{a:1,b:3}], v=>v.a.toString()+v.b.toString())_.uniq([1,2,3,3,'a','a','x'])

并将有：

[{a:1,b:2},{a:1,b:3}][1,2,3,'a','x']

（这是最简单的方法）

我有一个解决方案，使用es6减少和查找数组辅助方法来删除重复项。

let numbers = [2, 2, 3, 3, 5, 6, 6];
const removeDups = array => {return array.reduce((acc, inc) => {if (!acc.find(i => i === inc)) {acc.push(inc);}return acc;}, []);}
console.log(removeDups(numbers)); /// [2,3,5,6]

我有一个稍微不同的问题，我需要从数组中删除具有重复id属性的对象。

let objArr = [{id: '123'}, {id: '123'}, {id: '456'}];
objArr = objArr.reduce((acc, cur) => [...acc.filter((obj) => obj.id !== cur.id), cur], []);
console.log(objArr);

魔术

a.filter(e=>!(t[e]=e in t))

O（n）性能-我们假设您的数组在a和t={}中。解释这里（+杰普 imr。）

let unique = (a,t={}) => a.filter(e=>!(t[e]=e in t));
// "stand-alone" version working with global t:// a1.filter((t={},e=>!(t[e]=e in t)));
// Test datalet a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];
// Resultsconsole.log(JSON.stringify( unique(a1) ))console.log(JSON.stringify( unique(a2) ))console.log(JSON.stringify( unique(a3) ))

上面的Object答案在我使用Object的用例中似乎对我不起作用。

我将其修改如下：

var j = {};
this.forEach( function(v) {var typ = typeof v;var v = (typ === 'object') ? JSON.stringify(v) : v;
j[v + '::' + typ] = v;});
return Object.keys(j).map(function(v){if ( v.indexOf('::object') > -1 ) {return JSON.parse(j[v]);}
return j[v];});

这似乎现在适用于对象、数组、具有混合值的数组、布尔值等。

过滤掉未定义和空值，因为大多数时候您不需要它们。

const uniques = myArray.filter(e => e).filter((e, i, a) => a.indexOf(e) === i);

或

const uniques = [...new Set(myArray.filter(e => e))];

有时我需要从对象数组中获取唯一的出现。Lodash似乎是一个不错的助手，但我不认为过滤数组可以证明向项目添加依赖项是合理的。

让我们假设在比较属性时比较两个对象的姿势，例如id。

const a = [{id: 3}, {id: 4}, {id: 3}, {id: 5}, {id: 5}, {id: 5}];

由于我们都喜欢一行代码片段，以下是如何做到这一点：

a.reduce((acc, curr) => acc.find(e => e.id === curr.id) ? acc : [...acc, curr], [])

这个解决方案应该非常快，并且在许多情况下都能奏效。

1. 将索引数组项转换为对象键

2. 使用Object.keys函数

   var indexArray = ["hi","welcome","welcome",1,-9];var keyArray = {};indexArray.forEach(function(item){ keyArray[item]=null; });var uniqueArray = Object.keys(keyArray);

我有一个简单的例子，我们可以从对象中具有重复id的数组中删除对象，

  let data = new Array({id: 1},{id: 2},{id: 3},{id: 1},{id: 3});let unique = [];let tempArr = [];console.log('before', data);data.forEach((value, index) => {if (unique.indexOf(value.id) === -1) {unique.push(value.id);} else {tempArr.push(index);}});tempArr.reverse();tempArr.forEach(ele => {data.splice(ele, 1);});console.log(data);

现在使用集合，您可以删除重复项并将它们转换回数组。

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
console.log([...new Set(names)])

另一种解决方案是使用排序和过滤器

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];var namesSorted = names.sort();const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);console.log(result);

很多人已经提到使用…

[...new Set(arr)];

这是一个很好的解决方案，但我更喜欢使用.filter的解决方案。在我看来，过滤器是获得唯一值的更自然的方法。你有效地删除了重复项，从数组中删除元素正是过滤器的目的。它还可以让你链接.map、.reduce和其他.filter调用。我设计了这个解决方案…

const unique = () => {let cache;return (elem, index, array) => {if (!cache) cache = new Set(array);return cache.delete(elem);};};
myArray.filter(unique());

需要注意的是，您需要一个闭包，但我认为这是一个值得的权衡。就性能而言，它比我看到的使用.filter的其他解决方案性能更高，但性能比[...new Set(arr)]差。

另见我的github包年轻

重复数据删除通常需要给定类型的等号操作符。然而，使用eq函数会阻止我们以有效的方式利用Set来确定重复项，因为Set会回退到===。正如你所知道的，===不适用于引用类型。所以如果卡住了，我们会很友好，对吧？

解决的方法是使用一个转换器函数，它允许我们将（引用）类型转换为我们可以使用Set实际查找的内容。例如，我们可以使用哈希函数，或者JSON.stringify数据结构，如果它不包含任何函数。

通常我们只需要访问一个属性，然后我们可以比较它而不是Object的引用。

以下是满足这些要求的两个组合子：

const dedupeOn = k => xs => {const s = new Set();
return xs.filter(o =>s.has(o[k])? null: (s.add(o[k]), o[k]));};
const dedupeBy = f => xs => {const s = new Set();
return xs.filter(x => {const r = f(x);    
return s.has(r)? null: (s.add(r), x);});};
const xs = [{foo: "a"}, {foo: "b"}, {foo: "A"}, {foo: "b"}, {foo: "c"}];
console.log(dedupeOn("foo") (xs)); // [{foo: "a"}, {foo: "b"}, {foo: "A"}, {foo: "c"}]
console.log(dedupeBy(o => o.foo.toLowerCase()) (xs)); // [{foo: "a"}, {foo: "b"}, {foo: "c"}]

有了这些组合子，我们可以非常灵活地处理各种消重问题。这不是快速方法，而是最具表现力和最通用的方法。

[...new Set(duplicates)]

这是最简单的一个，引用自MDN Web文档。

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

这已经回答了很多，但它没有解决我的特殊需求。

很多答案是这样的：

a.filter((item, pos, self) => self.indexOf(item) === pos);

但这不适用于复杂对象的数组。

假设我们有一个这样的数组：

const a = [{ age: 4, name: 'fluffy' },{ age: 5, name: 'spot' },{ age: 2, name: 'fluffy' },{ age: 3, name: 'toby' },];

如果我们想要具有唯一名称的对象，我们应该使用array.prototype.findIndex而不是array.prototype.indexOf：

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

你可以试试这个：

function removeDuplicates(arr){var temp = arr.sort();for(i = 0; i < temp.length; i++){if(temp[i] == temp[i + 1]){temp.splice(i,1);i--;}}return temp;}

如果您只想获取唯一元素并删除重复一次的元素，您可以这样做：

let array = [2, 3, 4, 1, 2, 8, 1, 1, 2, 9, 3, 5, 3, 4, 8, 4];
function removeDuplicates(inputArray) {let output = [];let countObject = {};
for (value of array) {countObject[value] = (countObject[value] || 0) + 1;}
for (key in countObject) {if (countObject[key] === 1) {output.push(key);}}
return output;}
console.log(removeDuplicates(array));

你根本不需要. indexOf（）；你可以这样做O（n）：

function SelectDistinct(array) {const seenIt = new Set();
return array.filter(function (val) {if (seenIt.has(val)) {return false;}
seenIt.add(val);
return true;});}
var hasDuplicates = [1,2,3,4,5,5,6,7,7];console.log(SelectDistinct(hasDuplicates)) //[1,2,3,4,5,6,7]

如果您不想使用. filter（）：

function SelectDistinct(array) {const seenIt = new Set();const distinct = [];
for (let i = 0; i < array.length; i++) {const value = array[i];
if (!seenIt.has(value)) {seenIt.add(value);distinct.push(value);}}    
return distinct;/* you could also drop the 'distinct' array and return 'Array.from(seenIt)', which converts the set object to an array */}

最简单的方法是将值转换为字符串以过滤嵌套对象值。

const uniq = (arg = []) => {const stringifyedArg = arg.map(value => JSON.stringify(value))return arg.filter((value, index, self) => {if (typeof value === 'object')return stringifyedArg.indexOf(JSON.stringify(value)) === indexreturn self.indexOf(value) === index})}
console.log(uniq([21, 'twenty one', 21])) // [21, 'twenty one']console.log(uniq([{ a: 21 }, { a: 'twenty one' }, { a: 21 }])) // [{a: 21}, {a: 'twenty one'}]

对于具有一些唯一id的基于对象的数组，我有一个简单的解决方案，您可以通过它对线性复杂性进行排序

function getUniqueArr(arr){const mapObj = {};arr.forEach(a => {mapObj[a.id] = a})return Object.values(mapObj);}

任务是从由任意类型（原始和非原始）组成的数组中获取唯一数组。

基于使用new Set(...)的方法并不新鲜。这里它被JSON.stringify(...)、JSON.parse(...)和[].map方法利用。优点是普遍性（适用于任何类型的数组），短ES6符号，在这种情况下可能是性能：

const dedupExample = [{ a: 1 },{ a: 1 },[ 1, 2 ],[ 1, 2 ],1,1,'1','1']
const getUniqArrDeep = arr => {const arrStr = arr.map(item => JSON.stringify(item))return [...new Set(arrStr)].map(item => JSON.parse(item))}
console.info(getUniqArrDeep(dedupExample))/* [ {a: 1}, [1, 2], 1, '1' ] */

在我的解决方案中，我在过滤之前对数据进行排序：

const uniqSortedArray = dataArray.sort().filter((v, idx, t) => idx==0 || v != t[idx-1]);

在查看了这里的所有90+答案后，我发现还有一个空间：

Array.includes有一个非常方便的第二个参数："FromIndex"是否必选，因此通过使用它，filter回调方法的每次迭代都会搜索阵列，从[current index] + 1开始，保证不会在查找中包含目前过滤项，并且还节省了时间。

注意-此解决方案不保留顺序，因为它从从左到右中删除了重复的项目，但如果数组是对象的集合，它将赢得Set技巧。

//                🚩              🚩 🚩var list = [0,1,2,2,3,'a','b',4,5,2,'a']
console.log(list.filter((v,i) => !list.includes(v,i+1)))
// [0,1,3,"b",4,5,2,"a"]

说明：

例如，假设filter函数当前正在索引2处迭代，并且该索引处的值恰好是2。然后扫描重复项的数组部分（includes方法）是之后索引2（i+1）的所有内容：

           👇                    👇[0, 1, 2,   2 ,3 ,'a', 'b', 4, 5, 2, 'a']👆   |---------------------------|

由于当前过滤的项目的值2包含在数组的其余部分中，因此它将被过滤掉，因为前导感叹号否定了过滤规则。

如果顺序很重要，请使用此方法：

//                🚩              🚩 🚩var list = [0,1,2,2,3,'a','b',4,5,2,'a']
console.log(// Initialize with empty array and fill with non-duplicateslist.reduce((acc, v) => (!acc.includes(v) && acc.push(v), acc), []))
// [0,1,2,3,"a","b",4,5]

使用One Liner在对象数组中查找唯一

const uniqueBy = (x,f)=>Object.values(x.reduce((a,b)=>((a[f(b)]=b),a),{}));// f -> should must return string because it will be use as key
const data = [{ comment: "abc", forItem: 1, inModule: 1 },{ comment: "abc", forItem: 1, inModule: 1 },{ comment: "xyz", forItem: 1, inModule: 2 },{ comment: "xyz", forItem: 1, inModule: 2 },];
uniqueBy(data, (x) => x.forItem +'-'+ x.inModule); // find unique by item with module// output// [//   { comment: "abc", forItem: 1, inModule: 1 },//   { comment: "xyz", forItem: 1, inModule: 2 },// ];
// can also use for strings and number or other primitive values
uniqueBy([1, 2, 2, 1], (v) => v); // [1, 2]uniqueBy(["a", "b", "a"], (v) => v); // ['a', 'b']
uniqueBy([{ id: 1, name: "abc" },{ id: 2, name: "xyz" },{ id: 1, name: "abc" },],(v) => v.id);// output// [//   { id: 1, name: "abc" },//   { id: 2, name: "xyz" },// ];

这是一个几乎是单行的O（n），保留第一个元素，并且可以将您正在使用的字段分开。

这是函数式编程中一个非常常见的技术——你使用reduce来构建一个你返回的数组。由于我们这样构建数组，我们保证得到一个稳定的顺序，与[...new Set(array)]方法不同。我们仍然使用Set来确保我们没有重复，所以我们的累加器同时包含Set和我们正在构建的数组。

const removeDuplicates = (arr) =>arr.reduce(([set, acc], item) => set.has(item) ? [set, acc] : [set.add(item), (acc.push(item), acc)],[new Set(), []])[1]

上面的方法适用于简单的值，但不适用于对象，类似于[...new Set(array)]的分解方式。如果项目是包含id属性的对象，你会做：

const removeDuplicates = (arr) =>arr.reduce(([set, acc], item) => set.has(item.id) ? [set, acc] : [set.add(item.id), (acc.push(item), acc)],[new Set(), []])[1]

删除重复项可能有两种情况。首先，所有的数据都不是对象，其次，所有的数据都是对象。

如果所有数据都是任何类型的原始数据类型，如int，浮点数，字符串等，那么您可以遵循这个

const uniqueArray = [...new Set(oldArray)]

但是假设你的数组包含像bellow这样的JS对象

{id: 1,name: 'rony',email: 'rony@example.com'}

然后得到所有独特的物体，你可以按照这个

let uniqueIds = [];const uniqueUsers = oldArray.filter(item => {if(uniqueIds.includes(item.id)){return false;}else{uniqueIds.push(item.id);return true;}})

您还可以使用此方法使任何类型的数组变得唯一。只需将跟踪键保留在uniqueIds数组上。

对我来说这是最简单的解决办法

// A way to check if the arrays are equalconst a = ['A', 'B', 'C'].sort().toString()const b = ['A', 'C', 'B'].sort().toString()
console.log(a === b); // true

// Test Caseconst data = [{ group: 'A', name: 'SD' },{ group: 'B', name: 'FI' },{ group: 'A', name: 'SD' },{ group: 'B', name: 'CO' }];
// Return a new Array without dublocatesfunction unique(data) {return data.reduce(function (accumulator, currentValue) {// Convert to string in order to check if they are the same value.const currentKeys = Object.keys(currentValue).sort().toString();const currentValues = Object.values(currentValue).sort().toString();
let hasObject = false    
for (const obj of accumulator) {// Convert keys and values into strings so we can// see if they are equal with the currentValueconst keys = Object.keys(obj).sort().toString();const values = Object.values(obj).sort().toString();// Check if keys and values are equalif (keys === currentKeys && values === currentValues) {hasObject = true}}
// Push the object if it does not exist already.if (!hasObject) {accumulator.push(currentValue)}
return accumulator}, []);}
// Run Test Caseconsole.log(unique(data)); // [ { group: 'A', name: 'SD' }, { group: 'B', name: 'FI' }, { group: 'B', name: 'CO' } ]

使用猫鼬，我有一个对象名称的数组要处理。

我有一个对象ID的数组/列表要处理，首先需要设置为字符串，然后在唯一集之后，修改回对象ID。

var mongoose = require('mongoose')
var ids = [ObjectId("1"), ObjectId("2"), ObjectId("3")]
var toStringIds = ids.map(e => '' + e)let uniqueIds = [...new Set(toStringIds)]uniqueIds = uniqueIds.map(b => mongoose.Types.ObjectId(b))

console.log("uniqueIds :", uniqueIds)

我会对数组进行排序，然后所有重复项都是邻居。然后遍历数组一次并消除所有重复项。

function getUniques(array) {var l = array.lengthif(l > 1) {// get a cloned copy and sort itarray = [...array].sort();var i = 1, j = 0;while(i < l) {if(array[i] != array[j]) {array[++j] = array[i];}i++;}array.length = j + 1;}return array;}

您可以简单地使用内置函数Array.prototype.filter()和Array.prototype.indexOf()

array.filter((x, y) => array.indexOf(x) == y)

var arr = [1, 2, 3, 3, 4, 5, 5, 5, 6, 7, 8, 9, 6, 9];
var newarr = arr.filter((x, y) => arr.indexOf(x) == y);
console.log(newarr);

如前所述，如果您可以使用，[...new Set(values)]是最佳选择。

否则，这是一个不会为每个索引迭代数组的单行代码：

values.sort().filter((val, index, arr) => index === 0 ? true : val !== arr[index - 1]);

这只是将每个值与之前的值进行比较。结果将被排序。

示例：

let values = [ 1, 2, 3, 3, 4, 5, 5, 5, 4, 4, 4, 5, 1, 1, 1, 3, 3 ];let unique = values.sort().filter((val, index, arr) => index === 0 ? true : val !== arr[index - 1]);console.log(unique);

如果您想删除重复项，返回整个对象并希望使用ES6 Set和Map语法，并且只运行一个循环，您可以尝试此操作，以获得唯一的id：

const collection = [{id:3, name: "A"}, {id:3, name: "B"}, {id:4, name: "C"}, {id:5, name: "D"}]
function returnUnique(itemsCollection){const itemsMap = new Map();
itemsCollection.forEach(item => {if(itemsMap.size === 0){itemsMap.set(item.id, item)}else if(!itemsMap.has(item.id)){itemsMap.set(item.id, item)}});  
return [...new Set(itemsMap.values())];}
console.log(returnUnique(collection));

这是另一种使用比较器的方法（我更关心干净的代码而不是性能）：

const list = [{name: "Meier"},{name: "Hans"},{name: "Meier"},]const compare = (a, b) => a.name.localeCompare(b.name);const uniqueNames = list.makeUnique(compare);uniqueNames.pushIfAbsent({name: "Hans"}, compare);

原型声明：

declare global {interface Array<T>  {pushIfAbsent(item: T, compare:(a:T, b:T)=>number): number;}interface Array<T>  {makeUnique(compare:(a:T, b:T)=>number): Array<T>;}}Array.prototype.pushIfAbsent = function <T>(this:T[], item:T, compare:(a:T, b:T)=>number) {if (!this.find(existing => compare(existing, item)===0)) {return this.push(item)} else {return this.length;}}Array.prototype.makeUnique = function <T>(this:T[], compare:(a:T, b:T)=>number) {return this.filter((existing, index, self) => self.findIndex(item => compare(existing, item) == 0) == index);}

一种可扩展、快速、高效且易于阅读的现代方法，使用it-ops库：

import {pipe, distinct} from 'iter-ops';
const input = [1, 1, 2, 2, 2, 3]; // our data
const i = pipe(input, distinct()); // distinct iterable
console.log([...i]); //=> [1, 2, 3]

如果您的输入是一个对象数组，您只需为distinct运算符提供一个键选择器。

并不是对原始问题的直接字面答案，因为我更喜欢一开始就不在数组中包含重复值。所以这是我的UniqueArray：

class UniqueArray extends Array {constructor(...args) {super(...new Set(args));}push(...args) {for (const a of args) if (!this.includes(a)) super.push(a);return this.length;}unshift(...args) {for (const a of args.reverse()) if (!this.includes(a)) super.unshift(a);return this.length;}concat(...args) {var r = new UniqueArray(...this);for (const a of args) r.push(...a);return r;}}

> a = new UniqueArray(1,2,3,1,2,4,5,1)UniqueArray(5) [ 1, 2, 3, 4, 5 ]> a.push(1,4,6)6> aUniqueArray(6) [ 1, 2, 3, 4, 5, 6 ]> a.unshift(1)6> aUniqueArray(6) [ 1, 2, 3, 4, 5, 6 ]> a.unshift(0)7> aUniqueArray(7) [0, 1, 2, 3,4, 5, 6]> a.concat(2,3,7)UniqueArray(8) [0, 1, 2, 3,4, 5, 6, 7]

使用ES6new Set

var array = [3,7,5,3,2,5,2,7];var unique_array = [...new Set(array)];console.log(unique_array);    // output = [3,7,5,2]

使用for Loop

var array = [3,7,5,3,2,5,2,7];
for(var i=0;i<array.length;i++) {for(var j=i+1;j<array.length;j++) {if(array[i]===array[j]) {array.splice(j,1);}}}console.log(array); // output = [3,7,5,2]

使用#0删除重复项。

Array重复

const withDuplicates = [2, 2, 5, 5, 1, 1, 2, 2, 3, 3];

使用Set获取一个没有重复项的新数组

const withoutDuplicates = Array.from(new Set(withDuplicates));

更短的版本

const withoutDuplicates = [...new Set(withDuplicates)];

结果：[2, 5, 1, 3]

已经有很多很好的答案了。这是我的方法。

var removeDuplicates = function(nums) {let filteredArr = [];nums.forEach((item) => {if(!filteredArr.includes(item)) {filteredArr.push(item);}})
return filteredArr;}

对于一个元组数组，我将把东西扔进Map并让它完成工作。使用这种方法，你必须注意你想要使用的键：

const arrayOfArraysWithDuplicates = [[1, 'AB'],[2, 'CD'],[3, 'EF'],[1, 'AB'],[2, 'CD'],[3, 'EF'],[3, 'GH'],]
const uniqueByFirstValue = new Map();const uniqueBySecondValue = new Map();
arrayOfArraysWithDuplicates.forEach((item) => {uniqueByFirstValue.set(item[0], item[1]);uniqueBySecondValue.set(item[1], item[0]);});
let uniqueList = Array.from( uniqueByFirstValue, ( [ value, name ] ) => ( [value, name] ) );
console.log('Unique by first value:');console.log(uniqueList);
uniqueList = Array.from( uniqueBySecondValue, ( [ value, name ] ) => ( [value, name] ) );
console.log('Unique by second value:');console.log(uniqueList);

输出：

Unique by first value:[ [ 1, 'AB' ], [ 2, 'CD' ], [ 3, 'GH' ] ]
Unique by second value:[ [ 'AB', 1 ], [ 'CD', 2 ], [ 'EF', 3 ], [ 'GH', 3 ] ]

永远记住，内置方法易于使用。但请记住，它们具有复杂性。

基本逻辑是最好的，没有隐藏的复杂性。

let list = [1, 1, 2, 100, 2] // your arraylet check = {}list = list.filter(item => {if(!check[item]) {check[item] = truereturn true;}})

或者使用，让check=[]如果您需要将来遍历检查的项目（虽然浪费内存）

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

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方法，而ush（）、long（）和for每个（）是常见的
• 使用闭包更易读性
• 在内存，垃圾回收机制和性能方面似乎比其他更好
• 更少的代码行：如果你根据行尾的位置分隔行，你只需要一行逻辑（所以你可以随心所欲地调用或重构这个一行代码）：

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

使用ES6（单行）

原始值的数组

let originalArr= ['a', 1, 'a', 2, '1'];
let uniqueArr = [...new Set(originalArr)];

对象的数组

let uniqueObjArr = [...new Map(originalObjArr.map((item) => [item["propertyName"], item])).values()];
const ObjArray = [{name: "Eva Devore",character: "Evandra",episodes: 15,},{name: "Alessia Medina",character: "Nixie",episodes: 15,},{name: "Kendall Drury",character: "DM",episodes: 15,},{name: "Thomas Taufan",character: "Antrius",episodes: 14,},{name: "Alessia Medina",character: "Nixie",episodes: 15,},];
let uniqueObjArray = [...new Map(ObjArray.map((item) => [item["id"], item])).values()];

您可以使用Set来消除重复项。

const originalNumbers = [1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 1, 2, 9];const uniqueNumbersSet = new Set(originalNumbers);
/** get the array back from the set */const uniqueNumbersArray = Array.from(uniqueNumbersSet);
/** uniqueNumbersArray outputs to: [1, 2, 3, 4, 5, 9] */

了解更多关于set：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

在ES6/以后

仅获取唯一值

  let a = [{ id: 1, name: "usman" },{ id: 2, name: "zia" },{ id: 3, name: "usman" },];const unique = [...new Set(a.map((item) => item.name))];console.log(unique); // ["usman", "zia"]

获取唯一对象

const myObjArray = [{ id: 1, name: "usman" },{ id: 2, name: "zia" },{ id: 3, name: "usman" },];// Creates an array of objects with unique "name" property values.let uniqueObjArray = [...new Map(myObjArray.map((item) => [item["name"], item])).values(),];
console.log("uniqueObjArray", uniqueObjArray);

尝试这样做：

let d_array = [1, 2, 2, 3, 'a', 'b', 'b', 'c'];d_array = d_array.filter((x,i)=>d_array.indexOf(x)===i);console.log(d_array); // [1, 2, 3, "a", "b", "c"]

它循环遍历数组，检查数组中同一条目的第一个找到的结果是否是当前索引，如果是，则允许它在数组中。

像这样的简单代码：

let arr = [1,'k',12,1,1,'k','12'];let distictArr=arr.filter((item, index, arr) => arr.indexOf(item) === index);
console.log(distictArr); // [1, 'k', 12, '12']

我想从对象数组中删除重复项。重复项具有相同的id。这是我所做的。

// prev dataconst prev = [{id: 1,name: "foo",},{id: 2,name: "baz",},{id: 1,name: "foo",},];
// method:// Step 1: put them in an object with the id as the key. Value of same id would get overriden.// Step 2: get all the values.
const tempObj = {};prev.forEach((n) => (tempObj[n.id] = n));const next = Object.values(tempObj);
// result[{id: 1,name: "foo",},{id: 2,name: "baz",}];