如何在javascript中沿对角线遍历数组

我有一个包含字符串的数组，我想对角遍历该数组。
假设：

• 每个字符串的长度相同
• 阵列可以是方形或矩形，水平或垂直

矩阵如下所示：

A B C D
E F G H
I J K L

我想得到（从左上到右下）：

和（从左下到右上）：

我已经有了一段代码，可以工作3/4的方式，但我似乎无法找出我在做什么（错误）

我的代码把对角线分成4个循环，得到所有的对角线。对于在未绑定值上具有if-to-not循环的循环，它看起来是2。伪代码看起来有点像这样：

for(loop rows){
 var outputarray = [];
   for(loop columns){
      if(delimit for out of bound){
       var temprow = TheArray[something?];
       var tempvalue = temprow[something?];
       outputarray.push(tempvalue);
       }
   }
 //use values
document.getElementById("theDiv").innerHTML += outputarray.join("")+"<br>";
}

for（循环行）{
变量输出阵列=[]；
对于（循环列）{
if（超出边界的定界）{
var temprow=阵列[某物？]；
var tempvalue=temprow[某物？]；
输出阵列推送（tempvalue）；
}
}
//使用值
document.getElementById（“theDiv”）.innerHTML+=outputarray.join（“”+“
”；
}

我希望有人能帮我解决这个问题。

使用索引：

[i][j-i]

从0到M-1

j从0到i

而j++ 对于矩阵

类型数组[M][N]

但是，如果矩阵是矩形的，这可能会遗漏右下角的一些，您可能需要第二个嵌套的for循环，使用i和j来捕捉这些。

从左上到右下

var数组=[“ABCD”、“EFGH”、“IJKL”]；
var Ylength=数组长度；
var Xlength=数组[0]。长度；
var maxLength=数学最大值（X长度，Y长度）；
无功温度；
对于（变量k=0；k=0；--y）{
var x=k-y；
如果（x>=0&&x0）{
document.body.innerHTML+=temp.join（“”）+'
'；
}
}

以下是我对“从左上到右下”的尝试：

for (i=0; i<nbRows; i++) {
    x = 0; y = i;
    while (x < nbColumns && y >= 0) {
        print(array[x, y]);
        x++; y--;
    }
    print("\n");
}
for (i=1; i<nbColumns; i++) {
    x = i; y = nbRows - 1;
    while (x < nbColumns && y >=0) {
        print(array[x, y]);
        x++; y--;
    }
}

for（i=0；i=0）{
打印（数组[x，y]）；
x++；y--；
}
打印（“\n”）；
}
对于（i=1；i=0）{
打印（数组[x，y]）；
x++；y--；
}
}

---

需要进行一些调整以适应JavaScript语法。

这就完成了，并将所需结果输出到屏幕：

var数组=['ABCD'，'EFGH'，'IJKL']；
var rows=array.length；
var cols=数组[0]。长度；
对于（变量n=0；n=0&&c”）；
}

即使对于矩形矩阵，这也应该有效：

var数组=[“ABCD”、“EFGH”、“IJKL”]；
var arrOfArr=[]；
var resultArray=[]；
对于（变量i=0；i=0；--j）{
结果ray[index].push（arrOfArr[j][k]）；
++k；
if（k==列）{
打破
}
}
resultaray[index]=resultaray[index]。联接（“”）；
++指数；
}
对于（变量j=1；j试试这个


var TheArray=['ABCD'，'EFGH'，'IJKL']；
//行数
var RowLength=数组长度；
//柱数
var ColumnLength=数组[0]。长度；
var totalNoComb=行长+列长-1；
var combArr=新阵列（totalNoComb）；
对于（var i=0；i-1；j--）{
if（i-j>-1&&i-j-1&&i-j警报（combArr）注意：这假设所有字符串大小相同，或者至少与第一个字符串一样大

在2D数组（或者在本例中是字符串数组）中，对角线的索引与对角线的编号相加（类似于行号）。00、01 10、02 11 20等

使用此方法，对角线“行”的数量（从零开始）等于最大索引的总和，或者等于（columnlength+rowlength-2）的总和

因此，我的解决方案是迭代对角线行号并打印其和等于当前对角线行的所有索引对

var TheArray = ["ABCD","EFGH","IJKL"];
//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

var text = ''
for (i = 0; i <= (RowLength+ColumnLength-2); i++){
    for (x = 0; x<=i; x++){
    if (TheArray[i-x] && TheArray[i-x][x]){
        text += TheArray[i-x][x];
    }
  }
  text += "<br/>";
}

document.getElementById('text').innerHTML = text;

var TheArray=[“ABCD”、“EFGH”、“IJKL”]；
//行数
var RowLength=数组长度；
//柱数
var ColumnLength=数组[0]。长度；
变量文本=“”
对于（i=0；i两条对角线的完整解：

var TheArray = ['ABCD', 'EFGH', 'IJKL'];
var RowLength = TheArray.length;
var ColumnLength = TheArray[0].length;

// Diagonals
var diagonal = [[], []];
for (var i = 0; i < Math.min(RowLength, ColumnLength); i++) {
    diagonal[0].push({'row': 0-i, 'col': i});
    diagonal[1].push({'row': 0-i, 'col': 0-i});
}

// Entry points
// 1///
// 2///
// 3456
var points = [[], []];
for (var y = 0; y < RowLength; y++) {
    points[0].push({'row': y, 'col': 0});
}
for (var x = 1; x < ColumnLength; x++) {
    points[0].push({'row': RowLength - 1, 'col': x});
}

// Entry points
// \\\6
// \\\5
// 1234
for (var x = 0; x < ColumnLength; x++) {
    points[1].push({'row': RowLength - 1, 'col': x});
}
for (var y = RowLength - 2; y >= 0; y--) {
    points[1].push({'row': y, 'col': ColumnLength - 1});
}

var strings = [[], []];
for (var line = 0; line < diagonal.length; line++) {
    for (var point = 0; point < points[line].length; point++) {
        var inside = true;
        var index = 0;
        var string = '';
        while (inside && index < diagonal[line].length) {
            var row = points[line][point]['row'] + diagonal[line][index]['row'];
            var col = points[line][point]['col'] + diagonal[line][index]['col'];
            if (row >= 0 && row < RowLength && col >= 0 && col < ColumnLength) {
                string += TheArray[row][col];
                index++;
            } else {
                inside = false;
            }
        }
        strings[line].push(string);
    }
}

console.log(strings);

var TheArray=['ABCD'，'EFGH'，'IJKL']；
var RowLength=数组长度；
var ColumnLength=数组[0]。长度；
//对角线
变量对角线=[]，[]；
对于（var i=0；i=0；y--）{
点[1]。推送（{'row'：y，'col'：ColumnLength-1}）；
}
变量字符串=[]，[]；
（弗吉尼亚州）
for (i=0; i<nbRows; i++) {
    x = 0; y = i;
    while (x < nbColumns && y >= 0) {
        print(array[x, y]);
        x++; y--;
    }
    print("\n");
}
for (i=1; i<nbColumns; i++) {
    x = i; y = nbRows - 1;
    while (x < nbColumns && y >=0) {
        print(array[x, y]);
        x++; y--;
    }
}

var TheArray = ["ABCD","EFGH","IJKL"];
//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

var text = ''
for (i = 0; i <= (RowLength+ColumnLength-2); i++){
    for (x = 0; x<=i; x++){
    if (TheArray[i-x] && TheArray[i-x][x]){
        text += TheArray[i-x][x];
    }
  }
  text += "<br/>";
}

document.getElementById('text').innerHTML = text;

var TheArray = ['ABCD', 'EFGH', 'IJKL'];
var RowLength = TheArray.length;
var ColumnLength = TheArray[0].length;

// Diagonals
var diagonal = [[], []];
for (var i = 0; i < Math.min(RowLength, ColumnLength); i++) {
    diagonal[0].push({'row': 0-i, 'col': i});
    diagonal[1].push({'row': 0-i, 'col': 0-i});
}

// Entry points
// 1///
// 2///
// 3456
var points = [[], []];
for (var y = 0; y < RowLength; y++) {
    points[0].push({'row': y, 'col': 0});
}
for (var x = 1; x < ColumnLength; x++) {
    points[0].push({'row': RowLength - 1, 'col': x});
}

// Entry points
// \\\6
// \\\5
// 1234
for (var x = 0; x < ColumnLength; x++) {
    points[1].push({'row': RowLength - 1, 'col': x});
}
for (var y = RowLength - 2; y >= 0; y--) {
    points[1].push({'row': y, 'col': ColumnLength - 1});
}

var strings = [[], []];
for (var line = 0; line < diagonal.length; line++) {
    for (var point = 0; point < points[line].length; point++) {
        var inside = true;
        var index = 0;
        var string = '';
        while (inside && index < diagonal[line].length) {
            var row = points[line][point]['row'] + diagonal[line][index]['row'];
            var col = points[line][point]['col'] + diagonal[line][index]['col'];
            if (row >= 0 && row < RowLength && col >= 0 && col < ColumnLength) {
                string += TheArray[row][col];
                index++;
            } else {
                inside = false;
            }
        }
        strings[line].push(string);
    }
}

console.log(strings);