标记"；参观；使用javascript数组元素表示矛盾的结果

JS男孩/女孩！我的印象是，在JavaScript的2D数组中使用BFS时，我们可以直接在数组元素上标记“已访问”，如：grid[I][j]。visted=true，然后下次检查grid[I][j]。visted时，它将返回true。下面是一段这样工作的示例代码（请随意运行）：

var findP=函数（原点、网格）{
变量q=[原点]，计数=0；
网格[origin[0]][origin[1]]。已访问=真；
var arr=[[0，-1]，[0,1]，-1,0]，[1,0]；
而（q.length>0）{
var c=q.长度；
计数++；
而（c>=0）{
var t=q.shift（）；
如果（网格[t[0]][t[1]=='#'）{
返回计数；
}
对于（变量i=0；igrid.length-1）{
继续；
}
var n=t[1]+arr[i][1]；
if（n<0 | | n>网格[0]。长度-1）{
继续；
}
如果（网格[m][n]！='X'&&！网格[m][n]。已访问）{
网格[m][n]。已访问=真；
q、 推力（[m，n]）；
}
}
c--；
}
}
返回-1；
}
log（findP（[1,1]，[X'，'X'，'X'，'X'，'X']，[X'，'X']，[X'，'*'，'X'，'O'，'X']，
[‘X’、‘O’、‘O’、‘#’、‘#’、[‘X’、‘X’、‘X’、‘X’、‘X’]））

上面的代码运行良好。但是，当我尝试此方法时，它根本不起作用（无限循环警报。运行它不会很有趣）：

var shortestPath=函数（arr）{
如果（！arr | | arr.length==0）{
返回-1；
}
var i，j，hasBen=假；
对于（i=0；i0）{
var计数器=q.长度；
steps++；
而（计数器>0）{
var temp=q.shift（）；//temp=[i，j]；
对于（var x=0；x=arr[0]。长度| | n<0 | | n>=arr.length）{
继续；
}
如果（！arr[m][n]。已访问）{
arr[m][n]。已访问=真；
如果（arr[m][n]='#'）{
flag=true；
打破
}
如果（arr[m][n]！='X'）{
q、 推力（[m，n]）；
}
}
}
国际单项体育联合会（旗）{
打破
}
计数器--；
}
}
返回标志？步骤：-1；
}
最短路径（[['*'，'O'，'O'，'X']，['X'，'X'，'O'，'X']，['X'，'X'，'#'，'X']）；

---

上面代码中的两个console.log（）都未定义日志，这导致无限循环。但是，为什么第一个代码段可以工作，而第二个代码段却不能？在数组元素上附加.时，它们不是相同的吗？我真的很困惑。

你能告诉我们你到底想做什么，而不是怎么做吗？对于所有单字母变量、缺少注释和嵌套循环，您的代码很难理解。对于记录，您无法在字符串文字上设置属性。但是，您可以在它的“对象包装器”上。例如：

var x=“5”；x、 访问=真实；console.log（x.visted）//未定义

。然而，如果你说

varx=newstring（5）；x、 访问=真实；console.log（x.visted）//true

@mhodges虽然我发布的问题与代码正在解决的问题无关，但问题描述如下：2d数组中有4种元素：“*”、“#”、“x”、“O”。*是你的起点，是你的目标终点。X是你们不能通过的元素，O是你们可以通过的元素。找到从*到#的最短路径。我的问题是：为什么在第一个代码段中，我可以使用grid[x][y].visitored=true，而在第二个代码段中，arr[x][y].visitored=true不起作用？是的，在我自己对代码进行了一点修改之后，我明白了你想要做什么。如果您在任一示例中

console.log（arr[x][y].visited）

，它将返回undefined。我会在一天中再处理一些事情，看看我是否能弄明白。我想我知道现在发生了什么。非常感谢您指出我们“无法在字符串文字上设置属性”。我想第一个代码段起作用是不寻常的，而不是第二个代码段不起作用。。。。我将创建一个已访问的数组来解决此问题。再次感谢！

var findP = function(origin, grid) {
var q = [origin], count = 0;
grid[origin[0]][origin[1]].visited = true;

var arr = [[0, -1], [0, 1], [-1, 0], [1, 0]];
while(q.length > 0) {
    var c = q.length;
    count++;
    while(c >= 0) {

        var t = q.shift();
        if (grid[t[0]][t[1]] === '#') {
            return count;
        }
        for(var i = 0; i < arr.length; i++) {

            var m = t[0] + arr[i][0];
            if (m < 0 || m > grid.length - 1) {
                continue;
            }
            var n = t[1] + arr[i][1];
            if (n < 0 || n > grid[0].length - 1) {
                continue;
            }
            if (grid[m][n] !== 'X' && !grid[m][n].visited) {
                grid[m][n].visited = true;
                q.push([m, n]);
            }
        }
        c--;
    }
}
return -1;
}
console.log(findP([1, 1],[['X','X','X','X','X'], ['X','*','X','O','X'],
         ['X','O','O','#','#'],['X','X','X','X','X']]))

var shortestPath = function(arr) {
if (!arr || arr.length === 0) {
    return -1;
}
var i, j, hasBen = false;
for (i = 0; i < arr.length; i++) {
    for (j = 0; j < arr[i].length; j++) {
        if (arr[i][j] === '*') {
            hasBen = true;
            break;
        }
    }
    if (hasBen) {
        break;
    }
}
//(i, j) is where Ben is:
var steps = 0, helper = [[1, 0], [-1, 0], [0, 1], [0, -1]];
var q = [[i, j]], flag = false;
arr[i][j].visited = true;
console.log(arr[i][j].visited); // undefined
console.log(arr[0][0].visited); //undefined
while(q.length > 0) {
    var counter = q.length;
    steps++;
    while(counter > 0) {
        var temp = q.shift(); // temp = [i, j];
        for (var x = 0; x < helper.length; x++) {
            var t = helper[x];
            var m = temp[0] + t[0];
            var n = temp[1] + t[1];
            if (m < 0 || m >= arr[0].length || n < 0 || n >= arr.length) {
                continue;
            }
            if (!arr[m][n].visited) {
                arr[m][n].visited = true;
                    if (arr[m][n] === '#') {
                        flag = true;
                        break;
                    }
                    if (arr[m][n] !== 'X') {
                        q.push([m, n]);
                    }

                }
        }
        if (flag) {
            break;
        }
        counter--;
    }
}
return flag ? steps : -1;
}
shortestPath([['*', 'O', 'O', 'X'], ['X', 'X', 'O', 'X'], ['X', 'X', '#', 'X']]);