来自阵列的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()方法创建与通过由提供的功能实现的测试中所有元素的数组。

对于过滤，回调需要返回一个被解释为布尔值的值，也就是说，每个真值（如对象，数组或任何非零数等）将结果集的项目。

如果您只想使用内部数组的一部分，并且该部分是一个占空比值，那么过滤就可以工作，但它不会使用返回值，因为它不是用于此目的的。该及格，谓语，所以在你的情况下，这将是对item哪个项目1是真的

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回报元素。为了达到你想要什么，你需要先筛选项目，并使用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);

或者使用减少：

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

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

试试这个：

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);

...但对于真正的大数据集，如果你不想做多次通过，你可以给自己一个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 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']