清洁解决方案

export abstract class Serializable<T> {
  equalTo(t: Serializable<T>): boolean {
    return this.hashCode() === t.hashCode();
  }
  hashCode(): string {
    throw new Error('Not Implemented');
  }
}

export interface UserFields {
  firstName: string;
  lastName: string;
}

export class User extends Serializable<User> {
  constructor(private readonly fields: UserFields) {
    super();
  }
  override hashCode(): string {
    return `${this.fields.firstName},${this.fields.lastName}`;
  }
}

const list: User[] = [
  new User({ firstName: 'first', lastName: 'user' }),
  new User({ firstName: 'first', lastName: 'user' }),
  new User({ firstName: 'second', lastName: 'user' }),
  new User({ firstName: 'second', lastName: 'user' }),
  new User({ firstName: 'third', lastName: 'user' }),
  new User({ firstName: 'third', lastName: 'user' }),
];

/**
 * Let's create an map
 */
const userHashMap = new Map<string, User>();


/**
 * We are adding each user into the map using user's hashCode value
 */
list.forEach((user) => userHashMap.set(user.hashCode(), user));

/**
 * Then getting the list of users from the map,
 */
const uniqueUsers = [...userHashMap.values()];


/**
 * Let's print and see we did right?
 */
console.log(uniqueUsers.map((e) => e.hashCode()));

现在我们可以在相同的键和相同的值的基础上唯一对象

 const arr = [{"name":"Joe", "age":17},{"name":"Bob", "age":17}, {"name":"Carl", "age": 35},{"name":"Joe", "age":17}]
    let unique = []
     for (let char of arr) {
     let check = unique.find(e=> JSON.stringify(e) == JSON.stringify(char))
     if(!check) {
     unique.push(char)
     }
     }
    console.log(unique)

/ / / /输出:::[{名称:“乔”,年龄:17},{名称:“Bob”,年龄:17},{名称:“卡尔”,年龄:35}]

您可以使用像这样的字典方法。基本上，你在“字典”中指定你想要不同的值作为键(这里我们使用数组作为对象以避免使用字典模式)。如果该键不存在，则将该值添加为distinct。

下面是一个工作演示:

数组var =[{“名称”:“乔”,“年龄”:17},{“名称”:“鲍勃”,“年龄”:17},{“名称”:“卡尔”,“年龄”:35}); Var unique = []; Var distinct = []; 对于(设I = 0;I < array.length;我+ +){ 如果(!独特[array[我].age]) { distinct.push(数组[我].age); 独特的[[我]数组。年龄:1岁; } } var d = document.getElementById("d"); d.innerHTML = "" + distinct; < div id = " d " > < / div >

这将是O(n)其中n是数组中对象的数量m是唯一值的数量。没有比O(n)更快的方法了，因为每个值必须至少检查一次。

以前的版本使用对象，for in。这些都是小的性质，并已在上面进行了小的更新。然而，原始jsperf的两个版本之间的性能似乎有所提高的原因是由于数据样本量太小。因此，前一个版本中的主要比较是查看内部映射和过滤器使用与字典模式查找之间的差异。

如上所述，我更新了上面的代码，但是，我也更新了jsperf以查找1000个对象而不是3个对象。3忽略了许多涉及的性能缺陷(过时的jsperf)。

性能

https://jsperf.com/filter-vs-dictionary-more-data当我运行这个字典是96%快。

如果你使用的是ES6/ES2015或更高版本，你可以这样做:

const data = [
  { group: 'A', name: 'SD' }, 
  { group: 'B', name: 'FI' }, 
  { group: 'A', name: 'MM' },
  { group: 'B', name: 'CO'}
];
const unique = [...new Set(data.map(item => item.group))]; // [ 'A', 'B']

这里有一个如何做的例子。

以防你需要整个对象的唯一性

const _ = require('lodash');

var objects = [
  { 'x': 1, 'y': 2 },
  { 'y': 1, 'x': 2 },
  { 'x': 2, 'y': 1 },
  { 'x': 1, 'y': 2 }
];

_.uniqWith(objects, _.isEqual);

[对象{x: 1, y: 2}，对象{x: 2, y: 1}]

如果这是PHP，我会建立一个数组的键和array_keys在最后，但JS没有这样的奢侈。相反，试试这个:

var flags = [], output = [], l = array.length, i;
for( i=0; i<l; i++) {
    if( flags[array[i].age]) continue;
    flags[array[i].age] = true;
    output.push(array[i].age);
}