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

高效且简洁的方法，使用iter-ops库：

import {pipe, distinct, map} from 'iter-ops';

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

const i = pipe(
    array,
    distinct(a => a.age),
    map(m => m.age)
);

const uniqueAges = [...i]; //=> [17, 35]

const getDistinct = (arr = [], field) => {
    const distinctMap = {};
    arr.forEach(item => {
        if(!distinctMap[item[field]]) {
            distinctMap[item[field]] = item;
        }
    });
    const distinctFields = Object.keys(distinctMap);
    const distinctElements = Object.values(distinctMap);
    return {distinctFields, distinctElements}
}
const array = 
    [
        {"name":"Joe", "age":17}, 
        {"name":"Bob", "age":17}, 
        {"name":"Carl", "age": 35}
    ]
console.log(JSON.stringify(getDistinct(array, "age")));
/*output will be => 
  {
    distinctFields: ["17", "35"],
    distinctElements: [
      { name: "Joe", age: 17 },
      { name: "Carl", age: 35 }
    ]
  }*/

如果你的数组是对象数组，你可以使用这段代码。

getUniqueArray = (array: MyData[]) => {
    return array.filter((elem, index) => array.findIndex(obj => obj.value == elem.value) === index);
}

其中MyData的格式如下：

export interface MyData{
    value: string,
    name: string
}

使用新的 Ecma 特性很棒，但并非所有用户都可用。

以下代码将向全局数组对象附加一个名为distinct的新函数。 如果您正在尝试获取对象数组的不同值，则可以传递该类型的值的名称以获取不同的值。

Array.prototype.distinct = function(item){   var results = [];
for (var i = 0, l = this.length; i < l; i++)
    if (!item){
        if (results.indexOf(this[i]) === -1)
            results.push(this[i]);
        } else {
        if (results.indexOf(this[i][item]) === -1)
            results.push(this[i][item]);
    }
return results;};

请查看CodePen中的我的帖子以获取演示。

从一组键中获取不同值的方法。

您可以从这里获取给定代码，并添加仅针对所需键的映射，以获取唯一对象值的数组。

const
    listOfTags = [{ id: 1, label: "Hello", color: "red", sorting: 0 }, { id: 2, label: "World", color: "green", sorting: 1 }, { id: 3, label: "Hello", color: "blue", sorting: 4 }, { id: 4, label: "Sunshine", color: "yellow", sorting: 5 }, { id: 5, label: "Hello", color: "red", sorting: 6 }],
    keys = ['label', 'color'],
    filtered = listOfTags.filter(
        (s => o =>
            (k => !s.has(k) && s.add(k))
            (keys.map(k => o[k]).join('|'))
        )(new Set)
    )
    result = filtered.map(o => Object.fromEntries(keys.map(k => [k, o[k]])));

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

如果你被困在使用ES5中，或者由于某些原因不能使用new Set或new Map，并且你需要一个包含具有唯一键的值的数组（而不仅仅是唯一键的数组），那么可以使用以下方法：

function distinctBy(key, array) {
    var keys = array.map(function (value) { return value[key]; });
    return array.filter(function (value, index) { return keys.indexOf(value[key]) === index; });
}

或者在TypeScript中使用类型安全的等效方式：

public distinctBy<T>(key: keyof T, array: T[]) {
    const keys = array.map(value => value[key]);
    return array.filter((value, index) => keys.indexOf(value[key]) === index);
}

使用方法：

var distinctPeople = distinctBy('age', people);

• 返回唯一键的数组，而不是对象（例如返回年龄列表，而不是具有唯一年龄的人）；
• 使用 ES6、new Set、new Map 等可能不可用的内容；
• 没有可配置的键（例如将 .age 硬编码到 distinct 函数中）；
• 假设可以使用键索引数组，这并不总是正确的，TypeScript 不会允许。

此答案没有以上四个问题。

你可以使用lodash编写更简洁的代码。

方法1：嵌套方法

    let array = 
        [
            {"name":"Joe", "age":17}, 
            {"name":"Bob", "age":17}, 
            {"name":"Carl", "age": 35}
        ]
    let result = _.uniq(_.map(array,item=>item.age))

方法二：方法链或级联方法

    let array = 
        [
            {"name":"Joe", "age":17}, 
            {"name":"Bob", "age":17}, 
            {"name":"Carl", "age": 35}
        ]
    let result = _.chain(array).map(item=>item.age).uniq().value()

您可以从https://lodash.com/docs/4.17.15#uniq了解有关lodash的uniq()方法的信息。

关于这个函数，我想说两句：

var result = [];
for (var len = array.length, i = 0; i < len; ++i) {
  var age = array[i].age;
  if (result.indexOf(age) > -1) continue;
  result.push(age);
}

你可以在这里查看结果（第8种方法） http://jsperf.com/distinct-values-from-array/3