如何检查对象数组是否具有重复的属性值？

小开

ECMA 脚本6版本

如果您所处的环境支持 ECMA 脚本6的 Set，那么您可以使用 Array.prototype.some和 Set对象，如下所示

let seen = new Set();
var hasDuplicates = values.some(function(currentObject) {
return seen.size === seen.add(currentObject.name).size;
});

在这里，我们将每个对象的 name插入到 Set中，并检查添加前后的 size是否相同。这是因为 Set.size基于唯一数据返回一个数字(set 只在数据是唯一的时候添加条目)。如果/当您有重复的名称时，大小不会增加(因为数据不是唯一的) ，这意味着我们已经看到了当前的名称，它将返回 true。

ECMA Script 5 Version

如果不支持 Set，那么可以使用普通的 JavaScript 对象本身，如下所示

var seen = {};
var hasDuplicates = values.some(function(currentObject) {


if (seen.hasOwnProperty(currentObject.name)) {
// Current name is already seen
return true;
}


// Current name is being seen for the first time
return (seen[currentObject.name] = false);
});

同样的东西也可以简洁地写出来，就像这样

var seen = {};
var hasDuplicates = values.some(function (currentObject) {
return seen.hasOwnProperty(currentObject.name)
|| (seen[currentObject.name] = false);
});

注意: 在这两种情况下，我们都使用 Array.prototype.some，因为它会短路。一旦它从函数中得到一个真值，它将立即返回 true，它不会处理其余的元素。

小开

您可以使用 map来返回名称，然后使用这个 forEach技巧来检查它是否至少存在两次:

var areAnyDuplicates = false;


values.map(function(obj) {
return obj.name;
}).forEach(function (element, index, arr) {
if (arr.indexOf(element) !== index) {
areAnyDuplicates = true;
}
});

小提琴

小开

最佳答案

Use Array.Prototype.map and 数组，原型，一些:

var values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName4' },
{ name: 'someName2' }
];


var valueArr = values.map(function(item){ return item.name });
var isDuplicate = valueArr.some(function(item, idx){
return valueArr.indexOf(item) != idx
});
console.log(isDuplicate);

小开

使用 Underscore.js 可以使用 Underscore 的一些方法。这是其中之一。检查数组是否已经是唯一的。

function isNameUnique(values){
return _.uniq(values, function(v){ return v.name }).length == values.length
}

用普通的 JavaScript 通过检查数组中是否没有重复的名称。

function isNameUnique(values){
var names = values.map(function(v){ return v.name });
return !names.some(function(v){
return names.filter(function(w){ return w==v }).length>1
});
}

小开

尝试一个简单的循环:

var repeat = [], tmp, i = 0;


while(i < values.length){
repeat.indexOf(tmp = values[i++].name) > -1 ? values.pop(i--) : repeat.push(tmp)
}

Demo

小开

为了知道简单数组是否有重复，我们可以比较相同值的第一和最后索引:

功能:

var hasDupsSimple = function(array) {


return array.some(function(value) {                            // .some will break as soon as duplicate found (no need to itterate over all array)
return array.indexOf(value) !== array.lastIndexOf(value);   // comparing first and last indexes of the same value
})
}

测试:

hasDupsSimple([1,2,3,4,2,7])
// => true


hasDupsSimple([1,2,3,4,8,7])
// => false


hasDupsSimple([1,"hello",3,"bye","hello",7])
// => true

对于一个对象数组，我们首先需要将对象值转换为一个简单的数组:

使用 map将对象数组转换为简单数组:

var hasDupsObjects = function(array) {


return array.map(function(value) {
return value.suit + value.rank


}).some(function(value, index, array) {
return array.indexOf(value) !== array.lastIndexOf(value);
})
}

测试:

var cardHand = [
{ "suit":"spades", "rank":"ten" },
{ "suit":"diamonds", "rank":"ace" },
{ "suit":"hearts", "rank":"ten" },
{ "suit":"clubs", "rank":"two" },
{ "suit":"spades", "rank":"three" },
]


hasDupsObjects(cardHand);
// => false

var cardHand2 = [
{ "suit":"spades", "rank":"ten" },
{ "suit":"diamonds", "rank":"ace" },
{ "suit":"hearts", "rank":"ten" },
{ "suit":"clubs", "rank":"two" },
{ "suit":"spades", "rank":"ten" },
]


hasDupsObjects(cardHand2);
// => true

小开

如果你正在寻找一个布尔值，最快的方法是

var values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName1' },
{ name: 'someName1' }
]


// solution
var hasDuplicate = false;
values.map(v => v.name).sort().sort((a, b) => {
if (a === b) hasDuplicate = true
})
console.log('hasDuplicate', hasDuplicate)

小开

//checking duplicate elements in an array
var arr=[1,3,4,6,8,9,1,3,4,7];
var hp=new Map();
console.log(arr.sort());
var freq=0;
for(var i=1;i<arr.length;i++){
// console.log(arr[i-1]+" "+arr[i]);
if(arr[i]==arr[i-1]){
freq++;


}
else{
hp.set(arr[i-1],freq+1);
freq=0;
}
}
console.log(hp);

小开

在 TS 和 ES6中，您可以创建一个具有唯一属性的新 Set，并将其大小与原始数组进行比较。

const values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName3' },
{ name: 'someName1' }
]


const uniqueValues = new Set(values.map(v => v.name));


if (uniqueValues.size < values.length) {
console.log('duplicates found')
}

小开

添加更新的 es6函数以检查数组中的唯一值和重复值。这个函数是模块化的，可以在整个代码库中重用。感谢上面所有的帖子。




/* checks for unique keynames in array */
const checkForUnique = (arrToCheck, keyName) => {
/* make set to remove duplicates and compare to  */
const uniqueValues = [...new Set(arrToCheck.map(v => v[keyName]))];
if(arrToCheck.length !== uniqueValues.length){
console.log('NOT UNIQUE')
return false
}
return true
}




let arr = [{name:'joshua'},{name:'tony'},{name:'joshua'}]


/* call function with arr and key to check for  */
let isUnique = checkForUnique(arr,'name')

小开

你只需要一行代码。

var values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName4' },
{ name: 'someName2' }
];
let hasDuplicates = values.map(v => v.name).length > new Set(values.map(v => v.name)).size ? true : false;

小开

const values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName4' },
{ name: 'someName4' }
];


const foundDuplicateName = values.find((nnn, index) =>{
return values.find((x, ind)=> x.name === nnn.name && index !== ind )
})
    

console.log(foundDuplicateName)

找到了第一个重复的名字

const values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName4' },
{ name: 'someName4' }
];


const foundDuplicateName = values.find((nnn, index) =>{
return values.find((x, ind)=> x.name === nnn.name && index !== ind )
})

小开

checkDuplicate(arr, item) {
const uniqueValues = new Set(arr.map((v) => v[item]));
return uniqueValues.size < arr.length;
},


console.log(this.checkDuplicate(this.dutyExemptionBase, 'CI_ExemptionType')); // true || false

小开

It is quite interesting to work with arrays

可以使用新的 Set () 方法查找 复制品值！

假设你有一个这样的对象数组。

 let myArray = [
{ id: 0, name: "Jhon" },
{ id: 1, name: "sara" },
{ id: 2, name: "pop" },
{ id: 3, name: "sara" }
]


const findUnique = new Set(myArray.map(x => {
return x.name
}))


if(findUnique.size < myArray.length){
console.log("duplicates found!")
}else{
console.log("Done!")
}

小开

const duplicateValues = [{ name: "abc" }, { name: "bcv" }, { name: "abc" }];
const isContainDuplicate = (params) => {
const removedDuplicate = new Set(params.map((el) => el.name));
return params.length !== removedDuplicate.size;
};
const isDuplicate = isContainDuplicate(duplicateValues);
console.log("isDuplicate");