Javascript过滤数组中的值

Question

我有一个数组，每个数组都包含两个元素。如何通过过滤第一个元素从数组中返回第二个元素？

例如，我有以下数组，我的函数应该返回每个子数组的第二个元素，其中第一项是8：

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];

预期结果：['first', 'second', 'third']

这是我迄今为止实现的，但它返回两个元素，而不是每个数组中的第二个元素，并匹配...

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = array.filter(function(item){
  if(item[0] == 8) {
    return item[1];
  }
});
console.log(result);

Answer 1

您可以使用条件进行过滤，然后只需要映射您想要的部分。

在单个循环中只能使用Array#reduce，因为您可以在此处操作结果集的值。

Array#filter 返回数组的原始项，不做任何更改。

filter() 方法创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。

对于过滤，回调需要返回一个被解释为布尔值的值，这意味着，每个真值（如对象、数组或任何非零数字等）都会获取结果集的项目。

如果你喜欢只使用内部数组的一部分并且这部分是一个真实值，那么过滤是有效的，但它不接受返回值，因为它不是为此而设计的。

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']],
    result = array.filter(function(item){
        return item[0] === 8;
    }).
    map(function (a) {
        return a[1];
    });

console.log(result);

Answer 2

Array.prototype.filter 返回传递提供的谓词的元素，因此在您的情况下，这将是item，其中 item1 为真。要实现您想要的，您需要先过滤项目，然后使用 map 提取第二个元素：

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = array.filter(function(item) {
  return item[0] == 8;
}).map(function (item) {
  return item[1];
});
console.log(result);

或者使用reduce：

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = array.reduce(function(result, item) {
  return item[0] == 8 ? result.concat(item[1]) : result;
}, []);
console.log(result);

如果你想使用 ES6 的特性，它可以缩短事件：

const array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
const result1 = array.filter(([item]) => (item == 8)).map(([,item]) => item);
const result2 = array.reduce((res, [n, str]) => n == 8 ? [...res, str] : res, []);

console.log(result1);
console.log(result2);

编辑：要了解您的功能为何不起作用，您需要了解 Array.prototype.filter() 的工作原理。它创建一个由提供的谓词函数（即检查某些条件并返回布尔值）返回 true 的元素组成的新数组。对于所有以8 作为第一项的子数组，第二个元素将决定该元素是否用于创建新数组。

因此对于array 的每个元素（第一个[8, 'first']，下一个[8, 'second'] 等），您的函数将被评估，并且返回true 的元素将被添加到新数组中：

[[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']]
true,          true,          false,        true,         false

=> [[8, 'first'], [1, 'empty'], [8, 'third']]

Answer 3

你可以使用函数reduce

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];

var result = array.reduce(function(acc, item){
  if(item[0] === 8){
    acc.push(item[1])
   }
   return acc;
}, []);

console.log(result);

Array#reduce 它将在一个循环中完成。

Answer 4

Array 的 filter 方法通过在每次迭代中传递满足特定条件的项来创建一个新数组。

试试这个：

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 
'empty']],resArray = [];
array.forEach(function(item){
  if(parseInt(item[0]) === 8){
    resArray.push(item[1]);
  }
});
console.log(resArray);

Answer 5

首先映射，然后过滤以删除未定义的值。

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = array.map(function(item){
  if(item[0] == 8) {
    return item[1];
  }
}).filter(function(item) {
    return item;
});
console.log(result);

Answer 6

您需要过滤掉不需要的条目并将条目映射到条目中的第二个值。

一般来说，最好的方法是先filter，然后再map：

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = array.filter(function(item){ return item[0] == 8; })
                  .map(function(item) { return item[1]; });
console.log(result);

...但是对于一个非常大的数据集，如果你不想多次传球，你可以给自己一个filterMap函数：

function filterMap(arr, predicate) {
    var result = [];
    arr.forEach(function(entry) {
      var newEntry = predicate(entry);
      if (newEntry !== undefined) {
          result.push(newEntry);
      }
    });
    return result;
}
var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = filterMap(array, function(item){
    return item[0] == 8 ? item[1] : undefined;
});
console.log(result);

该版本假定您从不希望结果中出现undefined 条目，但您可以根据需要进行调整。例如，如果您希望它是真正通用的，您可以在 filterMap 上设置一个唯一值，表示“将其排除在外”：

function filterMap(arr, predicate) {
    var result = [];
    arr.forEach(function(entry) {
      var newEntry = predicate(entry);
      if (newEntry !== filterMap.OMIT) {
          result.push(newEntry);
      }
    });
    return result;
}
filterMap.OMIT = {};
var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];
var result = filterMap(array, function(item){
    return item[0] == 8 ? item[1] : filterMap.OMIT;
});
console.log(result);

虽然您可以硬塞reduce 来执行此操作，但reduce 对于“累加器”不变的情况并不是很好。因此，如果您经常这样做，请给自己一个实用程序来执行此操作。或者只是filter 和map。

Answer 7

您可以利用 Array.reduce 来实现您想要的输出 -

var array = [[8, 'first'], [8, 'second'], [1, 'empty'], [8, 'third'], [9, 'empty']];


array.reduce(function(i, n){
    if(n[0]==8){
        i.push(n[1]);
    }
    return i;
},[]);
//output : ['first', 'second', 'third']