ES6特定的方法来遍历两个数组并在每个数组中查找匹配项？

Question

假设我有两个要比较的对象数组：

var arr1 = [
  {
    name: 'A', type: "Dog"
  },
  {
    name: 'B', type: "Zebra"
  },
  {
    name: 'C', type: "Cat"
  },
  {
    name: 'D', type: "Dingo"
  }
]

var arr2 = [
  {
    name: 'A', type: "Wolf"
  },
  {
    name: 'B', type: "Echidna"
  },
  {
    name: 'C', type: "Wallaby"
  },
  {
    name: 'D', type: "Rabbit"
  }
]

假设API是旧数据，而arr2是来自arr1的更新数据。

我想遍历数组，查找name匹配的对象。如果有匹配，我想将type从arr1更新为arr2。

我会这样做：

for(var i = 0; i<arr1.length; i++){
  for(var x = 0; x<arr2.length; x++){
    if(arr1[i].name === arr2[x].name){
      arr1[i].type = arr2[x].type;
    }
  }
}

我想知道ECMAScript 6中有没有什么更新的方法可以让这件事变得更容易(在现实世界的场景中，逻辑要复杂得多，在循环中循环感觉相当笨拙)；

Answer 1

在ES2015中，您将使用maps，而不会使用此数据结构

var map1 = new Map([
  ['A', "Dog"],
  ['B', "Zebra"],
  ['C', "Cat"],
  ['D', "Dingo"]
]);
var map2 = new Map([
  ['A', "Wolf"],
  ['B', "Echidna"],
  ['C', "Wallaby"],
  ['D', "Rabbit"]
]);

然后，要使用来自map2的数据更新map1，您可以使用

for(let [key, value] of map2)
  map1.set(key, value);

平均而言，映射操作需要是次线性的。如果映射是使用散列实现的，则它们应该是常量。那么总成本将是线性的。

或者，由于键是字符串，您可以考虑使用普通对象。您可以使用Object.create(null)创建它，以防止它继承Object.prototype的属性，并使用Object.assign分配这些属性

var obj1 = Object.assign(Object.create(null), {
  A: "Dog",
  B: "Zebra",
  C: "Cat",
  D: "Dingo"
});
var obj2 = Object.assign(Object.create(null), {
  A: "Wolf",
  B: "Echidna",
  C: "Wallaby",
  D: "Rabbit"
});

然后，要使用来自obj2的数据更新obj1，您可以使用

for(let key in obj2)
  obj1[key] = obj2[key];

最有可能的是，对象将使用散列实现，因此每个赋值平均而言都是常量。总成本将是线性的。

Answer 2

您可以使用forEach循环(ES5)或ES6中的for..of循环：

for (let item1 of arr1) {
  for (let item2 of arr2) {
    if(item1.name === item2.name){
      item1.type = item2.type;
    }
  }
}

如果这些列表很长，我建议将更新后的列表放到一个哈希图中，这样时间复杂度就是线性的，而不是二次的。