str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str是一个对象数组。存在具有相同值的对象（这里是一个小示例，有两个对象的item_id与2相同）。check（id）是一个函数，用于检查是否存在任何具有相同itemid的对象。如果存在，则返回false，否则返回true。根据该结果，将对象推入新的数组obj上述代码的输出为[｛“item_id”：1｝，｛“item_id”:2｝]

为懒惰的Typescript开发人员提供快速（运行时更少）和类型安全的答案：

export const uniqueBy = <T>( uniqueKey: keyof T, objects: T[]): T[] => {
  const ids = objects.map(object => object[uniqueKey]);
  return objects.filter((object, index) => !ids.includes(object[uniqueKey], index + 1));
} 

带有Map的一行程序（高性能，不保留顺序）

在数组arr中查找唯一id。

const arrUniq = [...new Map(arr.map(v => [v.id, v])).values()]

如果订单很重要，请检查带过滤器的解决方案：带过滤器的方案

由数组arr中的多个财产（位置和名称）唯一

const arrUniq = [...new Map(arr.map(v => [JSON.stringify([v.place,v.name]), v])).values()]

由数组arr中的所有财产唯一

const arrUniq = [...new Map(arr.map(v => [JSON.stringify(v), v])).values()]

保留数组arr中的第一次出现

const arrUniq = [...new Map(arr.slice().reverse().map(v => [v.id, v])).values()].reverse()

TypeScript函数将数组过滤到其唯一元素，其中唯一性由给定的谓词函数决定：

function uniqueByPredicate<T>(arr: T[], predicate: (a: T, b: T) => boolean): T[] {
  return arr.filter((v1, i, a) => a.findIndex(v2 => predicate(v1, v2)) === i);
}

不打字员：

function uniqueByPredicate(arr, predicate) {
  return l.filter((v1, i, a) => a.findIndex(v2 => predicate(v1, v2)) === i);
}

这是一种带有Set和一些闭包的单循环方法，以防止在函数声明之外使用声明的变量，并获得简短的外观。

常量array=[{地点：“here”，名称：“stuff”，n:1}，{地方：“there”，名称“morestuff”，keys=['place'，'name']，unique=阵列过滤器(（s=>o=>（v=>！s.has（v）&&s.add（v））（keys.map（k=>o[k]）.join（'|'）））（新设置）);console.log（唯一）；.作为控制台包装｛最大高度：100%！重要；顶部：0；｝

这种方式对我很有效：

function arrayUnique(arr, uniqueKey) {
  const flagList = new Set()
  return arr.filter(function(item) {
    if (!flagList.has(item[uniqueKey])) {
      flagList.add(item[uniqueKey])
      return true
    }
  })
}
const data = [
  {
    name: 'Kyle',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Kyle',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Emily',
    occupation: 'Web Designer'
  },
  {
    name: 'Melissa',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Tom',
    occupation: 'Web Developer'
  },
  {
    name: 'Tom',
    occupation: 'Web Developer'
  }
]
console.table(arrayUnique(data, 'name'))// work well

打印输出

┌─────────┬───────────┬────────────────────┐
│ (index) │   name    │     occupation     │
├─────────┼───────────┼────────────────────┤
│    0    │  'Kyle'   │ 'Fashion Designer' │
│    1    │  'Emily'  │   'Web Designer'   │
│    2    │ 'Melissa' │ 'Fashion Designer' │
│    3    │   'Tom'   │  'Web Developer'   │
└─────────┴───────────┴────────────────────┘

ES5:

function arrayUnique(arr, uniqueKey) {
  const flagList = []
  return arr.filter(function(item) {
    if (flagList.indexOf(item[uniqueKey]) === -1) {
      flagList.push(item[uniqueKey])
      return true
    }
  })
}

这两种方式更简单易懂。