如何提升Minimax国际象棋引擎中棋盘复制操作的速度？

Great question—repeatedly copying a 120-element array for every possible move is a common bottleneck in chess engines, especially when scaling up Minimax depth. Let’s walk through practical, bitboard-free solutions to speed this up, starting with the most impactful:

1. Replace Copies with State Backtracking (Best Performance Gain) #

The biggest win here is to avoid copying the entire board altogether. Instead of creating a new board copy for each move, modify the original board, run your evaluation, then undo the move to restore the original state. This only touches 2-3 elements per move (the start square, end square, and possibly a captured piece) instead of copying 120 elements every time.

Here’s how to adjust your code:

pisces.forEach(pisce => {
  pisce.forEach(move => {
    // 1. Save the original state of the squares involved in the move
    const originalFromPiece = board[move.from];
    const originalToPiece = board[move.to];
    // If handling castling or en passant, save additional squares here too
    
    // 2. Execute the move on the original board
    board[move.to] = originalFromPiece;
    board[move.from] = 0; // Assume 0 represents an empty square
    
    // 3. Run your evaluation/Minimax logic here ("other stuff")
    
    // 4. Undo the move to restore the original board state
    board[move.from] = originalFromPiece;
    board[move.to] = originalToPiece;
  });
});

This approach eliminates all array copy overhead entirely—this is by far the most effective optimization you can make.

2. Optimize Array Copies If You Must Use Them #

If backtracking isn’t feasible for your engine’s architecture (e.g., if you need to keep multiple board states in memory simultaneously), you can speed up the copy operation itself:

• Use Typed Arrays: Instead of a regular JavaScript array, use a Uint8Array or Uint16Array (since chess pieces can be represented with small integers). Typed arrays are optimized for memory and copy operations, as they use raw memory buffers under the hood.

  // Initialize your board as a Typed Array
  const board = new Uint8Array(120);
  
  // Copy is a direct memory copy, faster than [...board]
  const copy = new Uint8Array(board);
  

• Prefer slice() over spread syntax: For regular arrays, board.slice() is often slightly faster than [...board] in practice, as it’s a more specialized method for array duplication.

3. Why Strings Aren’t a Good Solution #

While copying a string is fast (since strings are immutable and can be referenced), modifying a string-based board is extremely slow. To change a single square, you’d have to convert the string to an array, modify the element, then convert it back to a string—this adds far more overhead than copying an array in the first place. Stick to array-based representations for mutable board states.

内容的提问来源于stack exchange，提问作者ne0123.