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

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

您可以创建一个简单的find函数，该函数向后迭代数组，并在条件回调返回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

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

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

与其将其视为多维数组问题，不如将其视为包含嵌套在数组搜索问题中的数组 。

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

---

这是您可以实现某些Array方法相反的方法

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