Question

我有一个JavaScript对象，我试图与一个对象数组进行比较：

var builtVehicle = {pattern: "../images/fire1192015.png", 
vehicle: "../images/van1192015.png", 
wheel: "../images/wheels3.png"};

var createdVehicles = [
{pattern:"../images/checkerboard1192015.png",       
vehicle:"../images/car1192015.png", wheel:"../images/wheels1.png"}, 
{pattern:"../images/fire1192015.png", vehicle:"../images/truck1192015.png",     
wheel:"../images/wheels4.png"},]

我试图遍历JavaScript对象和createdVehicles对象数组，寻找完全匹配。如果没有完全匹配，我想将builtVehicle对象添加到createdVehicles数组。我的想法是将数组中对象的每个键/值对与builtVehicle对象进行比较，但是我在拉出数组中的键/值对时遇到了一些问题。我的循环看起来像这样：

for(var key in builtVehicle) {
    console.log('builtVehicle key: ' + key + '\n' + 'builtVehicle value: ' +     
builtVehicle[key]);
}


for(var b=0; b < createdVehicles.length; b++){
    alert(createdVehicles[b]);
}

这是最好的方法吗？我也在研究2D阵列来实现这一目标，但任何建议都值得赞赏。谢谢！

Answer 1

如果你可以改变数据结构，那么这样的事情可能会更好，这取决于你要做什么创建的车辆以及它是否需要是一个数组。

// indexed by id of the vehicle, this could be a model number or something instead, but just need some identifying key for comparison.
// structure of item: { identifyingKey : vehicleObject }
createdVehicles = {
  1 : { ... },
  2 : { ... }
 }

if (!createVehicles.hasOwnProperty(builtVehicle.id)) {
  createdVehicles[builtVehicle.id] = builtVehicle;
}

如果你坚持你的约束，最好采取直接的方法并迭代阵列。评论是正确的，旧的方式假设车辆是基于一个键的相同。这里创建了一个函数来进行ddper对象比较，然后用它来检查车辆阵列中的匹配。如果有匹配，我们就会爆发，如果不匹配则匹配保持为false，我们知道在循环完成后将其添加到数组中。这有点沉重和冗长，但没有图书馆这应该工作。很抱歉语法错误和内容，在工作中试图快速完成。

//if you have access to underscore you can use _.size(obj) instead
// otherwise having access ot the size of the object helps, idk how people
// feel about touching the object protoype itself, but this is quick and dirty
Object.prototype.size = function(obj) {
  var size = 0, key;
  for (key in obj) {
    if (obj.hasOwnProperty(key)) size++;
  }
  return size;
};

var match = false;

var isVehicle = function(builtVehicle, testVehicle) {
  if (builtVehicle.size() !== testVehicle.size()) {
     return false;
  }

  for (key in builtVehicle) {
    if (!testVehicle.hasOwnProperty[key]) {
      return false;
    }
  }

  return true;
}

for (var i = 0, len = createdVehicles.length; i < len; i++) {
  var testVehicle = createdVehicles[i],
      match = isVehicle(builtVehicle, testVehicle);

   //if there was a match break out
   if (match) {
     break;
   }
}

if (!match) {
  createdVehicles.push(builtVehicle);
}

因为人们提到了下划线，如果你有权访问，你可以这样做：

for (var i = 0, len = createdVehicles.length; i < len; i++) {
  var testVehicle = createdVehicles[i],
      match = _.isEqual(builtVehicle, testVehicle);

   //if there was a match break out
   if (match) {
     break;
   }
}

if (!match) {
  createdVehicles.push(builtVehicle);
}

Answer 2

我不能说这是最好的方法。最终，我会像@Brodie那样改变数据结构。否则你可以做这样的事情......

var builtVehicle = {
  pattern: "../images/fire1192015.png", 
  vehicle: "../images/van1192015.png", 
  wheel: "../images/wheels3.png"
};

var createdVehicles = [
{
  pattern:"../images/checkerboard1192015.png",       
  vehicle:"../images/car1192015.png", 
  wheel:"../images/wheels1.png"
}, 
{
  pattern:"../images/fire1192015.png", 
  vehicle:"../images/truck1192015.png",     
   wheel:"../images/wheels4.png"
}
];


var matchVehicle = function (vehicle, stack) {

  var i=0;

  for (i; i < stack.length; i+=1) {

      // if you have an id, thats even better because you don't have to test all of this, otherwise what makes it unique? a combo of everything?
      if ((vehicle.pattern === stack[i].pattern) && (vehicle.vehicle === stack[i].vehicle) && (vehicle.wheel === stack[i].wheel)) {
          return stack[i]; // returns the matching vehicle.
      }
  }
  // Will push the vehicle if it didn't match
  stack.push(vehicle);

};

console.log(matchVehicle(builtVehicle, createdVehicles));

将对象与对象数组进行比较

2 个答案: