Javascript 为什么阵列会在没有代码的情况下更改？

我的代码中有两个数组，分别是res_矩阵和original_矩阵

原始_矩阵是一个m*n矩阵，在每个单元格中填充“false”

然后让

res\u matrix=original\u matrix

我的代码使用res_矩阵进行所有计算，甚至不涉及原始矩阵

但我从控制台日志中看到，orginial_矩阵也发生了变化

谁能告诉我哪里做错了？谢谢

board = [["a","b"]];
word = "ba";

var exist = function(board, word) {
    
    let res = [], res_matrix = [], original_matrix = [];
    if (board.length === 0) {
        return false;
    } else {
        h = board.length;
        w = board[0].length;
        
        for (let x = 0; x < h; x++) {
            var row = [];
            for (let y = 0; y < w; y++) {
                row.push(false);
            }
            original_matrix.push(row);
        }
        
        for (let i = 0; i<h;i++) {
            for (let j=0;j<w;j++) {
                res_matrix = original_matrix;
                
                if (j===0) {
                    console.log("111111111", original_matrix);
                } else if (j===1) {
                    console.log("2222222", original_matrix);
                }
                if (dfs(i,j,0)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    function dfs(i,j, index) {
        
        if (index === word.length) {
            console.log('founded')
            return true;
        }
        
        console.log(i,j, index, word[index], res_matrix);
        
        if (i>=0 && i < h && j < w && j >= 0 && !res_matrix[i][j] && 
        index<=word.length) {
            
            res_matrix[i][j] = true;
            
            if (board[i][j] === word[index]) {
                if (dfs(i+1,j,index+1) ||
                    dfs(i-1,j,index+1) ||
                    dfs(i,j+1,index+1) ||
                    dfs(i,j-1,index+1)) {
                    return true;
                }
                
            }
        }
        return false;
    }
};


exist(board, word);

您可以在此处查看并运行代码：

---

将两个数组设置为彼此相等不会复制数组，而是复制引用。所有对象（如数组、对象或类实例）也是如此。使用旧变量的值创建新变量时，使用引用更新任何变量

var a=['some'，'random'，'elements']；
var b=a；
var c=a；
var d=b；
d、 推（“另一个元素”）；
b、 推动（“一个或多个元素”）；
c、 推动（“最后一个元素”）；
控制台日志（a）；
控制台日志（b）；
控制台日志（c）；
控制台日志（d）；

如果你看一下这段代码，你会注意到所有四个数组（

a

，

b

，

c

，和

d

）在最后都是等价的，即使三次更新了三个不同的变量。这是因为它们都共享相同的引用。字符串和数字等数据类型不共享引用，而是创建副本。请参见下面的示例：

var a='hello'；
var b=a；
b=‘再见’；
控制台日志（a）；
控制台日志（b）；

如果运行此代码，您将注意到

a

仍然是hello，只有

b

更改为

“再见”

---

由于您有一个多维数组，最简单的方法就是使用

json.stringify（）

将对象转换为json字符串，并立即使用

json.parse（）

对其进行解析。这仅适用于嵌套对象，而不适用于函数。运行

var arrCopy=JSON.parse（JSON.stringify（arr））

将创建数组的副本而不是引用，因此更新

arrCopy

不会更新

arr

res\u matrix=original\u matrix

不会创建源数组的副本。您是否尝试使用slice（）创建原始数组的副本？

111111111 [ [ false, false ] ]
0 0 0 b [ [ false, false ] ]
2222222 [ [ true, false ] ]
0 1 0 b [ [ true, false ] ]
1 1 1 a [ [ true, true ] ]
-1 1 1 a [ [ true, true ] ]
0 2 1 a [ [ true, true ] ]
0 0 1 a [ [ true, true ] ]