Question

我有一个对象数组，所有对象都有相同的键。我想检查两个键，在这种情况下是“a”＆amp;来自所有对象的“b”具有相同的值。在所有对象中表示=== a和b === b。

var arr = [{a:"x", b:2, c:3, d:4},{a:1, b:2, c:3, d:4},{a:1, b:2, c:3, d:4},{a:1, b:2, c:3, d:4}];

如果其中一个键值（a或b）与其他键值不匹配，我想返回false。这种情况应该返回false，因为arr [0] =“x”中的“a”，而所有其他的则等于1;

这是我的尝试。显然不起作用，但我试图让2个循环一次比较2个对象。例如，第一个循环将从arr [0]开始，第二个循环将从arr [1]开始，比较然后转到比较arr [3]和arr [4]，依此类推。虽然阵列的长度不一定都是均匀的。

function compareKeyVals(arr){

  for(var i = 0; i<arr.length; i+=2){
    for(var j = 1; j<arr.length; j+=2){
     for(key in arr[i]){     
        for(keyz in arr[j]){      
          if(key === "a" && keyz === "a"){
            if(arr[i][key] != arr[j][keyz]){
              return false;
            }
          }  
        }
      }    
    }
  }
}

compareKeyVals(arr);

感谢。

Answer 1

由于它们必须相同，您只需检查第一个对象的a和b属性，并将所有其他对象与之比较。像这样：

for(var i=1; i<arr.length; i++){
  if(arr[i].a !== arr[0].a || arr[i].b !== arr[0].b) {
    return false;
  }
}
return true;

更新：改变为严格比较，灵感来自Marc的回答

Answer 2

var flag = true;  
for(var i = 1; i<arr.length; i++){
if(arr[0].a != arr[i].a || arr[0].b != arr[i].b){
flag = false;
break;
 }
}
return flag;

Answer 3

你真的可以检测到从一次迭代到下一次迭代的变化，对吗？

 var arrayLength = arr.length; //cache the array length
 if (arrayLength > 0) { //only proceed if there are some elements
   var firstA = arr[0].a; //set the baseline that all others must match
   var firstB = arr[0].b;
   for(var i = 1; i<arrayLength ; i++) {
       //if the new one doesn't match the first one, break out
       if (firstA !== arr[i].a || firstB !== arr[i].b) {
           return false;
       }
   }
   return true; //return true if we complete the loop with all matches
 } else {
   return false; //assumes you want to return false if no elements in array
 }

当发现不匹配时，这会立即让你脱离循环，所以你不会浪费迭代。

（为每条评论添加了一个空数组检查）

循环对象数组，比较关键值

3 个答案: