实时通信底层原理深度剖析：短轮询、长轮询与WebSocket的本质差异

行走的陀螺仪2025-12-07 8:23

在前端实时交互场景中，短轮询、长轮询与WebSocket是实现数据实时同步的三大核心方案。三者看似均能满足"实时通信"需求，但其底层依赖的协议机制、连接管理逻辑、数据传输方式存在本质区别------短轮询是HTTP短连接的"暴力复用"，长轮询是HTTP短连接的"优化升级"，WebSocket是脱离HTTP的"原生长连接协议"。本文将从协议底层、核心流程、技术细节三维度深度拆解，揭露三种方案的本质逻辑，结合底层实现案例让原理具象化。

一、底层协议基础：先明确核心依赖的通信基石

要理解三种方案的原理差异，首先需明确其依赖的底层协议本质------HTTP与TCP的关系、HTTP短连接特性，是轮询方案的核心前提；而WebSocket则是独立于HTTP的全新应用层协议，仅借助HTTP完成"握手升级"。

1. 核心协议概念铺垫

  • TCP协议：传输层协议，负责建立可靠的双向字节流连接，核心特性是"三次握手建立连接、四次挥手关闭连接"，连接建立后可持续双向传输数据（长连接特性），但需手动维护连接状态。
  • HTTP协议 ：应用层协议，基于TCP实现，默认采用"短连接"模式------每次请求需先建立TCP连接，请求响应完成后立即关闭TCP连接（HTTP/1.1支持Connection: keep-alive长连接，但仅复用TCP连接减少握手开销，仍为"请求-响应"单向交互），核心局限性是"后端无法主动向前端发送数据"，仅能被动响应前端请求。
  • WebSocket协议：应用层独立协议，同样基于TCP实现，核心特性是"一次握手建立长连接，双向主动传输数据"，突破HTTP"请求-响应"的单向限制，是原生实时通信协议。

2. 三种方案的协议依赖关系

方案 底层传输协议 应用层协议 连接模式 核心限制突破
短轮询 TCP HTTP（短连接） 多次短连接循环 无突破，用"高频请求"模拟实时
长轮询 TCP HTTP（短连接） 延迟短连接循环 无突破，用"延迟响应"优化开销
WebSocket TCP WebSocket（长连接） 单次长连接持续 突破HTTP单向限制，支持双向主动传输

二、短轮询：HTTP短连接的"暴力复用"，用高频请求模拟实时

短轮询是最基础的实时通信方案，本质是利用HTTP短连接的"请求-响应"特性，通过前端高频发起HTTP请求，强制后端即时返回数据，以"高频问询"掩盖HTTP无法主动推送的缺陷，底层逻辑无任何协议优化，仅为业务层的简单循环。

1. 底层核心流程（含TCP/HTTP交互细节）

短轮询的完整流程包含"TCP连接建立→HTTP请求→HTTP响应→TCP连接关闭"的循环，每一次轮询都是独立的TCP+HTTP交互，具体步骤如下：

  1. 前端触发定时任务 ：通过setInterval设定固定间隔（如3s），每次间隔到期后，前端发起新的通信流程；
  2. TCP三次握手建连：前端作为客户端，向服务器发起TCP连接请求（SYN报文），服务器响应确认（SYN+ACK报文），前端再次确认（ACK报文），TCP连接建立（耗时约10-100ms，取决于网络）；
  3. HTTP请求发送 ：TCP连接建立后，前端封装HTTP请求（请求头含Method: GET、Path: /api/data等），通过TCP字节流发送至服务器；
  4. 后端即时处理响应 ：服务器接收HTTP请求后，无需等待数据变更，立即查询目标数据（无论有无新内容），封装HTTP响应（响应头含Status: 200、响应体含数据/空数据），通过TCP返回前端；
  5. TCP四次挥手断连：前端接收HTTP响应后，双方发起TCP关闭请求（四次挥手），释放TCP连接；
  6. 前端更新+等待下一轮：前端解析响应数据更新页面，等待下一个轮询间隔，重复步骤2-5，形成持续问询循环。

2. 底层关键细节

  • 每一次轮询都是独立的TCP连接 ：无连接复用（即使HTTP/1.1开启keep-alive，仅复用TCP连接减少握手开销，仍需每次发起HTTP请求，本质还是"请求-响应"循环）；
  • 空请求占比极高：若数据10分钟更新一次，按3s轮询间隔计算，200次轮询中仅1次为有效数据请求，其余199次均为无意义空请求；
  • 实时性由轮询间隔决定：延迟=轮询间隔，间隔越短实时性越强，但TCP建连/断连、HTTP请求解析的冗余开销越大，性能与实时性无法兼顾。

3. 底层实现案例（Node.js后端+前端，暴露协议交互）

后端（Node.js原生HTTP，无任何优化）
javascript 复制代码 
// 基于原生HTTP模块，接收请求后立即响应（无论有无数据）
const http = require('http');
const server = http.createServer((req, res) => {
  if (req.url === '/api/order/status') {
    // 模拟查询订单状态：随机返回pending/paid（模拟数据更新）
    const orderStatus = Math.random() > 0.5 ? 'pending' : 'paid';
    // 即时响应，无任何挂起逻辑（HTTP短连接本质）
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: orderStatus }));
  }
});
server.listen(3000, () => console.log('HTTP服务器启动，监听3000端口'));
前端（原生JS，暴露TCP/HTTP循环）
javascript 复制代码 
// 3s轮询间隔，每次轮询都是独立TCP+HTTP交互
let pollInterval = 3000;
let orderStatus = 'unknown';

// 单次轮询核心函数（含完整HTTP请求流程）
const singlePoll = () => {
  fetch('http://localhost:3000/api/order/status')
    .then(res => res.json())
    .then(data => {
      orderStatus = data.status;
      console.log(`当前订单状态：${orderStatus}（本次为独立HTTP请求，已关闭TCP连接）`);
    })
    .catch(err => console.log('轮询失败：', err));
};

// 启动轮询：初始执行一次，之后每3s执行一次
singlePoll();
setInterval(singlePoll, pollInterval);
底层交互日志（可通过浏览器F12 Network查看）

每3s会出现一条/api/order/status请求，每条请求的Connection状态为close（TCP连接已关闭），Response Size可能为有效数据（如20B）或空数据（如10B），印证"高频独立短连接"的本质。

三、长轮询：HTTP短连接的"优化升级"，用延迟响应减少冗余

长轮询是短轮询的底层逻辑优化方案，本质是仍基于HTTP短连接，但通过"后端延迟响应"将"高频独立请求"转化为"低频次延迟请求"，大幅减少TCP建连/断连、空请求的冗余开销，核心是利用后端逻辑优化HTTP的"请求-响应"节奏，而非改变HTTP协议本身。

1. 底层核心流程（含TCP/HTTP交互细节）

长轮询的单次请求流程仍为"TCP建连→HTTP请求→HTTP响应→TCP断连"，但关键差异是"后端延迟响应"，整体循环流程如下：

  1. 前端发起请求（无固定间隔） ：前端首次发起HTTP请求，携带上一次最新数据标识（如lastId=10，用于增量查询），同时设置前端超时（如30s，避免客户端长时间等待）；
  2. TCP三次握手建连：与短轮询一致，建立独立TCP连接；
  3. HTTP请求发送 ：前端封装HTTP请求，携带lastId等标识，发送至服务器；
  4. 后端挂起请求（核心优化点） ：服务器接收请求后，查询是否有增量数据（基于lastId判断）：
    • 若有增量数据：立即封装HTTP响应，通过TCP返回前端；
    • 若无增量数据：不立即返回响应，而是通过"线程阻塞"（如Java）、"协程挂起"（如Node.js）保持TCP连接（此时TCP连接处于活跃状态，但无数据传输），同时启动数据监听（如监听数据库变更、消息队列）；
  5. 响应触发条件（二选一） ：
    • 条件1：数据变更触发：后端监听到新数据/状态变更，立即唤醒挂起的请求，封装响应数据返回前端；
    • 条件2：超时触发：若长时间无数据变更（达到后端超时阈值，通常比前端短1-2s，如28s），后端返回空数据/心跳响应（如{"code":204,"msg":"no data"}），避免TCP连接永久占用；
  6. TCP四次挥手断连：前端接收响应后，双方关闭当前TCP连接；
  7. 前端立即重请求：前端解析响应（有数据则更新页面，无数据则忽略），无需等待固定间隔，立即发起下一次HTTP请求，重复步骤2-6，形成"延迟短连接循环"，实现无间断监听。

2. 底层关键细节

  • 仍为HTTP短连接：单次请求完成后TCP连接仍会关闭，区别于WebSocket的持续长连接，核心是"请求间隔极短（响应后立即重发）+ 单次请求时长延长（挂起）"；
  • 后端挂起的本质：不是TCP连接挂起，而是业务逻辑挂起------TCP连接始终处于活跃状态，后端通过阻塞/协程暂停请求处理流程，避免立即返回响应；
  • 需解决的底层问题：
    1. 连接池优化：高并发下大量挂起请求会占用后端线程/协程，需用连接池限制最大挂起数（如Node.js用事件驱动非阻塞挂起，避免线程耗尽）；
    2. 超时协同：前端超时需≥后端超时，避免前端先超时断开连接，后端后续返回响应无接收方；
    3. 增量查询：必须携带lastId等标识，后端仅返回新数据，减少数据传输冗余。

3. 底层实现案例（Node.js后端+Vue3前端，暴露挂起逻辑）

后端（Node.js原生HTTP，用EventEmitter实现非阻塞挂起）
javascript 复制代码 
const http = require('http');
const EventEmitter = require('events');
const dataEmitter = new EventEmitter(); // 数据变更事件发射器（模拟数据监听）

// 模拟数据存储：初始数据
let latestData = { id: 10, content: '初始消息' };

// 模拟数据变更（如5-15s随机更新一次，模拟真实业务场景）
setInterval(() => {
  latestData = { id: latestData.id + 1, content: `新消息${latestData.id + 1}` };
  dataEmitter.emit('dataChange', latestData); // 触发数据变更事件
}, Math.random() * 10000 + 5000);

// 长轮询核心：挂起请求+事件监听
const server = http.createServer((req, res) => {
  if (req.url.startsWith('/api/listen/data')) {
    // 1. 解析前端传递的lastId（增量查询标识）
    const urlParams = new URLSearchParams(req.url.split('?')[1]);
    const clientLastId = parseInt(urlParams.get('lastId') || '0');
    
    // 2. 设置后端超时（28s，比前端30s短2s）
    const timeoutTimer = setTimeout(() => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ code: 204, msg: 'no data' })); // 超时返回空数据
    }, 28000);
    
    // 3. 查询是否有增量数据
    if (latestData.id > clientLastId) {
      clearTimeout(timeoutTimer); // 清除超时，立即响应
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ code: 200, data: latestData }));
    } else {
      // 4. 无增量数据，挂起请求：监听数据变更事件
      const dataChangeHandler = (newData) => {
        clearTimeout(timeoutTimer); // 数据变更，清除超时
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ code: 200, data: newData }));
      };
      
      // 绑定事件监听（请求关闭时移除监听，避免内存泄漏）
      dataEmitter.once('dataChange', dataChangeHandler);
      req.on('close', () => {
        dataEmitter.off('dataChange', dataChangeHandler);
      });
    }
  }
});

server.listen(3000, () => console.log('长轮询服务器启动，监听3000端口'));
前端（Vue3+TS，暴露响应后立即重请求逻辑）
vue 复制代码 
<template>
  <div>最新数据：{{ latestData.content || '无数据' }}</div>
</template>

<script setup lang="ts">
import { ref, onUnmounted } from 'vue';

const latestData = ref({ id: 0, content: '' });
let abortController: AbortController | null = null; // 用于中断请求

// 单次长轮询请求（响应后立即重发）
const singleLongPoll = async () => {
  abortController = new AbortController();
  try {
    // 携带lastId增量查询，前端超时30s
    const res = await fetch(
      `http://localhost:3000/api/listen/data?lastId=${latestData.value.id}`,
      { timeout: 30000, signal: abortController.signal }
    );
    const data = await res.json();
    
    // 有新数据则更新
    if (data.code === 200 && data.data) {
      latestData.value = data.data;
      console.log(`获取新数据：${data.data.content}（当前TCP连接已关闭，立即发起下一次请求）`);
    }
    
    // 响应后立即发起下一次请求，无固定间隔
    singleLongPoll();
  } catch (err) {
    // 异常时延迟3s重试（避免频繁报错）
    if (!(err instanceof Error && err.name === 'AbortError')) {
      setTimeout(singleLongPoll, 3000);
    }
  }
};

// 组件挂载启动长轮询，卸载时中断请求
onUnmounted(() => {
  abortController?.abort();
});
singleLongPoll();
</script>
底层交互日志（浏览器F12 Network查看）
  • 无数据时：请求时长约28s，响应为no data，响应后立即出现新请求；
  • 有数据时：请求时长为数据变更间隔（如8s），响应为有效数据，响应后立即出现新请求；
  • 所有请求的Connection状态仍为close，印证"延迟短连接"本质，空请求占比≤10%（仅超时场景为空请求）。

四、WebSocket：脱离HTTP的原生长连接，实现真正双向实时

WebSocket是HTML5定义的独立应用层协议，本质是基于TCP建立一次持久长连接，突破HTTP"请求-响应"的单向限制，实现前后端双向主动传输数据，其底层不依赖HTTP协议，仅借助HTTP完成"协议升级握手"，是真正为实时通信设计的原生方案。

1. 底层核心流程（含TCP/HTTP握手/双向传输细节）

WebSocket流程分为"握手升级""双向通信""连接关闭"三个阶段，核心是一次TCP长连接贯穿始终，具体步骤如下：

阶段1：HTTP握手升级（建立WebSocket连接的唯一HTTP交互）
  1. 前端发起协议升级请求 ：前端创建WebSocket实例，发起特殊HTTP请求（目的是申请将HTTP协议升级为WebSocket协议），请求头包含核心字段：
    • Upgrade: websocket：声明要升级的协议为WebSocket；
    • Connection: Upgrade：声明本次请求为协议升级请求；
    • Sec-WebSocket-Key: xxxx：前端生成的随机字符串，用于服务器验证；
    • Sec-WebSocket-Version: 13：WebSocket协议版本（固定13为标准版本）；
  2. TCP三次握手建连：与HTTP请求一致，建立TCP连接；
  3. 服务器验证升级请求 ：服务器接收请求后，验证Sec-WebSocket-Key（通过特定算法生成Sec-WebSocket-Accept响应头），确认支持WebSocket协议后，返回HTTP 101响应（Status: 101 Switching Protocols），响应头包含：
    • Upgrade: websocket；
    • Connection: Upgrade；
    • Sec-WebSocket-Accept: yyyy（验证后的字符串，前端会校验）；
  4. WebSocket连接建立 ：前端校验Sec-WebSocket-Accept通过后，TCP连接正式转为WebSocket连接，此后通信完全脱离HTTP协议，仅基于WebSocket协议通过TCP长连接交互。
阶段2：双向实时通信（核心阶段，无TCP连接重建）
  1. 数据帧封装：前后端发送数据时，需将数据封装为WebSocket数据帧（含帧类型、长度、掩码、数据负载）------这是WebSocket与TCP裸连接的核心区别，数据帧可标识数据类型（文本、二进制、心跳、关闭等），支持分片传输大数据；
  2. 前端主动发送数据 ：前端通过ws.send(data)发送数据，数据经帧封装后通过TCP长连接传输至服务器，无需额外建立连接；
  3. 后端主动推送数据 ：服务器无需等待前端请求，可随时将数据封装为数据帧，通过TCP长连接主动推送至前端，前端通过ws.onmessage事件接收数据；
  4. 心跳保活 ：为避免TCP长连接被网关（如Nginx、运营商网关）断开（网关通常会关闭长时间无数据传输的连接），前后端定期发送心跳帧（帧类型为ping/pong），维持连接活跃（如前端每10s发送ping，后端接收后返回pong）。
阶段3：连接关闭（主动/被动关闭）
  1. 发起关闭请求 ：前端/后端通过ws.close()发起关闭请求，发送关闭帧（含关闭状态码、原因）；
  2. TCP四次挥手断连：双方确认关闭请求后，发起TCP四次挥手，释放TCP连接；
  3. 断线重连 ：若为异常关闭（如网络中断），前端需监听ws.onclose事件，触发自动重连逻辑（如5s后重新执行握手升级流程）。

2. 底层关键细节

  • TCP长连接复用：一次握手后TCP连接持续存在，双向通信无需重建连接，无TCP握手/断连冗余开销；
  • 协议独立性：仅握手阶段依赖HTTP，通信阶段完全独立，WebSocket有自己的帧协议、状态管理逻辑；
  • 双向主动传输：突破HTTP"前端请求→后端响应"的单向限制，后端可主动推送数据，实时性无延迟；
  • 核心底层问题 ：
    1. 连接保活：必须实现心跳机制，否则长连接易被网关断开；
    2. 数据可靠性：WebSocket本身不保证消息可靠送达（TCP保证传输可靠，但应用层可能丢失），需业务层实现重传、回执逻辑；
    3. 并发连接管理：后端需维护大量TCP长连接，需用事件驱动架构（如Node.js、Netty）而非线程池，避免资源耗尽；
    4. 网关适配：需配置网关支持WebSocket转发（如Nginx需开启proxy_set_header Upgrade $http_upgrade、proxy_set_header Connection "upgrade"）。

3. 底层实现案例（Node.js WebSocket服务+Vue3前端，暴露帧交互）

后端（Node.js ws库，原生WebSocket协议实现）
javascript 复制代码 
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 3000 }); // 创建WebSocket服务器

// 管理所有连接的客户端
const clients = new Set();

// 监听客户端连接（每有一个客户端握手成功，触发一次）
wss.on('connection', (ws) => {
  console.log('新客户端连接成功（WebSocket长连接已建立）');
  clients.add(ws);
  
  // 1. 后端主动推送初始数据
  ws.send(JSON.stringify({ id: 1, content: '欢迎连接WebSocket服务' }));
  
  // 2. 监听客户端发送的数据（前端主动发送）
  ws.on('message', (data) => {
    const clientMsg = JSON.parse(data.toString());
    console.log(`收到客户端消息：${clientMsg.content}`);
    
    // 模拟广播：将客户端消息推送给所有连接的客户端
    clients.forEach(client => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify({ id: Date.now(), content: `广播：${clientMsg.content}` }));
      }
    });
  });
  
  // 3. 监听心跳ping请求，返回pong响应
  ws.on('ping', () => {
    ws.pong();
  });
  
  // 4. 监听客户端断开连接
  ws.on('close', () => {
    console.log('客户端连接断开');
    clients.delete(ws);
  });
});

console.log('WebSocket服务器启动，监听3000端口');
前端（Vue3+TS，暴露握手+双向通信逻辑）
vue 复制代码 
<template>
  <div>
    <div>消息列表：</div>
    <div v-for="msg in messageList" :key="msg.id">{{ msg.content }}</div>
    <input v-model="inputMsg" placeholder="输入消息发送">
    <button @click="sendMsg">发送</button>
  </div>
</template>

<script setup lang="ts">
import { ref, onUnmounted } from 'vue';

const messageList = ref<{ id: number; content: string }[]>([]);
const inputMsg = ref('');
let ws: WebSocket | null = null;
let heartbeatTimer: NodeJS.Timeout | null = null;

// 初始化WebSocket连接（握手升级）
const initWebSocket = () => {
  // 发起握手请求（ws为非加密，wss为加密，对应HTTPS）
  ws = new WebSocket('ws://localhost:3000');
  
  // 1. 握手成功（WebSocket连接建立）
  ws.onopen = () => {
    console.log('WebSocket握手成功，长连接已建立');
    startHeartbeat(); // 启动心跳保活
  };
  
  // 2. 接收后端主动推送的数据
  ws.onmessage = (event) => {
    const msg = JSON.parse(event.data);
    messageList.value.push(msg);
    console.log(`收到后端推送：${msg.content}（基于同一TCP长连接）`);
  };
  
  // 3. 连接异常/关闭：自动重连
  ws.onclose = (event) => {
    console.log(`连接关闭，${event.wasClean ? '正常关闭' : '异常关闭'}，5s后重连`);
    clearInterval(heartbeatTimer!);
    setTimeout(initWebSocket, 5000);
  };
  
  // 4. 错误处理
  ws.onerror = (err) => {
    console.log('WebSocket错误：', err);
  };
};

// 心跳保活：每10s发送ping帧
const startHeartbeat = () => {
  heartbeatTimer = setInterval(() => {
    if (ws?.readyState === WebSocket.OPEN) {
      ws.ping(); // 发送ping心跳帧
    }
  }, 10000);
};

// 前端主动发送消息
const sendMsg = () => {
  if (!inputMsg.value || ws?.readyState !== WebSocket.OPEN) return;
  ws.send(JSON.stringify({ content: inputMsg.value }));
  inputMsg.value = '';
};

// 组件生命周期管理
onUnmounted(() => {
  ws?.close();
  clearInterval(heartbeatTimer!);
});
initWebSocket();
</script>
底层交互日志（浏览器F12 Network→WS查看）
  • 握手阶段：一条ws://localhost:3000请求，Status为101 Switching Protocols，Type为websocket；
  • 通信阶段：Frames面板可查看双向数据帧，含ping/pong心跳帧、文本数据帧，无新请求生成，仅复用同一连接；
  • 连接状态：始终为Connected（直至主动关闭/异常断开），印证"TCP长连接"本质。

五、三种方案底层原理核心差异总结

1. 本质定位差异

  • 短轮询：HTTP短连接的业务层暴力复用，无协议优化，仅用高频请求模拟实时，是"无奈的简易方案"；
  • 长轮询：HTTP短连接的逻辑层优化，通过后端延迟响应减少冗余，是"HTTP场景下的性价比方案"；
  • WebSocket：独立于HTTP的原生实时协议，基于TCP长连接实现双向通信，是"实时通信的标准方案"。

2. 核心底层维度对比

对比维度 短轮询 长轮询 WebSocket
TCP连接模式 多次独立短连接（每次请求重建） 延迟短连接（响应后立即重建） 单次长连接（持续复用）
应用层协议依赖 完全依赖HTTP 完全依赖HTTP 仅握手依赖HTTP，通信独立
数据交互触发方式 前端主动请求→后端即时响应 前端主动请求→后端延迟响应 前后端双向主动推送
冗余开销来源 TCP握手/断连+大量空请求 TCP握手/断连（少量） 仅心跳帧（极低）
后端核心逻辑 即时响应，无额外处理 请求挂起+数据监听 连接管理+帧解析+广播
实时性底层原因 延迟=轮询间隔，冗余高 延迟=挂起超时，冗余较低 无连接重建+即时推送，无延迟

3. 底层原理决定的适用边界

  • 短轮询：仅适用于"低实时、低并发、无后端资源"场景，底层冗余开销决定其无法支撑高要求场景；
  • 长轮询：适用于"中实时、中高并发、HTTP环境受限"场景，底层基于HTTP的优化特性使其兼容广且开销可控；
  • WebSocket：适用于"高实时、高并发、双向交互"场景，底层原生长连接+双向传输特性，是实时通信的终极选择。

六、总结

三种方案的底层原理差异，本质是"基于HTTP协议的妥协"与"原生实时协议的突破"的区别：短轮询和长轮询均未脱离HTTP"请求-响应"的底层限制，仅通过业务逻辑调整模拟实时；而WebSocket跳出HTTP框架，基于TCP长连接设计原生双向通信机制，从根本上解决了实时通信的底层痛点。

理解底层原理的核心价值，在于明确每种方案的"能力边界"------无需盲目追求技术先进，而是根据业务对实时性的要求、系统协议环境、开发运维资源，选择底层适配的方案；必要时通过"WebSocket为主、长轮询兜底、短轮询终极兼容"的降级策略，兼顾稳定性与体验，让技术底层逻辑真正服务于业务需求。

相关推荐
大猩猩X1 小时前
vue vxe-gantt 甘特图实现产品进度列表，自定义任务条样式和提示信息
前端·javascript·甘特图·vxe-ui·vxe-gantt
一字白首1 小时前
Vue 进阶,生命周期 + 工程化开发
前端·javascript·vue.js
沐风。561 小时前
css函数
前端·css·css3
tangdou3690986551 小时前
AI真好玩系列-WebGL爱心粒子手势互动教程 | Interactive Heart Particles with Hand Gestures
前端·人工智能·webgl
whbi1 小时前
DataX Web 部署方案
前端
keven-wang1 小时前
网路基础-如何将电脑通过wifi接入的网络通过有线网口共享给其他设备？
网络·wifi转有线·电脑wifi 供有线设备上网
BD_Marathon1 小时前
【JavaWeb】CSS_三种引入方式
前端·css
excel1 小时前
# Vue 渲染系统的四个关键阶段：从模板编译到新旧 VDOM Patch 的完整机制解析
前端
cos1 小时前
我的 Claude Code 使用小记 2
前端·ai编程·claude
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践04React CVE-2025-55182漏洞排查与修复指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06UV安装并设置国内源07BongoCat - 跨平台键盘猫动画工具08打造高效订单处理！ZKmall开源商城的统一履约中心架构解析09本地部署阿里最新开源的Z-Image10Linux下V2Ray安装配置指南