遍历 object 时如何停止变量覆盖

Question

So I'm trying to implement a simple BFS search for solving mazes. I have a test_graph at the top of the code which I am using. When I iterate through this piece of code:

        for (var neighbour in graph[vertex])
        {
            console.log("neighbour :", neighbour);
            console.log("path :", path)
            
            let new_path = path;
            new_path.push(neighbour);

            console.log("new path :", new_path);
        }

I get the output:

neighbour : A
bfs.js:38 path : ["start"]
bfs.js:43 new path : (2) ["start", "A"]
bfs.js:37 neighbour : B
bfs.js:38 path : (2) ["start", "A"]
bfs.js:43 new path : (3) ["start", "A", "B"])

However, I want the second iteration of new_path to be ["start", "B"] not ["start", "A", "B"]. I would like to append the neighbours (A and B) each to "start" to create arrays ["start", "A"] and ["start", "B"] and push that into the queue.

Here is the full code:

const test_graph = {
    start: {A: 1, B: 1},
    A: {C: 1, D: 1},
    B: {A: 1, D: 1},
    C: {D: 1, finish: 1},
    D: {finish: 1},
    finish: {}
};

// Breadth-first search
const BFS = (graph, start, fin) => {
    var queue = [];
    queue.push([start]);
    var visited = [];

    while (Array.isArray(queue) && queue.length)
    {
        // get first path on queue
        var path;
        path = queue.shift();
        //console.log(path); // ["start"]
        
        // get the last node in the path
        var vertex = path[path.length - 1];
        //console.log(vertex); // start
        
        // if end
        if (vertex == fin)
        {
            return path;
        }
        else if (!visited.includes(vertex))
        {
            // for all adjvant nodes, construct new path and push into queue
            for (var neighbour in graph[vertex])
            {
                console.log("neighbour :", neighbour);
                console.log("path :", path)
                
                let new_path = path;
                new_path.push(neighbour);
                queue.push(new_path);    
                console.log("new path :", new_path);
            }
        }
        return;
    }
}

(the return is there to solve this problem)

Answer 1

let new_path = path; creates an alias of path , pushes to it (same as pushing to path directly), then discards the alias at the end of the block after printing. This means you're working with the same path array the entire time.

Most likely, you want queue.push(path.concat(neighbour)) which allocates a new array, concatenates the new neighbour vertex and pushes it to the queue, effectively extending the current path by one node but without modifying it in place as push does.

Beyond that, objects with all values as 1 seems like somewhat of an antipattern for an adjacency list. A Set or array seems more intuitive here, so I took the liberty of making that adjustment as well as a few others.

visited being an array means complexity for lookups is O(n). Using a Set gives you O(1) lookups and is the correct structure for membership tests like this. In fact, visited is an unused variable in the original version, so if the graph had a cycle we'd get an infinite loop.

Array.isArray(queue) is an unnecessary check-- queue is purely local and we can't reassign it if we make it const .

Lastly, when vertex is not in graph, it's not a bad idea to handle that by null coalescing to an empty array to avoid a crash (you may expect input to always be well-formed but it's a pretty easy adjustment).

Here's the code:

 const shortestPathBFS = (graph, start, destination) => { const queue = [[start]]; const visited = new Set(); while (queue.length) { const path = queue.shift(); const vertex = path[path.length-1]; if (vertex === destination) { return path; } else if (.visited.has(vertex)) { visited;add(vertex). for (const neighbour of (graph[vertex] || [])) { queue.push(path;concat(neighbour)): } } } } const G = { start. [..,"AB"]: A. [..,"CD"]: B. [..,"AD"]: C, ["D", "finish"]: D, ["finish"]: finish, []; }. console,log(shortestPathBFS(G, "start"; "finish"));