无限递归-Javascript极小极大

我正在尝试使用该库创建一个国际象棋AI。我使用的是带有Alpha-Beta修剪的minimax解决方案，但由于某些原因，当程序运行时，即使深度达到0，它也会继续运行。谁能告诉我为什么

var Buddha = function() {

  this.movehistory = 0;
  this.color = "b";
  this.opp = "w";


  this.minimax = function(board, depth, alpha, beta) {
    console.log(depth);
    if(depth === 0 || board.game_over() === true) {
      console.log("Depth == 0");
      return [this.eval_board(board), null]
    } else {
      if(board.turn() === this.color) {
        var bestmove = null

        var possible_moves = board.moves()
        for (index = 0; index < possible_moves.length; ++index) {
          var new_board = new Chess(board.fen());
          new_board.move(possible_moves[index])

          var mini = this.minimax(new_board, --depth, alpha, beta)
          var score = mini[0];
          var move = mini[1];

          if(score > alpha) {
            alpha = score;
            bestmove = possible_moves[index];
            if(alpha >= beta) {
              break;
            }
          }
        }
        return [alpha, bestmove]
      } else if(board.turn() === this.opp) {
        var bestmove = null

        var possible_moves = board.moves()
        for (index = 0; index < possible_moves.length; ++index) {
          var new_board = new Chess(board.fen());
          new_board.move(possible_moves[index])

          var mini = this.minimax(new_board, --depth, alpha, beta)
          var score = mini[0];
          var move = mini[1];

          if(score < beta) {
            beta = score;
            bestmove = possible_moves[index];
            if(alpha >= beta) {
              break;
            }
          }
        }
        return [beta, bestmove]
      }
    }
  }

  this.eval_board = function(board) {
    if(board.in_check()) {
      if(board.turn() == this.opp) {
        return Number.POSITIVE_INFINITY;
      } else {
        return Number.NEGATIVE_INFINITY;
      }
    } else if(board.in_checkmate()) {
      if(board.turn() == this.opp) {
        return Number.POSITIVE_INFINITY;
      } else {
        return Number.NEGATIVE_INFINITY;
      }
    } else if(board.in_stalemate()) {
      if(board.turn() == this.opp) {
        return Number.POSITIVE_INFINITY;
      } else {
        return Number.NEGATIVE_INFINITY;
      }
    }
  }

  this.move = function(board) {
    var bestmove = this.minimax(board, 1, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
  }

}

var=function（）{
this.movehistory=0；
this.color=“b”；
this.opp=“w”；
this.minimax=函数（板、深度、α、β）{
控制台日志（深度）；
如果（深度==0 | | board.game_over（）==true）{
console.log（“深度==0”）；
返回[this.eval_board（board），null]
}否则{
if（board.turn（）==此.color）{
var bestmove=null
var可能的移动=board.moves（）
对于（索引=0；索引<可能的长度；++索引）{
var new_board=新国际象棋（board.fen（））；
新建电路板。移动（可能的移动[索引]）
var mini=此.minimax（新板，--深度，α，β）
var得分=最小值[0]；
var move=mini[1]；
如果（分数>α）{
α=分数；
最佳移动=可能的移动[索引]；
如果（α>=β）{
打破
}
}
}
返回[阿尔法，最佳移动]
}else if（board.turn（）==this.opp）{
var bestmove=null
var可能的移动=board.moves（）
对于（索引=0；索引<可能的长度；++索引）{
var new_board=新国际象棋（board.fen（））；
新建电路板。移动（可能的移动[索引]）
var mini=此.minimax（新板，--深度，α，β）
var得分=最小值[0]；
var move=mini[1]；
如果（分数=β）{
打破
}
}
}
返回[beta，bestmove]
}
}
}
this.eval_板=功能（板）{
if（线路板输入检查（））{
if（board.turn（）==this.opp）{
返回数。正无穷大；
}否则{
返回数.负_∞；
}
}else if（board.in_checkmate（））{
if（board.turn（）==this.opp）{
返回数。正无穷大；
}否则{
返回数.负_∞；
}
}else if（board.in_stalate（））{
if（board.turn（）==this.opp）{
返回数。正无穷大；
}否则{
返回数.负_∞；
}
}
}
this.move=功能（板）{
var bestmove=this.minimax（电路板，1，数字。负无穷大，数字。正无穷大）
}
}

函数极小极大值（板、深度、α、β）{
如果（深度===0…{…
返回…
}否则{
…
对于（索引=0；索引<可能的长度；++索引）{
…minimax（新的_板，--深度，α，β）
//                         ^^
…
}
}
}

---

这里是在循环中递减

深度。使用
depth为什么--depth和depth-1会有所不同？他们不是在创造同样的东西吗？不是。
--depth
是一个-与
depth-=1
或
depth=depth-1
相同。如果您不知道它的功能，请不要使用它：-）对不起，我不太擅长Javascript。我更像是个巨蟒。我认为他们都做了同样的事。非常感谢。啊，我明白了。
function minimax(board, depth, alpha, beta) {
  if(depth === 0 …) { …
    return …
  } else {
    …
    for (index = 0; index < possible_moves.length; ++index) {
      … minimax(new_board, --depth, alpha, beta)
//                         ^^
    …
    }
  }
}