Question

我有两个数组如下

  var arr = ["x", "y", "z", "a", "b", "c"];
  var tgtArr = [{val:"a"}, {val:"b"}]; It does not need to be as lengthy as Array `arr`

这就是我试过的

  var dest = new Array(arr.length);
  for(var i = 0; i < arr.length; i++){
      for(var k = 0; k < tgtArr.length; k++){
          dest[i] = dest[i] || [];
          if(tgtArr[k].val == arr[i]){
              dest[i] = arr[i];
          }
      }
  }
  console.log(dest);

我的预期输出是（高于tgtArr值）

  [{}, {}, {}, {val:"a"}, {val:"b"}, {}];

如果tgtArr为空数组

  [{},{},{},{},{},{}]

这是fiddle。对于我来说，任何替代方案对我来说都不是一个好方法，因为我每次都在遍历整个数组。

Answer 1

短：

var result = arr.map(function(x) {
    return tgtArr.some(function(o) { return o.val == x; }) ? {val:x} : {};
});

这更有效：

var set = {};
tgtArr.forEach(function(obj, i) {
    set[obj.val] = true;
});
var result = arr.map(function(x) {
    return x in set ? {val:x} : {};
});

Answer 2

var dest = new Array(arr.length);
  for(var i = 0; i < arr.length; i++){
      dest[i] = {}
      for(var k = 0; k < tgtArr.length; k++){
          if(tgtArr[k].val == arr[i]){
              dest[i] = tgtArr[k];
          }
      }
  }
  console.log(dest);

Answer 3

我喜欢使用map而不是循环来做这种事情（Fiddle）：

var result = arr.map(function(x) {
    var match = tgtArr.filter(function(y) {
        return y.val == x;
    });
    if (match.length == 1) return match[0];
    else return {};
});

这可能是效率低下的，因为tgtArr中的每个项都会遍历arr，所以O（n * m）。如果需要，您可以通过预处理tgtArr并将其转换为哈希映射（Fiddle）来解决此问题。这样你就得到了一个O（n + m）算法（遍历每个数组一次）：

var tgtMap = {};
tgtArr.forEach(function(x) { tgtMap[x.val] = x; })
var result = arr.map(function(x) {
    var match = tgtMap[x];
    return match || {};
});

Answer 4

var tmp = {};
for (var i = 0; i < tgtArr.length; i++) {
    tmp[tgtArr[i].val] = i;
}

var dest = [];

for (var i = 0; i < arr.length; i++) {
    var obj= tmp[arr[i]] === undefined ? {} : tgtArr[tmp[arr[i]]];
    dest.push(obj);     

}

DEMO

Answer 5

这与Paul的答案相同，但是使用循环代替 map 。它首先根据 val 属性收集密钥，然后如果密钥不在tgtArr中，则使用空对象创建新数组，或者如果是，则从tgtArr复制对象的引用： / p>

function newArray(arr, tgtArr) {
  var keys = {},
      i = tgtArr.length,
      j = arr.length,
      newArr = [];

  // Get keys
  while (i--) keys[tgtArr[i].val] = tgtArr[i];

  // Make new array
  while (j--) newArr[j] = arr[j] in keys? keys[arr[j]] : {};

  return newArr; 
}

它应该是高效的，因为它只遍历每个数组一次。

根据另一个Array的值顺序重新排列Array

5 个答案: