Javascript jQuery：递归太多了，但我需要对扫雷舰进行递归

我对javascript比较陌生。我正试图为我的扫雷舰网络版编写代码。这是我需要的一个递归函数，在浏览器给出这个“太多递归”错误之前，它看起来可以正常工作。问题是我需要递归。有没有其他办法给扫雷舰编码？以下是演示：

如果需要，我可以发布我的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);
                                } 
                            }                               
                        }
                    }
                } 
            }           

函数递归（id）{ var id=id； //确定这是什么类型的电池：干净的，炸弹还是炸弹的邻接物 if（$（“#”+id）.hasClass（“adj”）==true） var在=“adj”下； if（$（“#”+id）.hasClass（“炸弹”）==true） var在=“炸弹”下； if（$（“#”+id）.hasClass（“clean”）==true） var在=“clean”下； //打开牢房 $（“#”+id）.hide（）； $（“#在”+id.show（）下）； //如果是炸弹，打开整个电网和按钮重新启动 如果（低于==‘炸弹’） { $（“.cover”）.hide（）； $（“.under”）.show（）； $（“正文”）。追加（
）； }否则{ //如果是干净的电池 如果（在==“清洁”下） { //获取所有相邻的单元格ID var split=id.split（'-'）； var row=parseInt（拆分[0]）； var col=parseInt（拆分[1]）； var adjasent=新数组（）； 邻接词[0]=（第1行）+“-”+（第1列）； 邻接词[1]=行+“-”+（列+1）； 邻接词[2]=（行+1）+“-”+（列+1）； 邻接词[3]=（行+1）+“-”+列； 邻接词[4]=（行+1）+“-”+（列-1）； 形容词[5]=行+“-”+（列-1）； 邻接词[6]=（第1行）+“-”+（第1列）； 邻接词[7]=（第1行）+“-”+列； //循环通过相邻单元 对于（变量i=0；变量i 0&&row2<17） { 如果（col2>0&&col2<17） { //执行递归 var adj=邻接物[i]； 递归（adj）； } } } } } }

---

我的猜测是，如果两个干净的单元格相邻，那么代码将进入无限递归

每个迭代递归到所有相邻单元。假设细胞A和B彼此相邻，并且都是干净的。A将调用递归到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

---

我的猜测是，如果两个干净的单元格相邻，那么代码将进入无限递归

每个迭代递归到所有相邻单元。假设细胞A和B彼此相邻，并且都是干净的。A将调用递归到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

---

保留要检查的单元格id的运行数组，并在检查时从数组中删除这些值

        var stack = ["first_id_to_check"];

        function check(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)
                            {
                                stack.push(adjasent[i]);
                            } 
                        }                               
                    }
                }
            } 
        }

        while(stack[0]!==undefined) {
            check(stack[0]);
            stack.splice(0,1);
        }

var stack=[“第一个要检查的id”]；
功能检查（id）{
var id=id；
//确定这是什么类型的电池：干净的，炸弹还是炸弹的邻接物
if（$（“#”+id）.hasClass（“adj”）==true）
var在=“adj”下；
if（$（“#”+id）.hasClass（“炸弹”）==true）
var在=“炸弹”下；
if（$（“#”+id）.hasClass（“clean”）==true）
var在=“clean”下；
//打开牢房
$（“#”+id）.hide（）；
$（“#在”+id.show（）下）；
//如果是炸弹，打开整个电网和按钮重新启动
如果（低于==‘炸弹’）
{       
$（“.cover”）.hide（）；
$（“.under”）.show（）；
$（“正文”）。追加（
）；
}否则{
//如果是干净的电池
如果（在==“清洁”下）
{
//获取所有相邻的单元格ID
var split=id.split（'-'）；
var row=parseInt（拆分[0]）；
var col=parseInt（拆分[1]）；
var adjasent=新数组（）；
邻接词[0]=（第1行）+“-”+（第1列）；
邻接词[1]=行+“-”+（列+1）；
邻接词[2]=（行+1）+“-”+（列+1）；
邻接词[3]=（行+1）+“-”+列；
邻接词[4]=（行+1）+“-”+（列-1）；
形容词[5]=行+“-”+（列-1）；
邻接词[6]=（第1行）+“-”+（第1列）；
邻接词[7]=（第1行）+“-”+列；