如何从 JavaScript 中的对象数组中获取不同的值？

如果您使用的是 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']

Here 是有关如何执行此操作的示例。

---

对于那些想要返回具有键唯一属性的对象的人

常量数组 = [ { "name": "Joe", "age": 17 }, { "name": "Bob", "age": 17 }, { "name": "Carl", "age": 35 } ] 常量键 = '年龄'; const arrayUniqueByKey = [...new Map(array.map(item => [item[key], item])).values()]; console.log(arrayUniqueByKey); /*OUTPUT [ { "name": "Bob", "age": 17 }, { "name": "Carl", "age": 35 } ] */ // 注意：这将选择最后一个重复的项目名单。

---

使用 ES6

let array = [
  { "name": "Joe", "age": 17 },
  { "name": "Bob", "age": 17 },
  { "name": "Carl", "age": 35 }
];
array.map(item => item.age)
  .filter((value, index, self) => self.indexOf(value) === index)

> [17, 35]

---

使用 ES6 功能，您可以执行以下操作：

const uniqueAges = [...new Set( array.map(obj => obj.age)) ];

---

如果这是 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);
}

---

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

这是一个工作演示：

var 数组 = [{"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35 }]; var 唯一 = [];变种不同 = []; for( let i = 0; i < array.length; i++ ){ if( !unique[array[i].age]){ distinct.push(array[i].age);唯一[数组[i].age] = 1; } } var d = document.getElementById("d"); d.innerHTML = "" + 不同的；

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

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

如前所述，我已经更新了上面的代码，但是，我还更新了 jsperf 以查看 1000 个对象而不是 3 个。3 忽略了许多涉及的性能缺陷（obsolete jsperf）。

表现

https://jsperf.com/filter-vs-dictionary-more-data 当我运行这本词典时，速度提高了 96%。

https://i.stack.imgur.com/HZTBu.png

---

从 2017 年 8 月 25 日起，您将通过 ES6 for Typescript 使用新的 Set 来解决此问题

Array.from(new Set(yourArray.map((item: any) => item.id)))

---

我只是映射和删除重复：

var ages = array.map(function(obj) { return obj.age; });
ages = ages.filter(function(v,i) { return ages.indexOf(v) == i; });

console.log(ages); //=> [17, 35]

编辑：好吧！就性能而言，这不是最有效的方法，而是最简单最易读的 IMO。如果您真的关心微优化或者您拥有大量数据，那么常规 for 循环将更加“高效”。

---

var unique = array
    .map(p => p.age)
    .filter((age, index, arr) => arr.indexOf(age) == index)
    .sort(); // sorting is optional

// or in ES6

var unique = [...new Set(array.map(p => p.age))];

// or with lodash

var unique = _.uniq(_.map(array, 'age'));

ES6 示例

const data = [
  { name: "Joe", age: 17}, 
  { name: "Bob", age: 17}, 
  { name: "Carl", age: 35}
];

const arr = data.map(p => p.age); // [17, 17, 35]
const s = new Set(arr); // {17, 35} a set removes duplications, but it's still a set
const unique = [...s]; // [17, 35] Use the spread operator to transform a set into an Array
// or use Array.from to transform a set into an array
const unique2 = Array.from(s); // [17, 35]

---

已经有很多有效的答案，但我想添加一个仅使用 reduce() 方法的答案，因为它干净且简单。

function uniqueBy(arr, prop){
  return arr.reduce((a, d) => {
    if (!a.includes(d[prop])) { a.push(d[prop]); }
    return a;
  }, []);
}

像这样使用它：

var array = [
  {"name": "Joe", "age": 17}, 
  {"name": "Bob", "age": 17}, 
  {"name": "Carl", "age": 35}
];

var ages = uniqueBy(array, "age");
console.log(ages); // [17, 35]

---

常量数组 = [ {"id":"93","name":"CVAM_NGP_KW"}, {"id":"94","name":"CVAM_NGP_PB"}, {"id":"93"," name":"CVAM_NGP_KW"}, {"id":"94","name":"CVAM_NGP_PB"} ] function uniq(array, field) { return array.reduce((accumulator, current) => { if(! accumulator.includes(current[field])) { accumulator.push(current[field]) } return accumulator; }, [] ) } const ids = uniq(array, 'id'); console.log(ids) /* 输出 ["93", "94"] */

---

如果您需要整个对象，这与 ES6 版本略有不同：

let arr = [
    {"name":"Joe", "age":17}, 
    {"name":"Bob", "age":17}, 
    {"name":"Carl", "age": 35}
]
arr.filter((a, i) => arr.findIndex((s) => a.age === s.age) === i) // [{"name":"Joe", "age":17}, {"name":"Carl", "age": 35}]

---

我有一个小解决方案

let data = [{id: 1}, {id: 2}, {id: 3}, {id: 2}, {id: 3}];

let result = data.filter((value, index, self) => self.findIndex((m) => m.id === value.id) === index);

---

@travis-j 答案的 forEach 版本（对现代浏览器和 Node JS 世界很有帮助）：

var unique = {};
var distinct = [];
array.forEach(function (x) {
  if (!unique[x.age]) {
    distinct.push(x.age);
    unique[x.age] = true;
  }
});

在 Chrome v29.0.1547 上快 34%：http://jsperf.com/filter-versus-dictionary/3

还有一个采用映射器函数的通用解决方案（比直接映射慢一点，但这是意料之中的）：

function uniqueBy(arr, fn) {
  var unique = {};
  var distinct = [];
  arr.forEach(function (x) {
    var key = fn(x);
    if (!unique[key]) {
      distinct.push(key);
      unique[key] = true;
    }
  });
  return distinct;
}

// usage
uniqueBy(array, function(x){return x.age;}); // outputs [17, 35]

---

我已经开始在所有新项目中默认使用 Underscore，这样我就不必考虑这些小的数据处理问题。

var array = [{"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35}];
console.log(_.chain(array).map(function(item) { return item.age }).uniq().value());

产生 [17, 35]。

---

这是解决此问题的另一种方法：

var result = {};
for(var i in array) {
    result[array[i].age] = null;
}

result = Object.keys(result);

或者

result = Object.values(result);

我不知道这个解决方案与其他解决方案相比有多快，但我喜欢更简洁的外观。 ;-)

编辑：好的，以上似乎是这里最慢的解决方案。

我在这里创建了一个性能测试用例：http://jsperf.com/distinct-values-from-array

我没有测试年龄（整数），而是选择比较名称（字符串）。

方法1（TS的解决方案）非常快。有趣的是，方法 7 优于所有其他解决方案，在这里我只是摆脱了 .indexOf() 并使用了它的“手动”实现，避免了循环函数调用：

var result = [];
loop1: for (var i = 0; i < array.length; i++) {
    var name = array[i].name;
    for (var i2 = 0; i2 < result.length; i2++) {
        if (result[i2] == name) {
            continue loop1;
        }
    }
    result.push(name);
}

使用 Safari 和 Firefox 的性能差异是惊人的，似乎 Chrome 在优化方面做得最好。

我不确定为什么上述片段与其他片段相比如此之快，也许比我更聪明的人有答案。 ;-)

---

使用 lodash

var array = [
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
];
_.chain(array).pluck('age').unique().value();
> [17, 35]

---

var 数组 = [ {"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35 } ];常量年龄 = [...new Set(array.reduce((a, c) => [...a, c.age], []))];控制台日志（年龄）；

---

常量数组 = [ { "name": "Joe", "age": 17 }, { "name": "Bob", "age": 17 }, { "name": "Carl", "age": 35 } ] 常量键 = '年龄'; const arrayUniqueByKey = [...new Map(array.map(item => [item[key], item])).values()]; console.log(arrayUniqueByKey);

---

使用 Maps 的简单不同过滤器：

让数组 = [ {"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35 } ];让数据 = 新地图（）； for (let obj of array) { data.set(obj.age, obj); } 放出 = [...data.values()];控制台.log(out);

---

使用 Lodash

var array = [
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
];

_.chain(array).map('age').unique().value();

返回 [17,35]

---

function get_unique_values_from_array_object(array,property){
    var unique = {};
    var distinct = [];
    for( var i in array ){
       if( typeof(unique[array[i][property]]) == "undefined"){
          distinct.push(array[i]);
       }
       unique[array[i][property]] = 0;
    }
    return distinct;
}

---

下划线.js _.uniq(_.pluck(array,"age"))

---

这是一个使用reduce、允许映射和维护插入顺序的通用解决方案。

项目：一个数组

mapper：将项目映射到条件的一元函数，或者为空以映射项目本身。

function distinct(items, mapper) {
    if (!mapper) mapper = (item)=>item;
    return items.map(mapper).reduce((acc, item) => {
        if (acc.indexOf(item) === -1) acc.push(item);
        return acc;
    }, []);
}

用法

const distinctLastNames = distinct(items, (item)=>item.lastName);
const distinctItems = distinct(items);

如果这是您的风格，您可以将其添加到您的 Array 原型中并省略 items 参数......

const distinctLastNames = items.distinct( (item)=>item.lastName) ) ;
const distinctItems = items.distinct() ;

您还可以使用 Set 而不是 Array 来加快匹配速度。

function distinct(items, mapper) {
    if (!mapper) mapper = (item)=>item;
    return items.map(mapper).reduce((acc, item) => {
        acc.add(item);
        return acc;
    }, new Set());
}

---

如果您想返回一个唯一的对象列表。这是另一种选择：

const unique = (arr, encoder=JSON.stringify, decoder=JSON.parse) =>
  [...new Set(arr.map(item => encoder(item)))].map(item => decoder(item));

这将变成这样：

unique([{"name": "john"}, {"name": "sarah"}, {"name": "john"}])

进入

[{"name": "john"}, {"name": "sarah"}]

这里的诀窍是我们首先使用 JSON.stringify 将项目编码为字符串，然后将其转换为 Set（这使得字符串列表唯一），然后我们使用 {2 将其转换回原始对象}。

---

var 数组 = [ {"name":"Joe", "age":17}, {"name":"Bob", "age":17}, {"name":"Carl", "age": 35 } ] console.log(Object.keys(array.reduce((r,{age}) => (r[age]='', r) , {})))

输出：

Array ["17", "35"]

---

刚找到这个，我认为它很有用

_.map(_.indexBy(records, '_id'), function(obj){return obj})

再次使用 underscore，所以如果您有这样的对象

var records = [{_id:1,name:'one', _id:2,name:'two', _id:1,name:'one'}]

它只会给你独特的对象。

这里发生的是 indexBy 返回这样的地图

{ 1:{_id:1,name:'one'}, 2:{_id:2,name:'two'} }

仅仅因为它是一张地图，所有的键都是唯一的。

然后我只是将此列表映射回数组。

如果您只需要不同的值

_.map(_.indexBy(records, '_id'), function(obj,key){return key})

请记住，key 作为字符串返回，因此，如果您需要整数，则应该这样做

_.map(_.indexBy(records, '_id'), function(obj,key){return parseInt(key)})

---

我认为您正在寻找 groupBy 功能（使用 Lodash）

_personsList = [{"name":"Joe", "age":17}, 
                {"name":"Bob", "age":17}, 
                {"name":"Carl", "age": 35}];
_uniqAgeList = _.groupBy(_personsList,"age");
_uniqAges = Object.keys(_uniqAgeList);

产生结果：

17,35

jsFiddle 演示：http://jsfiddle.net/4J2SX/201/

---

[...new Set([
    { "name": "Joe", "age": 17 },
    { "name": "Bob", "age": 17 },
    { "name": "Carl", "age": 35 }
  ].map(({ age }) => age))]

---

原始类型

var unique = [...new Set(array.map(item => item.pritiveAttribute))];

对于复杂类型，例如对象

var unique = [...new DeepSet(array.map(item => item.Object))];

export class DeepSet extends Set {

  add (o: any) {
    for (let i of this)
      if (this.deepCompare(o, i))
        return this;
    super.add.call(this, o);
    return this;
  };

  private deepCompare(o: any, i: any) {
    return JSON.stringify(o) === JSON.stringify(i)
  }
}

---