Question

此函数将数组数与其邻居相乘并返回最大的乘积。我尝试使用forEach创建此函数，但我无法使inputArray [i + 1]工作。如何在forEach中定位数组元素邻居？谢谢！

function adjacentElementsProduct(inputArray) {
  var product = inputArray[0] * inputArray[1];
  for(var i = 0; i < inputArray.length; i++) {
    if((inputArray[i] * inputArray[i + 1]) > product) {
      product = inputArray[i] * inputArray[i + 1];
    }
  }
  console.log(product);
}

Answer 1

您可以从第二个元素Array#slice开始获取给定数组的副本，然后迭代该数组。然后获取产品的迭代数组和原始数组的相同索引的乘积。如有必要，请比较并更新product。

工作原理：

index       0   1   2   3   4   5   6   7 
original [  1,  3,  5,  3,  7,  4,  8,  2  ]
copy     [  3,  5,  3,  7,  4,  8,  2  ]
product     3  15  15  21  28  32  16

＆＃13;

function adjacentElementsProduct(inputArray) {
    var product = inputArray[0] * inputArray[1];
    inputArray.slice(1).forEach(function (a, i) {
        var p = inputArray[i] * a;
        if (p > product) {
            product = p;
        }
    });
    console.log(product);
}

adjacentElementsProduct([1, 3, 5, 3, 7, 4, 8, 2]);

＆＃13;

与Array#reduce

相同

＆＃13;

function adjacentElementsProduct(array) {
    return array.slice(1).reduce(function (r, a, i) {
        var p = array[i] * a;
        return r >= p ? r : p;
    }, undefined);
}

console.log(adjacentElementsProduct([1, 3, 5, 3, 7, 4, 8, 2]));
console.log(adjacentElementsProduct([-1, 1]));
console.log(adjacentElementsProduct([0, 0]));
console.log(adjacentElementsProduct([42]));
console.log(adjacentElementsProduct([]));

＆＃13;

Answer 2

foreach参数提供当前索引和数组对象。没有办法直接获取参数中的下一个值。

inputArray.forEach(function(currentValue, index, array){
    product = currentValue * array[index+1]
});

Answer 3

如documentation所述，foreach回调函数有3个参数：

元素值
元素索引
正在遍历的数组

所以你可以访问下一个项目：

myArray.forEach(function(value, index, array) {
  product = value * array[index + 1];
}

我让你完成代码以获得更高的产品;）

Answer 4

forEach的回调函数有三个参数 - 当前项，当前索引和数组。

将代码转换为forEach将如下所示：

function adjacentElementsProduct(inputArray) {
    let product = inputArray[0] * inputArray[1];
    inputArray.forEach((item, index, array) => {
        if (item * array[index + 1] > product) {
            product = item * array[index + 1];
        }
    });
    console.log(product);
}

在我看来，reduce更适合此类问题。

function adjacentElementsProduct(inputArray) {
    const result = inputArray.reduce((largestSoFar, current, index, array) => {
        const product = current * array[index + 1];
        return (largestSoFar === null || product > largestSoFar) ?
            product :
            largestSoFar;
    }, null);
    console.log(result);
}

使用forEach定位数组元素

4 个答案: