如何获得包含某个元素的最后一个数组？

Question

我有一个数组的数组，我想检查第二个元素之间是否有联系，然后返回最后一个数组中的第一个元素，这个元素是打结的。

例如本应（即具有使领带的第二元素的最后一个数组中的第一个元素）返回4.

var optionsArray = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 

Answer 1

这是很简单的，你需要遍历源阵列，检查给定的项目是否与条件匹配，如果存在，则将其保存为结果。现在如果任何其他项目符合条件，结果的值将被新的匹配项目覆盖。

var optionsArray = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 
 
var result; 
 
optionsArray.forEach(function(item) { 
 
    if(item[1] == 10) { 
 
    result = item; 
 
    } 
 
}); 
 

 
console.log(result);

Answer 2

您可以创建向后遍历数组，并尽快为条件回调返回true返回一个简单的查找功能。

var optionsArray = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 
 

 
function find10(s) { 
 
    return s[1] === 10; 
 
} 
 

 
function findFromTheEnd(arr, cb) { 
 
    var l = arr.length; 
 
    
 
    while(l--) { // iterate backwards 
 
    if(cb(arr[l])){ // if the callback returns true 
 
     return arr[l]; // return the item 
 
    } 
 
    } 
 
    
 
    return null; // return null if none found 
 
} 
 

 
var result = findFromTheEnd(optionsArray, find10); 
 

 
console.log(result);

Answer 3

您可以使用reduceRight()并返回数组。

var arr = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 
 
var result = arr.reduceRight(function(r, e) { 
 
    if(e[1] == 10 && !r) r = e; 
 
    return r; 
 
}, 0) 
 

 
console.log(result)

您还可以使用for循环，从终点开始，在第一场比赛打破。

var arr = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 
 
var result; 
 
for (var i = arr.length - 1; i >= 0; i--) { 
 
    if (arr[i][1] == 10) { 
 
    result = arr[i] 
 
    break; 
 
    } 
 
} 
 

 
console.log(result)

Answer 4

与break储备订单经典for似乎不够：

var optionsArray = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 

var elementFound; 
for (var i = optionsArray.length-1; i >=0; i--) { 
    if(optionsArray[i].item[1] == 10) { 
    elementFound = optionsArray[i].item[1]; 
    break; 
    } 
} 

如果elementFound不是不确定的，它指的是发现阵列。

Answer 5

与其将此视为多维数组问题，可以将其看作嵌套在array search问题中的array includes问题;

const aarr = [1, 2, 3, 4]; 
aarr.includes(3); // true 
aarr.includes(10); // false 

// and 

const barr = ['hello', 'world']; 
barr.find(item => item[0] === 'h'); // "hello" 
barr.find(item => item[3] === 'l'); // "hello" 
barr.find(item => item[1] === 'z'); // undefined 

所以筑巢这些，

const carr = [[1, 2, 3, 4], [4, 5, 6, 7]]; 
carr.find(arr => arr.includes(4)); // [1, 2, 3, 4] 
carr.find(arr => arr.includes(6)); // [4, 5, 6, 7] 

---

接下来，我们已经下跌降低了整个问题“如何做到这一点的反向？“

你有几个选择取决于你想如何实现它，但一个简单的方法来做到这一点是一个浅克隆arr.slice()后跟一个反向arr.reverse()（我们使用克隆，所以没有副作用冲销原始阵列）

carr.slice().reverse().find(arr => arr.includes(4)); // [4, 5, 6, 7] 

如果你有指数工作，记住，你需要改变这些呢; -1是固定的，否则transformed_index = arr.length - original_index - 1

---

这里是你将如何实现的一些阵列的方法

const optionsArray = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]]; 
// index    0  1  2  3  4 

function arrLast(arr, comparator, method = 'find', transform = x => x) { 
    return transform(arr.slice().reverse()[method](comparator), arr); 
} 
const findLast = (arr, comparator) => arrLast(arr, comparator); 
const findLastIndex = (arr, comparator) => arrLast(arr, comparator, 'findIndex', (i, arr) => i === -1 ? -1 : arr.length - i - 1); 

arrLast(optionsArray, arr => arr.includes(10)); // [4, 10] 
findLastIndex(optionsArray, arr => arr.includes(10)); // 3 

Answer 6

如果你必须做出阵列项目之间的比较，你需要剪短一旦你满足了while循环是理想相反。因此，你可以这样做：

var arr = [[1, 10], [2, 10], [3, 10], [4, 10], [6, 14]], 
 
    i = 0, 
 
    result; 
 

 
while (arr[i][1] === arr[++i][1]); 
 
result = arr[i-1][0] 
 
console.log(result);