NodeJS后端骑士最短路径API开发：数据传递与架构咨询

Hey there! Let's tackle your questions step by step and share some practical, optimized tips for your knight's shortest path REST API:

First, you'll need a properly structured Mongoose Move model to store the path data. Then, once your Board class returns the calculated path, you can instantiate a new document and save it to the database.

Step 1: Define the Move Model #

const mongoose = require('mongoose');

const moveSchema = new mongoose.Schema({
  startPosition: { type: String, required: true, match: /^[a-h][1-8]$/ },
  endPosition: { type: String, required: true, match: /^[a-h][1-8]$/ },
  path: { type: [String], required: true },
  createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Move', moveSchema);

Step 2: Integrate with Your Controller #

Assuming your Board.endPosition() method returns a valid path array (e.g., ['a1', 'b3', 'c5']), here's how to save it:

const Move = require('../models/Move');
const Board = require('../utils/Board');

async function calculateAndSavePath(req, res) {
  const { start, target } = req.body;
  const board = new Board();

  try {
    // Calculate the shortest path
    const path = board.endPosition(start, target);
    
    // Create and save the move document
    const newMove = new Move({
      startPosition: start,
      endPosition: target,
      path: path
    });
    await newMove.save();

    res.status(201).json({
      success: true,
      path: path,
      moveId: newMove._id // Return ID for future lookups
    });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
}

module.exports = { calculateAndSavePath };

Ditch the hardcoding by accepting parameters from the request body. Here's how to set this up with Express:

Step 1: Define the Route #

const express = require('express');
const router = express.Router();
const chessController = require('../controllers/chessController');

// POST endpoint to calculate and optionally save the path
router.post('/knight/path', chessController.calculateAndSavePath);

Step 2: Accept JSON Input #

When sending a request (via Postman, frontend, etc.), pass the start/target in the request body as JSON:

{
  "start": "a1",
  "target": "c5"
}

Step 3: Validate Inputs #

Add input validation to avoid invalid square values (use express-validator for this):

const { body, validationResult } = require('express-validator');

// Update the route with validation middleware
router.post('/knight/path', [
  body('start').matches(/^[a-h][1-8]$/).withMessage('Start must be a valid chess square (e.g., a1)'),
  body('target').matches(/^[a-h][1-8]$/).withMessage('Target must be a valid chess square (e.g., c5)')
], chessController.calculateAndSavePath);

Then check for validation errors in your controller before proceeding:

const errors = validationResult(req);
if (!errors.isEmpty()) {
  return res.status(400).json({ errors: errors.array() });
}

Stick to RESTful conventions with these route patterns:

• POST /api/knight/path: Calculate the shortest path and save it to the database (returns path + move ID)
• GET /api/knight/path/:moveId: Retrieve a saved path by its ID
• GET /api/knight/paths: Fetch all saved paths (add query params like ?start=a1 or ?limit=10 for filtering/pagination)
• GET /api/knight/path: Calculate a path without saving it (use query params: ?start=a1&target=c5)

It depends on your use case:

• No database needed: If you only need to calculate paths in real-time and don't need to track historical queries. This keeps your API lightweight and fast.
• Database recommended: If you want to log user queries, track usage metrics, or let users revisit past paths.

You can even offer both options: add a save boolean parameter to the POST request, so users can choose whether to persist the path.

Use BFS for Shortest Path Calculation #

While chess.js is great for validating moves, the knight's shortest path is a classic BFS problem (BFS guarantees the shortest path in unweighted graphs). Here's a refined Board class with BFS:

class Board {
  constructor() {
    // All 8 possible knight moves (column, row)
    this.knightMoves = [[2,1],[1,2],[-1,2],[-2,1],[-2,-1],[-1,-2],[1,-2],[2,-1]];
  }

  // Convert chess square (e.g., a1) to coordinates [0,0]
  squareToCoords(square) {
    const col = square.charCodeAt(0) - 'a'.charCodeAt(0);
    const row = parseInt(square[1]) - 1;
    return [col, row];
  }

  // Convert coordinates back to chess square
  coordsToSquare(coords) {
    const col = String.fromCharCode(coords[0] + 'a'.charCodeAt(0));
    const row = coords[1] + 1;
    return `${col}${row}`;
  }

  // BFS to find shortest path
  endPosition(startSquare, targetSquare) {
    const start = this.squareToCoords(startSquare);
    const target = this.squareToCoords(targetSquare);

    // Validate inputs
    if (!this.isValidSquare(start) || !this.isValidSquare(target)) {
      throw new Error('Invalid start or target square');
    }

    // BFS queue: [currentCoords, pathSoFar]
    const queue = [[start, [startSquare]]];
    const visited = new Set();
    visited.add(start.toString());

    while (queue.length > 0) {
      const [current, path] = queue.shift();

      // Check if we've reached the target
      if (current[0] === target[0] && current[1] === target[1]) {
        return path;
      }

      // Explore all possible knight moves
      for (const move of this.knightMoves) {
        const newCol = current[0] + move[0];
        const newRow = current[1] + move[1];
        const newCoords = [newCol, newRow];

        if (this.isValidSquare(newCoords) && !visited.has(newCoords.toString())) {
          visited.add(newCoords.toString());
          const newSquare = this.coordsToSquare(newCoords);
          queue.push([newCoords, [...path, newSquare]]);
        }
      }
    }

    // This line should never be reached (chessboard is fully connected)
    throw new Error('No path found');
  }

  // Check if coordinates are within the 8x8 board
  isValidSquare(coords) {
    const [col, row] = coords;
    return col >= 0 && col < 8 && row >= 0 && row < 8;
  }
}

module.exports = Board;

Add Global Error Handling #

Create a middleware to handle errors consistently across your API:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ success: false, error: 'Internal Server Error' });
});

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