javascript - jQuery:太多递归但我需要扫雷递归

Question

我对 javascript 比较陌生。我正在尝试编写我的扫雷网页版代码。这是我需要的一个递归函数，它看起来工作正常，直到浏览器给出“太多递归”错误。问题是我需要递归。还有其他方法来编码扫雷吗？这是演示:http://altynachar.com/minesweeper/

如果需要，我可以发布我的 php 代码。

function recursive(id){
                var id = id;
                //Determine what kind of cell this is: Clean, Bomb or Adjasent to bomb
                if($("#"+id).hasClass("adj")== true)
                    var under = "adj";
                if($("#"+id).hasClass("bomb")==true)
                    var under = "bomb";
                if($("#"+id).hasClass("clean")==true)
                    var under = "clean";

                //open up the cell          
                $("#"+id).hide();
                $("#under_"+id).show(); 

                //if it is bomb, open up whole grid and button for restart
                if(under == 'bomb')
                {       
                    $(".cover").hide();
                    $(".under").show();
                    $("body").append("<br /><input type='button' value='restart' onClick='javascript:window.location.reload();' />");
                } else {        

                    //if it is clean cell       
                    if(under == "clean")
                    {
                        //get all the adjasent cell ids
                        var split = id.split('-');
                        var row = parseInt(split[0]);
                        var col = parseInt(split[1]);
                        var adjasent = new Array();
                        adjasent[0] = (row-1)+"-"+ (col+1);
                        adjasent[1] =  row +"-"+(col+1);
                        adjasent[2] = (row+1)+"-"+(col+1);
                        adjasent[3] = (row+1)+"-"+col;
                        adjasent[4] = (row+1)+"-"+(col-1);
                        adjasent[5] =  row+"-"+(col-1);
                        adjasent[6] = (row -1)+"-"+(col-1);
                        adjasent[7] = (row -1)+"-"+col;

                        //loop through adjasent cells
                        for(var i=0; i<adjasent.length; i++)
                        {
                            var split2 = adjasent[i].split('-');
                            var row2 = parseInt(split2[0]);
                            var col2 = parseInt(split2[1]);

                            //check if cell is existent
                            if(row2 > 0 && row2 < 17)
                            {
                                if(col2 > 0 && col2 < 17)
                                {
                                    //perform recursion
                                    var adj = adjasent[i];
                                    recursive(adj);
                                } 
                            }                               
                        }
                    }
                } 
            }           

Answer 1

我的猜测是，如果你有 2 个彼此相邻的干净单元格，你的代码将陷入无限递归。

每次迭代都会递归到所有相邻单元格。假设 A 单元和 B 单元相邻，并且都是干净的。 A 会调用 recurse 到 B，然后 B 会递归到 A，A 又递归到 B，依此类推。

您可以尝试清理递归，以便它不会查看已经看到的单元格，或者删除递归。您可以通过将任何看不见的干净单元添加到队列中来完成同样的事情，然后不断从队列末尾弹出直到队列为空。这可能会更容易避免两次检查同一个单元格。

<小时/>

此外，请不要构建字符串只是为了稍后将它们拆分为单独的数据。而不是:

adjasent[0] = (row-1)+"-"+ (col+1);
/* ... */
var split2 = adjasent[i].split('-');
var row2 = parseInt(split2[0]);
var col2 = parseInt(split2[1]);

就这么做

adjacent[0] = { row: row-1, col: col+1 };
/* ... */
var row2 = adjacent[0].row
var col2 = adjacent[0].col