Question

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

例如，这应该返回4.（最后一个数组中的第一个元素，它有第二个元素构成一个平局）

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

Answer 1

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

＆＃13;

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

＆＃13;

Answer 2

您可以创建一个向后迭代数组的简单查找函数，并在条件回调返回true后立即返回。

＆＃13;

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

＆＃13;

Answer 3

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

＆＃13;

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)

＆＃13;

您还可以使用从结束开始的for循环，并在第一场比赛中休息。

＆＃13;

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)

＆＃13;

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

不要将此视为多维数组问题，而应将其视为嵌套在array includes问题中的array search问题;

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循环是理想的。因此，您可以执行以下操作;

＆＃13;

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

＆＃13;

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

6 个答案: