Question

我有一个三维数组，例如：

var array = [[1,0][3,3][2,1][0,8]]

，我想对每个子数组中的第一项做一些事情，但是对每个子数组中的第二项做其他事情。

因此，例如，我想找到array[0][0], array[1][0], array[2][0]的总和，以此类推。但是，我想要array.length等的单独结果。

我仍在学习javascript（非常缓慢），并且，如果可能的话，我想指出正确的方向，而不是寻求现成的解决方案。我一直在寻找可能的解决方案，我认为我可能需要一个嵌套的array[0][1], array[1][1], array[2][1]循环，但是我不确定如何构造它以获取所有值。

我一直在尝试以下方法：

for

但是我不知道发生了什么，足以操纵结果。

如果有人可以引导我朝正确的方向寻求解决方案，那将不胜感激。

谢谢。

Answer 1

您可能会考虑使用.reduce-在每次迭代中，将第一个数组值添加到累加器的属性中，然后对第二个数组值执行所需的操作，将其结果分配给累加器的另一个属性。例如，对于第二个项目，您想获得其产品：

const input = [[1,0],[3,3],[2,1],[0,8]];
const { sum, product } = input
  .reduce(({ sum=0, product=1 }, [item0, item1]) => ({
    sum: sum + item0,
    product: product * item1
  }), {});
console.log(sum, product);

在上面的代码中，累加器是一个具有两个属性的对象，sum（从0开始）和product（从1开始）。在reduce内部，返回一个对象，新的sum是旧的sum加上数组中的第一项，新的product是旧的{ {1}}乘以数组中的第二项。（当然，结果乘积为0，因为在第一个子数组中，第二项为0）

还请注意，数组始终需要用逗号分隔每个数组项-您需要修复输入数组的语法。

当然，您也可以根据需要product进行循环，但是我认为数组方法是更可取的，因为它们功能更多，抽象性更好并且不需要手动迭代。带有for循环的相同代码如下所示：

for

Answer 2

您只需要一个for循环，因为您只有一个数组，其中的数组知道您要处理的索引。因此，结果如下：

let sum1 = 0;
let sum2 = 0;
for(let i = 0; i < array.length; i++) {
    sum1 += array[i][0];
    sum2 += array[i][1];     
}
console.log('sum1: ', sum1);
console.log('sum2: ', sum2);

Answer 3

由于您寻求帮助以正确的方向，我建议您从简单的console.logs开始，看看发生了什么（注释内联）：

var array = [[1, 0],[3, 3],[2, 1],[0, 8]];

var results = [0, 0]; // this array is to store the results of our computation

for (var i = 0; i < array.length; i++) { // for each subarray in array
  console.log('examining subarray ', array[i]); 
  for (var j = 0; j < array[i].length; j++) { // for each element in subarray
    if (j === 0) {
      console.log('...  do something with the first element of this array, which is: ' + array[i][j]);
      results[j] += array[i][j]
    } else if (j === 1) {
      console.log('...  do something with the second element of this array, which is: ' + array[i][j]);
      // do some other computation and store it in results
    }
  }
}

console.log('Final results are ', results);

Answer 4

您在第二行上犯了一个错误。您需要遍历嵌套数组，然后从主数组获取值。

const mainArray = [[1, 0], [3, 3], [2, 1], [0, 8]];

for (let i = 0; i < mainArray.length; i++) {
  const nestedArray = mainArray[i]
  for (let j = 0; j < nestedArray.length; j++) {
    const value = mainArray[i][j]
    switch(j) {
      case 0:
        console.log(`first item of array number ${i+1} has value: ${value}`)
        break;
      case 1:
        console.log(`second item of array number ${i+1} has value: ${value}`)
        break;
    }
  }
}

Answer 5

首先，您发布的数组是2d数组，而不是3d数组。

您发布的嵌套for循环非常适合您想要的内容。首先要陈述的是遍历数组的第一面。第二个是获取第二个数组中的每个索引

var array = [[1,0],[3,3],[2,1],[0,8]]
for (var i = 0; i < array.length; i++) {
  //This loop over these [1,0],[3,3],[2,1],[0,8] 
  //So i on the first loop is this object [1,0] so so on
  for (var j = 0; j < array.length; j++) {
    //This will loop over the i object
    //First loop j will be 1
    //Here is where you would do something with the index i,j. 
    //Right now you are just returning 1 on the first loop
    return array[i][j];
  }
}

希望这对您有所帮助

Answer 6

您可以像这样使用for...of循环和解构：

for(let [a, b] of array) {
   // a will be the first item from the subarrays: array[0][0], array[1][0], ...
   // b will be the second: : array[0][1], array[1][1], ...
}

演示：

let array = [[1, 0], [3, 3], [2, 1], [0, 8]];

for(let [a, b] of array) {
   console.log("a: " + a);
   console.log("b: " + b);
}

Answer 7

在循环中使用调试器是观察和理解循环的每个步骤的好方法
使用forEach方法将是遍历数组及其子级的更清晰方法

const items = [[1, 0],[3, 3],[2, 1],[0, 8]]
let results = {}

items.forEach((item, index) => {
  // debugger;
  item.forEach((subItem, subIndex) => {
    // debugger;
    if (results[subIndex]) {
      results[subIndex] = results[subIndex] + subItem
    } else {
      results[subIndex] = subItem
    }
  })
})

console.log(results) // { 0: 6, 1: 12 }

// *********EXPLANATION BELOW ************

const items = [[1, 0],[3, 3],[2, 1],[0, 8]]

// store results in its own key:value pair
const results = {}

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
// forEach is a more readable way to loop through an array
items.forEach((item, index) => {
  // use console.log(item, index) to see the values in each loop e.g first loop contains `item = [1,0]`
  // you can also use a debugger here which would be the easiest way to understand the iteration
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger
  // debugger;

  // loop over item (e.g [1,0]) to get subItems and their index
  item.forEach((subItem, subIndex) => {

    // get the result from previous sums from `result` 
    // and add them to the current subItem values
    // if there was no previous sum(i.e for first entry) 
    // use subItem as the first value.
    if (results[subIndex]) {
      results[subIndex] = results[subIndex] + subItem
    } else {
      results[subIndex] = subItem
    }

    // Below is a oneliner way to do line 16 to 20 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator
    // results[subIndex] = results[subIndex] ? results[subIndex] + subItem : subItem
  })
})

console.log(results) // { 0: 6, 1: 12 } the results of `array[0][0],array[1][0]...` are in 0 and the result of `array[0][1], array[1][1]...` are in 1 and so on.

Answer 8

强制性单线烤面条。

console.log([[1, 0], [3, 3], [2, 1], [0, 8]].reduce((p, c) => [p[0] += c[0], p[1] += c[1]]));

如何分别遍历嵌套数组项

8 个答案: