Javascript 从数组中过滤值

Question

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

例如，我有以下数组，我的函数应该 return 来自每个子数组的第二个元素，其中第一项是 8:

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

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

这是我目前已经实现的，但它return是两个元素而不是每个数组中匹配的第二个元素...

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 returns 数组的原始项目，没有改变任何东西。

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

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

如果您只想使用内部数组的一部分并且该部分是真实值，则过滤有效，但它不会采用 return 值，因为它不是为此而设计的。

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 returns 传递提供谓词的元素，因此在您的情况下，这将是 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() 的工作原理。它创建一个由提供谓词函数（即检查某些条件并返回布尔值）returns 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

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

试试这个：

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 4

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

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 5

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

一般来说，最好的方法是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);

...但是对于非常大的数据集，如果你不想做多次pass，你可以给自己一个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 条目，但您可以根据需要进行调整。例如，如果您希望它是 really 通用的，您可以在 filterMap 上放置一个唯一值，表示 "leave this out":

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 对于 "accumulator" 不适合的情况来说并不是很好改变。所以如果你经常这样做，给自己一个实用程序来做它。或者只是 filter 和 map.

Answer 6

你可以使用函数 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 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']

Javascript 从数组中过滤值

Javascript filter values from array

javascript

arrays

ecmascript-5