假设我有以下内容：
var array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
能够获得所有不同年龄的数组的最佳方法是什么，以便得到结果数组：
[17, 35]
我是否有某种方法可以替代地构建数据或更好的方法，这样我就不必遍历每个数组来检查“age”的值并检查另一个数组是否存在，如果没有则添加它？ / p>
如果有某种方式我可以在没有迭代的情况下拉出不同的年龄......
我想改进的当前无效方式......如果它意味着“数组”不是一个对象数组，而是具有一些唯一键的对象“地图”（即“1,2,3”）那也没关系。我只是在寻找性能最高效的方式。
以下是我目前的做法，但对我而言，迭代看起来效率很高，即使它确实有效......
var distinct = []
for (var i = 0; i < array.length; i++)
if (array[i].age not in distinct)
distinct.push(array[i].age)
答案 0 :(得分：393)
如果您使用的是ES6 / ES2015或更高版本，则可以这样做：
const unique = [...new Set(array.map(item => item.age))];
Here就是如何做到的一个例子。
答案 1 :(得分：103)
您可以使用像这样的字典方法。基本上，您将要分离的值指定为字典中的键。如果密钥不存在，则将该值添加为不同。
var unique = {};
var distinct = [];
for( var i in array ){
if( typeof(unique[array[i].age]) == "undefined"){
distinct.push(array[i].age);
}
unique[array[i].age] = 0;
}
这是一个有效的演示：http://jsfiddle.net/jbUKP/1
这将是O（n），其中n是数组中对象的数量，m是唯一值的数量。没有比O（n）更快的方法，因为你必须至少检查一次每个值。
<强>性能
http://jsperf.com/filter-versus-dictionary当我运行这本词典的速度提高了30％。
答案 2 :(得分：103)
如果这是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);
}
答案 3 :(得分：99)
使用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]
答案 4 :(得分：56)
截至2017年8月25日，您可以通过ES6 for Typescript解决此问题。
Array.from(new Set(yourArray.map((item: any) => item.id)))
答案 5 :(得分：53)
使用ES6功能，您可以执行以下操作：
const uniqueAges = [...new Set( array.map(obj => obj.age)) ];
答案 6 :(得分：51)
我只是映射并删除重复：
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]
修改：Aight！在性能方面不是最有效的方式，而是最简单最易读的IMO。如果您真的关心微优化，或者您拥有大量数据，那么常规for循环将更加“高效”。
答案 7 :(得分：18)
@ 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：http://jsperf.com/filter-versus-dictionary/3
的速度提高了34％一个采用映射器函数的通用解决方案（比直接映射慢，但这是预期的）：
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]
答案 8 :(得分：12)
默认情况下，我开始在所有新项目中坚持使用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]。
答案 9 :(得分：11)
我有一个小解决方案
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);
答案 10 :(得分：8)
使用lodash
var array = [
{ "name": "Joe", "age": 17 },
{ "name": "Bob", "age": 17 },
{ "name": "Carl", "age": 35 }
];
_.chain(array).pluck('age').unique().value();
> [17, 35]
答案 11 :(得分：7)
对于那些想通过键返回具有唯一属性的对象
的人
const array =
[
{ "name": "Joe", "age": 17 },
{ "name": "Bob", "age": 17 },
{ "name": "Carl", "age": 35 }
]
const key = 'age';
const arrayUniqueByKey = [...new Map(array.map(item =>
[item[key], item])).values()];
console.log(arrayUniqueByKey);
/*OUTPUT
[
{ "name": "Bob", "age": 17 },
{ "name": "Carl", "age": 35 }
]
*/
答案 12 :(得分：7)
已经有很多有效的答案，但是我想添加一个仅使用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]
答案 13 :(得分：7)
以下是解决此问题的另一种方法：
var result = {};
for(var i in array) {
result[array[i].age] = null;
}
result = Object.keys(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＆amp; amp;的性能差异Firefox非常棒，看起来Chrome在优化方面做得最好。
我不确定为什么上述代码段与其他代码段相比如此之快，也许比我更聪明的人有答案。 ; - ）
答案 14 :(得分：5)
underscore.js
_.uniq(_.pluck(array,"age"))
答案 15 :(得分：5)
答案 16 :(得分：5)
useEffect(()=>(async () => {
console.warn("1:- ", new Date());
const resp = await fetch(
"https://raw.githubusercontent.com/json-iterator/test-data/master/large-file.json"
);
const json = await resp.json();
console.log(json);
console.warn("3:- ", new Date());
})(), []);
答案 17 :(得分：5)
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;
}
答案 18 :(得分：5)
您可能会根据其中一个键对唯一的一组对象感兴趣：
let array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
let unq_objs = [...new Map(array.map(o =>[o["age"], o])).values()];
console.log(unq_objs)
//result
[{name: "Bob", age: 17},
{name: "Carl", age: 35}]
答案 19 :(得分：5)
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))];
答案 20 :(得分：5)
使用地图的简单不同过滤器：
let array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
];
let data = new Map();
for (let obj of array) {
data.set(obj.age, obj);
}
let out = [...data.values()];
console.log(out);
答案 21 :(得分：4)
const x = [
{"id":"93","name":"CVAM_NGP_KW"},
{"id":"94","name":"CVAM_NGP_PB"},
{"id":"93","name":"CVAM_NGP_KW"},
{"id":"94","name":"CVAM_NGP_PB"}
].reduce(
(accumulator, current) => accumulator.some(x => x.id === current.id)? accumulator: [...accumulator, current ], []
)
console.log(x)
/* output
[
{ id: '93', name: 'CVAM_NGP_KW' },
{ id: '94', name: 'CVAM_NGP_PB' }
]
*/
答案 22 :(得分：4)
我认为您正在寻找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/
答案 23 :(得分：3)
我知道我的代码长度短，时间复杂度低，但是这是可以理解的，所以我尝试了这种方式。
我试图在此处开发基于原型的功能，并且代码也会更改。
这是我自己的原型函数。
<script>
var array = [{
"name": "Joe",
"age": 17
},
{
"name": "Bob",
"age": 17
},
{
"name": "Carl",
"age": 35
}
]
Array.prototype.Distinct = () => {
var output = [];
for (let i = 0; i < array.length; i++) {
let flag = true;
for (let j = 0; j < output.length; j++) {
if (array[i].age == output[j]) {
flag = false;
break;
}
}
if (flag)
output.push(array[i].age);
}
return output;
}
//Distinct is my own function
console.log(array.Distinct());
</script>
答案 24 :(得分：2)
刚刚发现这个，我觉得它很有用
_.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)})
答案 25 :(得分：2)
[...new Set([
{ "name": "Joe", "age": 17 },
{ "name": "Bob", "age": 17 },
{ "name": "Carl", "age": 35 }
].map(({ age }) => age))]
答案 26 :(得分：2)
如果您需要整个对象，这是 ES6 版本的一个细微变化：
let arr = [
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
arr.filter((a, i) => arr.findIndex((s) => a.id === s.id) === i) // [{"name":"Joe", "age":17}, {"name":"Carl", "age": 35}]
答案 27 :(得分：2)
如果您有Array.prototype.includes或愿意polyfill它，这可行：
var ages = []; array.forEach(function(x) { if (!ages.includes(x.age)) ages.push(x.age); });
答案 28 :(得分：2)
如果像我一样，你更喜欢更多功能性的＆＃34;在不影响速度的情况下，此示例使用包含在reduce闭包内的快速字典查找。
var array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
var uniqueAges = array.reduce((p,c,i,a) => {
if(!p[0][c.age]) {
p[1].push(p[0][c.age] = c.age);
}
if(i<a.length-1) {
return p
} else {
return p[1]
}
}, [{},[]])
根据这个test，我的解决方案的速度是建议答案的两倍
答案 29 :(得分：1)
有一个库，可以在打字稿中提供强类型的可查询集合。
集合是：
该库称为 ts-generic-collections 。
GitHub上的源代码：
https://github.com/VeritasSoftware/ts-generic-collections
您可以得到如下不同的值
it('distinct', () => {
let numbers: number[] = [1, 2, 3, 1, 3];
let list = new List(numbers);
let distinct = list.distinct(new EqualityComparer());
expect(distinct.length == 3);
expect(distinct.elementAt(0) == 1);
expect(distinct.elementAt(1) == 2);
expect(distinct.elementAt(2) == 3);
});
class EqualityComparer implements IEqualityComparer<number> {
equals(x: number, y: number) : boolean {
return x == y;
}
}
答案 30 :(得分：1)
回答这个老问题是毫无意义的，但是有一个简单的答案可以说明Javascript的本质。 Javascript中的对象本质上是哈希表。我们可以使用它来获取唯一键的哈希值：
var o = {}; array.map(function(v){ o[v.age] = 1; });
然后我们可以将散列减少为唯一值的数组：
var a2 = []; for (k in o){ a2.push(k); }
这就是您所需要的。数组 a2 仅包含唯一的年龄。
答案 31 :(得分：1)
const array = [
{ "name": "Joe", "age": 17 },
{ "name":"Bob", "age":17 },
{ "name":"Carl", "age": 35 }
]
const allAges = array.map(a => a.age);
const uniqueSet = new Set(allAges)
const uniqueArray = [...uniqueSet]
console.log(uniqueArray)
答案 32 :(得分：1)
有linq.js - LINQ for JavaScript软件包（npm install linq），. Net开发人员应该熟悉。
samples中显示的其他方法中有明显的重载。
通过属性值从对象数组中区分对象的示例 是
Enumerable.from(array).distinct(“$.id”).toArray();
来自https://medium.com/@xmedeko/i-recommend-you-to-try-https-github-com-mihaifm-linq-20a4e3c090e9
答案 33 :(得分：1)
如果要返回唯一的对象列表。 这是另一种选择：
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（使字符串列表唯一），然后将其转换回使用JSON.parse的原始对象。
答案 34 :(得分：1)
假设我们有这样的数据 arr=[{id:1,age:17},{id:2,age:19} ...]，然后我们可以找到这样的独特对象 -
function getUniqueObjects(ObjectArray) {
let uniqueIds = new Set();
const list = [...new Set(ObjectArray.filter(obj => {
if (!uniqueIds.has(obj.id)) {
uniqueIds.add(obj.id);
return obj;
}
}))];
return list;
}
点击此处Codepen Link
答案 35 :(得分：1)
这是一个多功能的解决方案，它使用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);
如果这是你的风格，你可以将它添加到你的数组原型中并省略 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());
}
答案 36 :(得分：1)
下面的代码将显示唯一的年龄数组，以及没有重复年龄的新数组
var data = [
{"name": "Joe", "age": 17},
{"name": "Bob", "age": 17},
{"name": "Carl", "age": 35}
];
var unique = [];
var tempArr = [];
data.forEach((value, index) => {
if (unique.indexOf(value.age) === -1) {
unique.push(value.age);
} else {
tempArr.push(index);
}
});
tempArr.reverse();
tempArr.forEach(ele => {
data.splice(ele, 1);
});
console.log('Unique Ages', unique);
console.log('Unique Array', data);```
答案 37 :(得分：1)
unique(obj, prop) {
let result = [];
let seen = new Set();
Object.keys(obj)
.forEach((key) => {
let value = obj[key];
let test = !prop
? value
: value[prop];
!seen.has(test)
&& seen.add(test)
&& result.push(value);
});
return result;
}
答案 38 :(得分：1)
如果您需要整个对象唯一
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}]
答案 39 :(得分：0)
我随机抽取了样本，并针对100,000个项目进行了测试，如下所示：
let array=[]
for (var i=1;i<100000;i++){
let j= Math.floor(Math.random() * i) + 1
array.push({"name":"Joe"+j, "age":j})
}
这里是每个的性能结果：
Vlad Bezden Time: === > 15ms
Travis J Time: 25ms === > 25ms
Niet the Dark Absol Time: === > 30ms
Arun Saini Time: === > 31ms
Mrchief Time: === > 54ms
Ivan Nosov Time: === > 14374ms
我还要提及，由于这些物品是随机生成的，因此第二位是在Travis和Niet之间进行迭代。
答案 40 :(得分：0)
let mobilePhones = [{id: 1, brand: "B1"}, {id: 2, brand: "B2"}, {id: 3, brand: "B1"}, {id: 4, brand: "B1"}, {id: 5, brand: "B2"}, {id: 6, brand: "B3"}]
let allBrandsArr = mobilePhones .map(row=>{
return row.brand;
});
let uniqueBrands = allBrandsArr.filter((item, index, arry) => (arry.indexOf(item) === index));
console.log('uniqueBrands ', uniqueBrands );答案 41 :(得分：0)
var array =
[
{"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"]
答案 42 :(得分：0)
const array = [{
"name": "Joe",
"age": 17
},
{
"name": "Bob",
"age": 17
},
{
"name": "Carl",
"age": 35
}
]
const uniqueArrayByProperty = (array, callback) => {
return array.reduce((prev, item) => {
const v = callback(item);
if (!prev.includes(v)) prev.push(v)
return prev
}, [])
}
console.log(uniqueArrayByProperty(array, it => it.age));答案 43 :(得分：0)
原始类型
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)
}
}
答案 44 :(得分：0)
使用新的Ecma功能非常棒，但并非所有用户都拥有这些功能。
以下代码会将名为 distinct 的新函数附加到Global Array对象。 如果您尝试获取对象数组的不同值，则可以传递值的名称以获取该类型的不同值。
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中查看my post以获取演示。
答案 45 :(得分：0)
试试
var x = [] ;
for (var i = 0 ; i < array.length ; i++)
{
if(x.indexOf(array[i]['age']) == -1)
{
x.push(array[i]['age']);
}
}
console.log(x);
答案 46 :(得分：0)
如果您的数组是对象数组，则可以使用此代码。
getUniqueArray = (array: MyData[]) => {
return array.filter((elem, index) => array.findIndex(obj => obj.value == elem.value) === index);
}
MyData 如下所示：
export interface MyData{
value: string,
name: string
}
注意：您不能使用 Set，因为在比较对象时，它们是按引用而不是按值进行比较。因此，您需要比较对象的唯一键，在我的示例中，唯一键是值字段。 有关更多详细信息，您可以访问此链接：Filter an array for unique values in Javascript
答案 47 :(得分：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);
所有其他答案之一：
new Set，new Map等； .age硬编码到不同的函数中）； 此答案没有以上四个问题中的任何一个。
答案 48 :(得分：0)
简单的单缸套，性能卓越。比我的tests中的ES6解决方案快6％。
年龄= array.map（function（o）{return o.age}）。filter（function（v，i，a）{return a.indexOf（v）=== i}）;
答案 49 :(得分：0)
使用集合和过滤器。这样可以保留顺序：
let unique = (items) => {
const s = new Set();
return items.filter((item) => {
if (s.has(item)) {
return false;
}
s.add(item);
return true;
});
}
console.log(
unique(
[
'one', 'two', 'two', 'three', 'three', 'three'
]
)
);
/*
output:
[
"one",
"two",
"three"
]
*/
答案 50 :(得分：0)
我知道这是一个古老且相对容易回答的问题，我给出的答案将使完整的对象返回（我在这篇文章的很多评论中都看到了这一点）。它可能是“粘性”的，但就可读性而言，它比许多其他解决方案更干净（尽管效率更低）。
这将返回数组内部完整对象的唯一数组。
let productIds = data.map(d => {
return JSON.stringify({
id : d.sku.product.productId,
name : d.sku.product.name,
price : `${d.sku.product.price.currency} ${(d.sku.product.price.gross / d.sku.product.price.divisor).toFixed(2)}`
})
})
productIds = [ ...new Set(productIds)].map(d => JSON.parse(d))```
答案 51 :(得分：0)
从一组键中获取不同值的集合的方法。
您可以从here中获取给定的代码，并仅对所需键添加一个映射，以获取唯一对象值的数组。
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; }
答案 52 :(得分：0)
好吧，您可以使用lodash编写冗长的代码
方法1：嵌套方法
let array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
let result = _.uniq(_.map(array,item=>item.age))
方法2：方法链接或级联方法
let array =
[
{"name":"Joe", "age":17},
{"name":"Bob", "age":17},
{"name":"Carl", "age": 35}
]
let result = _.chain(array).map(item=>item.age).uniq().value()
答案 53 :(得分：0)
对于一般情况，我用TypeScript编写了自己的脚本，例如Kotlin的ObjectMapper mapper = new ObjectMapper();
// deserializes IExternalData into certain implementation.
mapper.enableDefaultTyping();
...
Array.distinctBy {}当然function distinctBy<T, U extends string | number>(array: T[], mapFn: (el: T) => U) {
const uniqueKeys = new Set(array.map(mapFn));
return array.filter((el) => uniqueKeys.has(mapFn(el)));
}
是可哈希的。对于对象，您可能需要https://www.npmjs.com/package/es6-json-stable-stringify
答案 54 :(得分：0)
这里有很多很好的答案，但是没有一个解决以下问题：
有没有其他方法可以构成数据
我将创建一个对象，其键是年龄，每个键都指向一个名称数组。
var array = [{ "name": "Joe", "age": 17 }, { "name": "Bob", "age": 17 }, { "name": "Carl", "age": 35 }];
var map = array.reduce(function(result, item) {
result[item.age] = result[item.age] || [];
result[item.age].push(item.name);
return result;
}, {});
console.log(Object.keys(map));
console.log(map);
通过这种方式，您已将数据结构转换为一种很容易从中检索不同年龄的结构。
这是一个更紧凑的版本，它还存储整个对象而不是名称（如果您要处理的对象具有两个以上的属性，那么它们就不能存储为键和值）。
var array = [{ "name": "Joe", "age": 17 }, { "name": "Bob", "age": 17 }, { "name": "Carl", "age": 35 }];
var map = array.reduce((r, i) => ((r[i.age] = r[i.age] || []).push(i), r), {});
console.log(Object.keys(map));
console.log(map);
答案 55 :(得分：-1)
这个函数可以是唯一的数组和对象
function oaunic(x,n=0){
if(n==0) n = "elem";
else n = "elem."+n;
var uval = [];
var unic = x.filter(function(elem, index, self){
if(uval.indexOf(eval(n)) < 0){
uval.push(eval(n));
return index == self.indexOf(elem);
}
})
return unic;
}
像这样使用
tags_obj = [{name:"milad"},{name:"maziar"},{name:"maziar"}]
tags_arr = ["milad","maziar","maziar"]
console.log(oaunic(tags_obj,"name")) //for object
console.log(oaunic(tags_arr)) //for array
答案 56 :(得分：-1)
我对此功能的两分钱：
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
答案 57 :(得分：-1)
如果您想从已知唯一对象属性的数组中过滤出重复的值，则可以使用以下代码段：
let arr = [
{ "name": "Joe", "age": 17 },
{ "name": "Bob", "age": 17 },
{ "name": "Carl", "age": 35 },
{ "name": "Carl", "age": 35 }
];
let uniqueValues = [...arr.reduce((map, val) => {
if (!map.has(val.name)) {
map.set(val.name, val);
}
return map;
}, new Map()).values()]
答案 58 :(得分：-2)
使用d3.js v3：
ages = d3.set(
array.map(function (d) { return d.age; })
).values();