Javascript 是否可以使用for…of和/或for…in循环遍历嵌套数组？

假设我有一个由嵌套数组组成的“矩形网格”，如下所示：

let board = [
  ['a0', 'a1', 'a2', 'a3', 'a4'],
  ['b0', 'b1', 'b2', 'b3', 'b4'],
  ['c0', 'c1', 'c2', 'c3', 'c4'],
  ['d0', 'd1', 'd2', 'd3', 'd4'],
];

我试图在其列中迭代，因此结果将类似于

“a0”、“b0”、“c0”、“d0”、“a1”。。。etc

当然，我可以使用良好的旧for循环：

const iterateAcrossColumnsES5 = () => {
  for (let i = 0; i < board[0].length; i++) {
    for (let j = 0; j < board.length; j++) {
      console.log(board[j][i]);
    }
  }
}

但它既不简洁，也不可读，而且它只有在板是“正方形”（父数组长度与其子数组长度相同）的情况下才起作用，否则我得到的迭代太多或太少

---

有可能吗？我没有尝试使用

map（）

或

forEach（）

，我对它们没问题，但我很好奇，我是否只能使用

for..of

或

for..in

这只有在你有一块方板的情况下才能达到你的目的

let board=[
[“a0”、“a1”、“a2”、“a3”、“a4”]，
[“b0”、“b1”、“b2”、“b3”、“b4”]，
[“c0”、“c1”、“c2”、“c3”、“c4”]，
[“d0”、“d1”、“d2”、“d3”、“d4”]，
[“e0”、“e1”、“e2”、“e3”、“e4”]
];
用于（板上的常数i）{
用于（板中的常数j）{
控制台日志（board[j][i]）；
}
}

您可以转置矩阵，然后进行迭代

const transpose=（r，a）=>a.map（（v，i）=>（r[i]| |[]）.concat（v））；
让电路板=['a0'，'a1'，'a2'，'a3'，'a4']，['b0'，'b1'，'b2'，'b3'，'b4']，['c0'，'c1'，'c2'，'c3'，'c4']，['d0'，'d1'，'d2'，'d3'，'d4']；
对于（让一个板减少（转置，[]））{
for（让v of a）{
控制台日志（v）；
}
}

---

。作为控制台包装{max height:100%！important；top:0；}

您可以使用

map

创建

a0，b0….

的数组，然后进一步减少它。然后使用带分隔符的join

，

创建所需的结果

let board=[
['a0'，'a1'，'a2'，'a3'，'a4']，
['b0'，'b1'，'b2'，'b3'，'b4']，
[c0'，c1'，c2'，c3'，c4']，
[d0'，d1'，d2'，d3'，d4']，
];
var result=board.reduce（（res，b）=>res.map（（elem，i）=>elem+'，'+b[i]）。join（'，'）；
控制台日志（结果）在js中没有内置此功能，但通过两个小助手函数，您可以非常优雅地编写循环：


函数*链（its）{
为了（让它自己去）
屈服
}
函数zip（数组）{
返回数组[0].map（（e，i）=>arrays.map（a=>a[i]））
}
//
让董事会=[
['a0'，'a1'，'a2'，'a3'，'a4']，
['b0'，'b1'，'b2'，'b3'，'b4']，
[c0'，c1'，c2'，c3'，c4']，
[d0'，d1'，d2'，d3'，d4']，
]
控制台。日志（[…链（板）]。连接（“”））
console.log（[…chain（zip（board））]）。使用
为…加入（''）
：


var板=[
['a0'，'a1'，'a2'，'a3'，'a4']，
['b0'，'b1'，'b2'，'b3'，'b4']，
[c0'，c1'，c2'，c3'，c4']，
['d0'，'d1'，'d2'，'d3'，'d4']
];
var结果=[]；
用于（板中的var i）
对于（板[i]中的var j）
结果[+j*board.length++i]=board[i][j]；
控制台日志（结果）
您可以更改电路板的，然后使用数组排列或
for…of
来获取项目：


const board=[
['a0'，'a1'，'a2'，'a3'，'a4']，
['b0'，'b1'，'b2'，'b3'，'b4']，
[c0'，c1'，c2'，c3'，c4']，
[d0'，d1'，d2'，d3'，d4']，
];
板[Symbol.iterator]=函数（）{
const rows=board.length；
const max=行*板[0]。长度；
设电流=0；
返回{
下一个：（）=>({
值：此[当前%rows][parseInt（当前/行）]，
完成：当前+==最大值
})
};
};
console.log（[…board]）；
用于（板的常数项）{
控制台日志（项目）；
}
ES6不是ES5的替代品，如果循环的标准有意义，就使用循环的标准。@Keith我同意，我只是好奇这是否可能。你正在寻找
zip
函数（），然后
firstCol=zip（…grid）[0]
如果你只想控制台记录每个条目，那么->
for（让我离开棋盘）{for（让我离开棋盘）console.log（j）；}
@Keith是的，我用它来迭代行，但我需要迭代列。看起来，合法，但我想迭代整个电路板，假设我不知道它的尺寸。@edit:嗯，是的，但这些是行，我需要列。@HynekS Oops。午饭后我有点困。@edit:如果棋盘是正方形（父母和孩子的长度相同）就可以了，但如果不是，就不行了。谢谢。这不完全是我想要的（独角兽？），但是非常有趣、鼓舞人心并且可能有用。目标是迭代项目，而不是打印逗号分隔的数组。看起来非常有趣。我必须承认，我不知道为什么
*它作为一个生成器产生，但我会看看Kyle Simpsons的“异步和性能”，并希望在那里找到答案……是否有可能在列的末尾传递回调（
console.log（）
就足够了？@HynekS：如果你需要为每个列做些什么，使用没有链的zip并分别迭代它们可能更容易，
for（col of zip（board））{for（item of col）….
const iterateAcrossColumnsES6 = () => {
  for (let [i, item] of Object.entries(board)) {
    for(let row of board) {
      console.log(row[i])
    }
  }
}