HTML如何制作五子棋？胜负判断算法怎么写？

星降

发布时间：2025-08-13 21:23:01

797人浏览过

来源于php中文网

原创

构建五子棋棋盘界面有两种主流方法：基于html div网格和基于canvas元素；推荐新手使用div网格，因其结构清晰、事件处理方便；2. 五子棋胜负判断的核心逻辑是以新落子为中心，沿水平、垂直、主对角线和副对角线四个方向检查是否形成五子连珠，通过方向增量数组遍历并计数连续同色棋子，总和≥5则判定胜利；3. 胜负判断算法的优化关键在于仅检查当前落子位置、设置提前退出机制、合理设计方向数组、避免重复获取棋子颜色，基础算法已足够高效，无需全局扫描棋盘，重点应放在代码可读性与游戏体验上。

HTML如何制作五子棋？胜负判断算法怎么写？

HTML制作五子棋，核心在于利用HTML构建棋盘结构，CSS负责视觉呈现，而JavaScript则承担了游戏逻辑的大部分工作，尤其是胜负判断。要实现一个可玩的五子棋，关键在于JavaScript如何追踪棋子位置、响应玩家操作，并在每次落子后高效地检查是否有玩家达成五子连珠。

解决方案

要制作一个HTML五子棋，我们通常会从三个方面入手：

HTML结构： 创建一个主容器，比如一个

div

，作为棋盘的父元素。棋盘本身可以用

canvas

元素绘制，这在处理复杂图形和动画时效率更高；或者，对于一个标准的五子棋盘，也可以用嵌套的

div

元素来表示每个棋格。例如，一个

div

作为棋盘，内部再用CSS Grid或Flexbox布局生成15x15或19x19的棋格

div

。每个棋格可以设置一个唯一的ID或数据属性，方便JavaScript操作。

CSS样式： 负责棋盘、棋格以及棋子的视觉效果。

为棋盘容器设置背景色、边框，并确定其尺寸。
如果使用
```
div
```
棋格，为每个棋格设置边框，使其看起来像棋盘格线。
定义两种棋子（黑子和白子）的样式，通常是圆形，不同颜色。可以通过在棋格
```
div
```
内动态添加一个
```
span
```
或
```
i
```
元素来表示棋子，并为其应用CSS类。

#chessboard {
    display: grid;
    grid-template-columns: repeat(15, 30px); /* 假设15x15棋盘，每个格子30px */
    grid-template-rows: repeat(15, 30px);
    width: 450px; /* 15 * 30px */
    height: 450px;
    border: 1px solid #333;
    background-color: #f0d9b5; /* 棋盘木色 */
}

.cell {
    width: 30px;
    height: 30px;
    box-sizing: border-box;
    border: 0.5px solid #888; /* 棋格线 */
    display: flex;
    justify-content: center;
    align-items: center;
    cursor: pointer;
}

.piece {
    width: 28px;
    height: 28px;
    border-radius: 50%;
}

.black {
    background-color: black;
}

.white {
    background-color: white;
}

JavaScript逻辑： 这是整个游戏的核心。

游戏状态管理：
- 一个二维数组（例如
```
board[15][15]
```
  ）来表示棋盘的当前状态，每个元素存储0（空）、1（黑子）或2（白子）。
- 一个变量记录当前轮到哪位玩家（例如
```
currentPlayer = 1
```
  ）。
- 一个布尔变量
```
gameOver
```
  标记游戏是否结束。
事件监听：
- 监听棋盘或每个棋格的点击事件。当用户点击时，获取点击的棋格的坐标。
落子逻辑：
- 检查点击的棋格是否为空。
- 如果为空，更新棋盘数组中的对应位置，并更新DOM（在点击的棋格内添加相应颜色的棋子元素）。
- 切换
```
currentPlayer
```
  。
- 最关键的一步：调用胜负判断函数。
胜负判断：
- 在每次落子后，传入新落子的坐标，检查该棋子是否形成了五子连珠。
- 如果判断出胜负，设置
```
gameOver = true
```
  ，并显示胜利信息。
重置游戏：
- 监听重置按钮的点击事件，将棋盘数组清空，移除所有棋子DOM元素，重置
```
currentPlayer
```
  和
```
gameOver
```
  。

如何构建五子棋的棋盘界面？

构建五子棋的棋盘界面，我个人觉得有两种主流且各有优劣的方法：基于HTML

div

网格和基于

canvas

元素。选择哪种方式，往往取决于你对性能、动画需求以及开发复杂度的权衡。

立即学习“前端免费学习笔记（深入）”；

1. 基于HTML

div

网格： 这是最直观也最容易上手的方法。你可以通过CSS Grid或Flexbox来快速构建一个规整的棋盘。

优点：
- 上手简单： HTML结构清晰，CSS布局直观，非常适合初学者。
- 事件处理方便： 每个棋格都是一个独立的DOM元素，直接给它们添加点击事件监听器非常方便，不需要复杂的坐标转换。
- 调试友好： 可以直接在浏览器开发者工具中检查每个棋格的样式和状态。
缺点：
- DOM元素数量多： 对于一个15x15的棋盘，你需要创建225个
```
div
```
  元素作为棋格，再加上棋子，DOM树会比较庞大。虽然现代浏览器处理起来通常没问题，但如果棋盘更大或者有频繁的动画，可能会有轻微的性能开销。
- 绘图限制： 如果想实现更复杂的棋盘纹理、动态效果（比如落子时的涟漪），纯CSS和
```
div
```
  会比较受限。
实现方式： 在HTML中定义一个
```
id="chessboard"
```
的
```
div
```
，然后在JavaScript中根据棋盘大小（例如15x15）循环生成
```
div
```
元素，并为它们添加
```
class="cell"
```
和
```
data-x
```
、
```
data-y
```
属性来记录坐标。CSS负责设置
```
#chessboard
```
为
```
display: grid
```
，并定义
```
grid-template-columns
```
和
```
grid-template-rows
```
来创建网格。棋子则是在点击棋格时，动态地在对应的
```
cell
```
内部插入一个带有
```
black
```
或
```
white
```
类的
```
div
```
。

2. 基于

canvas

元素：

canvas

提供了一个绘图上下文，你可以用JavaScript在上面绘制任何图形，包括棋盘线和棋子。

优点：
- 性能优异： 只有一个
```
canvas
```
  元素，所有图形都是直接绘制在像素层面，DOM元素数量极少，对于复杂的绘图和动画表现更好。
- 绘图自由度高： 可以轻松实现自定义的棋盘纹理、棋子样式、动画效果（如落子动画、胜利特效等）。
缺点：
- 开发复杂度高： 所有图形都需要通过JavaScript代码绘制，包括线条、圆形、文字等。你不能直接通过CSS来样式化棋子。
- 事件处理复杂：
```
canvas
```
  本身只有一个点击事件。你需要根据点击的像素坐标，手动计算出点击了棋盘的哪个逻辑位置（哪个棋格），这需要一些数学计算。
- 调试相对困难： 你不能直接在开发者工具中检查
```
canvas
```
  内部的“元素”，只能通过
```
console.log
```
  来追踪绘图状态。
实现方式： 在HTML中放置一个
。JavaScript中获取
```
canvas
```
的2D上下文，然后编写函数来绘制棋盘的网格线、棋子。当用户点击
```
canvas
```
时，获取点击的
```
offsetX
```
和
```
offsetY
```
，然后通过简单的除法和取整操作，将其转换为棋盘的逻辑坐标（例如
```
(x, y)
```
）。

对于一个标准的五子棋，我个人倾向于推荐新手从

div

网格开始，因为它能让你更快地看到效果并理解基本的交互逻辑。当你对JavaScript和DOM操作有了一定掌握后，再尝试

canvas

，它能为你的游戏带来更丰富的视觉体验。

五子棋胜负判断的核心逻辑是什么？

五子棋胜负判断的核心逻辑，说白了就是在每次有新棋子落下后，以这个新棋子为中心，向水平、垂直以及两条对角线方向延伸，检查是否有连续五个相同颜色的棋子。 如果找到了，那么当前落子方就赢了。这个过程必须高效，因为每次落子都要执行。

具体来说，这个算法的步骤通常是这样的：

代悟

开发者专属的AI搜索引擎

下载

确定检查点： 当一个棋子落在
```
(x, y)
```
位置后，我们只需要从这个点出发进行检查，因为只有新落下的棋子才可能形成新的五子连珠。之前的棋子已经检查过了，不会因为新棋子的出现而突然形成连珠（除非是活三、活四等高级规则，但基础胜负判断不考虑）。
定义检查方向： 五子棋有四种可能的连线方向：
- 水平方向：
```
(x, y)
```
  向左和向右。
- 垂直方向：
```
(x, y)
```
  向上和向下。
- 主对角线方向（从左上到右下）：
```
(x, y)
```
  向左上和向右下。
- 副对角线方向（从右上到左下）：
```
(x, y)
```
  向右上和向左下。
我们可以用一个数组来表示这些方向的增量：
```
directions = [[0, 1], [1, 0], [1, 1], [1, -1]]
```
- ```
[0, 1]
```
  代表水平方向（只向右，但结合反方向检查就是水平线）
- ```
[1, 0]
```
  代表垂直方向（只向下，但结合反方向检查就是垂直线）
- ```
[1, 1]
```
  代表主对角线（只向右下）
- ```
[1, -1]
```
  代表副对角线（只向左下）

遍历每个方向并计数： 对于每个方向（例如

[dx, dy]

），我们需要分别向“正”方向和“负”方向进行延伸计数，然后把这两个方向的计数加起来（别忘了把中心棋子算进去）。

核心循环逻辑（以水平方向为例）： 假设当前落子颜色为
```
currentPlayer
```
。 a. 向一个方向（比如向右）延伸： 从
```
(x, y)
```
开始，依次检查
```
(x, y+1)
```
、
```
(x, y+2)
```
... 直到遇到不同颜色的棋子、空位或者棋盘边界。每遇到一个相同颜色的棋子，计数器加1。 b. 向相反方向（比如向左）延伸： 从
```
(x, y)
```
开始，依次检查
```
(x, y-1)
```
、
```
(x, y-2)
```
... 直到遇到不同颜色的棋子、空位或者棋盘边界。每遇到一个相同颜色的棋子，计数器加1。 c. 总和判断： 将向右计数和向左计数相加，再减去1（因为
```
(x, y)
```
棋子被算了两次）。如果这个总和大于等于5，那么就判断为胜利。

伪代码示例：

function checkWin(board, x, y, playerColor) {
    // board: 二维数组表示棋盘状态
    // x, y: 新落子的坐标
    // playerColor: 当前落子的颜色 (1或2)

    const directions = [
        [0, 1],  // 水平
        [1, 0],  // 垂直
        [1, 1],  // 主对角线 (右下)
        [1, -1]  // 副对角线 (左下)
    ];

    for (const [dx, dy] of directions) {
        let count = 1; // 包含当前落子本身

        // 向一个方向延伸
        for (let i = 1; i < 5; i++) { // 最多检查4个额外的棋子
            const nx = x + i * dx;
            const ny = y + i * dy;
            if (nx >= 0 && nx < boardSize && ny >= 0 && ny < boardSize && board[nx][ny] === playerColor) {
                count++;
            } else {
                break;
            }
        }

        // 向相反方向延伸
        for (let i = 1; i < 5; i++) {
            const nx = x - i * dx;
            const ny = y - i * dy;
            if (nx >= 0 && nx < boardSize && ny >= 0 && ny < boardSize && board[nx][ny] === playerColor) {
                count++;
            } else {
                break;
            }
        }

        if (count >= 5) {
            return true; // 找到了五子连珠
        }
    }
    return false; // 没有找到
}

这里

boardSize

是棋盘的边长（例如15）。这个循环结构能有效地在每个方向上检查连续的棋子。

边界条件： 在延伸检查时，务必确保新的坐标
```
nx
```
和
```
ny
```
没有超出棋盘的边界（例如
```
0 <= nx < boardSize
```
和
```
0 <= ny < boardSize
```
）。

这个逻辑简洁而高效，因为它只关注新落子点周围的有限区域，避免了不必要的全局扫描。

如何优化五子棋的胜负判断算法？

对于一个标准的五子棋（15x15或19x19），前面提到的那种以新落子为中心的检查算法，其实已经足够高效了。它避免了遍历整个棋盘，每次只检查与新棋子相关的四个方向。在这种规模下，进一步的“优化”往往更多是关于代码的清晰度、健壮性以及一些微小的性能提升，而不是算法上的颠覆性改进。

但如果非要谈优化，或者说让它更“精炼”，我们可以从几个角度来看：

明确的“只检查当前落子”： 这是最基本的优化，但值得强调。算法设计时就应确保，每次判断只针对当前落子的位置，而不是每次都扫描整个棋盘。例如，如果你有一个
```
board
```
数组，当
```
board[x][y]
```
被放置后，你的
```
checkWin(x, y)
```
函数应该只以此
```
x, y
```
为起点。很多初学者可能会犯的错误是，在每次落子后，重新遍历整个`board寻找是否有五子连珠，这无疑是巨大的性能浪费。我们目前的方案已经避免了这一点。
提前退出机制： 在
```
checkWin
```
函数中，一旦在一个方向上找到了五子连珠（
```
count >= 5
```
），就可以立即返回
```
true
```
，无需继续检查其他方向。这在上面的伪代码中已经体现了。这是一个简单但有效的优化，因为它避免了不必要的计算。
方向数组的巧妙设计： 我们前面使用的
```
directions = [[0, 1], [1, 0], [1, 1], [1, -1]]
```
，每个元素代表一个“半方向”。在内部循环中，我们分别向正向和反向延伸。这种方式是清晰且易于理解的。另一种稍微不同的写法是，将一个方向的两个端点合并起来考虑，例如水平方向的
```
[0, -1]
```
和
```
[0, 1]
```
，然后从当前点开始，沿着这个完整的方向线（从左到右或从上到下）去数。但实际上，从性能角度看，差异不大。
避免重复计算棋子颜色： 在
```
checkWin
```
函数中，
```
playerColor
```
参数传入当前落子的颜色，这样在内部循环中，可以直接比较
```
board[nx][ny] === playerColor
```
，而不需要每次都从棋盘数组中重新获取。这虽然是微乎其微的优化，但体现了良好的编程习惯。
针对特定规则的优化（高级，非基础胜负判断）： 如果你的五子棋涉及到禁手（如三三、四四、长连禁手），那么胜负判断会变得复杂得多。这时，你可能需要一个更复杂的棋型判断系统，例如：
- 活三、眠三、活四、眠四的判断： 这不再是简单的五子连珠，而是需要判断棋子周围的空位，以及是否能延伸出更多连子。
- 禁手判断： 在落子前或落子后，需要额外检查该落子是否形成了禁手棋型。这通常涉及对所有可能的五子连线进行更细致的分析，判断其两端是否被堵住，或者是否形成了双三、双四等。这些“优化”其实是算法复杂度的提升，以适应更复杂的规则，而非单纯的性能优化。对于纯粹的“五子连珠”判断，基础算法已经非常高效。