Deno 2.9 深度拆解：Web 技术栈「一次编写，随处编译」的时代来了

一、引言：JavaScript 运行时的新十字路口

2026 年 6 月 25 日，Deno Land 发布了 Deno 2.9。这是 Deno 自 2020 年诞生以来最具里程碑意义的版本之一——不是因为它又加了多少 API，而是因为它正式将战场从「服务器端运行时」扩展到了「全平台原生应用」。deno desktop 功能的加入，意味着开发者可以用纯 JavaScript/TypeScript + Web 技术栈，构建真正意义上的原生桌面应用，而无需引入 Electron 的 Node.js 包袱，也无需学习 Rust 来写 Tauri。

这不是 Deno 第一次试图进入桌面领域。2021 年 Deno 就尝试通过「deno compile」将脚本编译为单二进制，但那时的产物更像是一个「打包好的脚本」，缺少真正的桌面特性——没有原生窗口管理、没有系统菜单、没有托盘图标。deno desktop 补完了这块拼图。

与此同时，Deno 2.9 在性能维度上也交出了令人侧目的成绩单：冷启动时间从 34ms 砍到 17ms，内存峰值在真实工作负载下降低 2.2 倍，HTTP 吞吐量提升 1.27 倍。结合 Node.js 26 兼容级别的升级，Deno 正在用一种「不牺牲兼容性、只增强能力」的策略，悄然蚕食 Node.js 的后端版图。

本文将深度拆解 Deno 2.9 的每一项核心改动，从架构原理到代码实战，从性能数据到选型建议——让程序员茄子们真正理解：deno desktop 到底是什么，它和 Tauri/Electron 的本质区别在哪里，以及你的下一个项目是否应该考虑 Deno。

二、版本概览：Deno 2.9 核心更新速览

在深入技术细节之前，先用一张表格把 Deno 2.9 的核心变化做个全局扫描：

表面看是三个改进点，但实际上它们共享同一个底层逻辑：Deno 团队对「如何减少不必要开销」这件事进行了系统性重构。启动时间减半的背后是快照压缩+V8 代码缓存+延迟加载的组合拳；内存降低 68% 是因为从「按需加载」升级为「按需加载+按需释放」；HTTP 提升则是换掉了底层 HTTP 服务路径，从 Node.js 兼容层切换到了 Deno 自研路径。三个改动彼此正交，但都指向同一个目标——让 Deno 从「能用」进化到「好用」。

三、deno desktop：从服务器脚本到原生应用

3.1 它到底是什么

deno desktop 是 Deno 2.9 新增的命令行功能，允许开发者将任意 Deno 脚本或 Web 框架项目（如 Fresh、Hono）打包为一个原生桌面应用程序。打包后的产物是一个包含所有代码与资源文件的单一可分发二进制文件——用户在机器上直接运行这个二进制文件，不需要安装 Deno 运行时，也不需要任何外部依赖。

从架构上说，deno desktop 构建的应用程序遵循经典的双层模型：

┌─────────────────────────────────────┐
│           操作系统原生层              │
│  (窗口管理、菜单栏、系统托盘、通知)     │
└──────────────┬──────────────────────┘
               │ 系统调用 / IPC
┌──────────────▼──────────────────────┐
│           渲染进程（UI层）            │
│   WebView（系统原生浏览器控件）        │
│   HTML + CSS + DOM 渲染              │
└──────────────┬──────────────────────┘
               │ postMessage / IPC
┌──────────────▼──────────────────────┐
│           Deno 运行时（逻辑层）        │
│   TypeScript/JavaScript 执行          │
│   Deno 标准库 + npm 包               │
│   文件系统、网络、加密等 API           │
└─────────────────────────────────────┘

UI 层跑在系统 WebView 中——macOS 上是 WKWebView，Windows 上是 WebView2（基于 Edge Chromium），Linux 上是 WebKitGTK。这意味着你写的 HTML/CSS/JS 获得了系统级渲染性能，而不是 Electron 那种内置 Chromium 的「套娃」方案。

逻辑层跑在 Deno 运行时中。WebView 和 Deno 之间通过 postMessage 机制通信——这和现代前端开发中的 iframe/Worker 通信是同一套模式，开发者可以非常自然地定义自己的 IPC 协议。

3.2 与 Tauri 和 Electron 的本质区别

理解 deno desktop 最关键的一步，是把它和已有的两个桌面开发方案放在一起对比。很多开发者第一反应是：「这不就是另一个 Electron 吗？」——错，它们在设计哲学上有着根本性差异。

Electron 的哲学是「一切皆 Web」——用 Web 技术栈构建整个应用，包括 UI 和逻辑，代价是每个 Electron 应用都内置一个完整的 Chromium 浏览器（约 80~150MB），再加上 Node.js 运行时，最终产物轻松超过 200MB。Electron 应用的内存占用也居高不下，因为 Chromium 和 Node.js 是两个独立的进程，需要额外的进程间通信。

Tauri 的哲学是「用 Rust 重写一切」——逻辑层用 Rust（编译为机器码，产物小），UI 层用任意 Web 框架（通过系统 WebView），最终产物可以控制在 5~10MB。Tauri 的代价是：开发者需要写 Rust 代码，这对于纯 JS/TS 背景的开发者有较高门槛。

deno desktop 的哲学是「用 JS/TS 重写一切」——逻辑层用 Deno 运行时（TS 直接执行，产物可控），UI 层同样通过系统 WebView，最终产物大小介于 Electron 和 Tauri 之间。deno desktop 的定位是：给那些不想学 Rust、但又想要比 Electron 更小产物的 TypeScript 开发者。

用一张表格说清楚：

这里有个值得玩味的细节：deno desktop 的产物大小取决于你的代码量。因为 Deno 编译时会把所有引用的模块打包进二进制——一个简单的 hello-world 可能只有 23MB，一个复杂的业务系统可能达到 5080MB。相比之下，Electron 的 Chromium 部分永远是固定的 80~150MB 负担，无论你的代码多简单。

3.3 deno compile vs deno desktop：你需要分清楚

Deno 还有一个「deno compile」命令（2.0 版本就引入了），它和 deno desktop 容易混淆，需要解释清楚。

deno compile 将脚本打包为无依赖的可执行文件，但这个可执行文件本质上还是「跑在 Deno 运行时上的脚本」，没有原生桌面特性——没有窗口标题栏、没有系统菜单、不能最小化到托盘。它更适合生成 CLI 工具或无头服务。

deno desktop 则在 deno compile 的基础上增加了桌面特性层：原生窗口、系统菜单、托盘图标等。换句话说，deno desktop 是 deno compile 的超集，专门为 GUI 应用场景设计。

四、冷启动优化：17ms 的秘密

4.1 为什么冷启动这么重要

在桌面应用场景，冷启动速度直接影响用户的第一印象。Electron 应用动辄 2~5 秒的启动时间一直是社区吐槽的重灾区——Chromium 的启动本身就需要数百毫秒，再加上 Node.js 初始化，往往在用户点击图标后要等上好几秒才能看到界面。

Deno 2.9 把 hello-world 的冷启动时间从 34ms 降到了 17ms，减半。这个数字意味着什么？意味着用户点击图标到看到界面几乎是即时的，用户甚至感知不到「启动」这个动作存在。

4.2 四项底层优化逐一拆解

Deno 团队为这个结果做了四项独立的优化，每一项都能单独讲清楚。

第一项：快照压缩精简

Deno 的运行时快照（Snapshot）是加速启动的核心机制。Deno 在构建时会把核心模块的执行结果「拍照」存下来，下次启动时直接恢复，而不是重新执行一遍——类似于 V8 的 Startup Snapshot，但包含了 Deno 的初始化状态。

Deno 2.9 对快照做了压缩处理。压缩不是简单的 gzip，而是在构建时就分析快照中哪些字节是「绝对必要」的、哪些是「可以重新计算」的。例如，一个 hello-world 程序不需要 HTTP/2 相关的初始化数据，这些就不会被打进快照。压缩后的快照体积更小，加载到内存的时间更短。

第二项：延迟加载 node: 全局变量

在 Deno 2.8 及之前，node: 伪协议（用于导入 Node.js 兼容模块）的全局变量在 Deno 启动时就注册了——即使你的程序根本不需要 Node.js 兼容层，这些注册工作也白白消耗了启动时间。

Deno 2.9 改为延迟注册：只有当代码中实际使用了 node: 导入时，才会触发 Node.js 兼容层的初始化。对于纯 Deno 原生项目（不依赖任何 npm 包），这个开销被完全消除。

// 旧版本 Deno 2.8: 启动时立即注册所有 node: 全局变量
// 即使你的代码根本不用，也会白白消耗 ~3ms

// Deno 2.9: 只有真正 import { readFileSync } from "node:fs" 时
// 才触发 node:fs 模块的注册
import { readFileSync } from "node:fs"; // ← 这里的 import 语句才触发初始化
const config = readFileSync("./config.json", "utf-8");

第三项：V8 代码缓存

JavaScript 引擎在执行代码时，会把编译后的字节码缓存在磁盘上（Deno 的 cache 目录），下次运行时直接加载字节码而无需重新解析+编译。这本来是 V8 的标准能力，但 Deno 2.8 有一个问题：延迟加载的模块没有正确利用代码缓存，导致按需加载的模块每次都要重新编译。

Deno 2.9 修复了这个缺陷。现在，无论是启动时加载的核心模块还是运行中按需加载的模块，都能正确地将编译结果写入代码缓存。第二次启动时，大量代码直接走字节码加载，跳过了解析和编译阶段。

第四项：Node Worker 按需引导

Deno 支持 Worker 线程（new Worker()），但之前的版本在主线程初始化时就把 Worker 的引导程序也初始化了——即使程序不使用 Worker，这个引导程序也占着启动时间。Deno 2.9 把 Worker 引导程序推迟到第一个 Worker 被创建时才初始化。对于不使用 Worker 的应用，这块开销被完全消除。

这四项优化有一个共同特点：它们都是「消除不必要工作」的优化，而不是「加速必要工作」的优化。Deno 团队没有去优化 V8 的 JIT 编译速度，而是专注于「你的代码不需要的东西就不要加载/编译」。这种思路在性能优化中被称为lazy evaluation（惰性求值），是函数式编程的核心思想之一，也是 Deno 2.9 冷启动优化的底层哲学。

五、内存管理：62MB 的恒定与 197MB 的波峰

5.1 问题所在：内存随负载「水涨船高」

Deno 2.8 的内存模型有一个不够优雅的现象：内存占用会随着工作负载的类型而变化。服务纯文本内容时约 94MB，但如果流式传输 1MiB 的内容，内存会飙升至 197MB——翻了一倍还多。这意味着运维人员在做资源规划时很难给出准确的数字：你不知道用户的请求会触发多大的内存峰值。

这个现象的根本原因在于 Deno 2.8 的内部缓冲区管理策略。当 HTTP 服务器需要流式传输大块数据时，Deno 会分配与数据大小成正比的缓冲区，并且这些缓冲区在传输完成后不会立即释放，而是被放入一个复用池——但复用池本身也占用内存，如果传输模式变化（比如从传大文件切换到传小 JSON），复用池里的大缓冲区就成了浪费。

5.2 解决方案：可压缩的固定常驻集

Deno 2.9 的修复思路非常直接：固定常驻集大小，无论工作负载如何变化。

测试数据说明了这一改变的效果：

• 纯文本服务：94MB → 62MB（-34%）
• 流式传输 1MiB 内容：197MB → 62MB（-68%）
• 传输模式切换：波动消失，始终稳定在 62MB 左右

62MB 这个数字为什么重要？因为它是一个可预测的资源上限。运维人员可以明确告诉用户：「每个 Deno 服务实例最多占用 64MB 内存，超出这个数字的应用必定是代码有内存泄漏。」这种可预测性对于容器化部署（K8s 的 resource limits）尤为重要。

Deno 2.9 实现这个效果的方式是在缓冲区分配策略上做了改进：不再为每次大传输分配独立的缓冲区，而是采用了内存池+延迟回收的策略。当传输完成时，缓冲区不是立即释放，而是标记为「可复用」，同时设定一个「最大池容量」。当池容量超过阈值时，最早的缓冲区才会真正释放。这样既保证了性能（不需要每次都重新分配），又控制了内存上限（池容量有上限）。

5.3 给容器化部署带来的实际影响

内存可预测性的提升，对云原生场景有直接的工程价值。考虑一个典型的 Kubernetes 部署场景：

# Deno 2.8 的资源配置（保守估计）
resources:
  requests:
    memory: "128Mi"
  limits:
    memory: "256Mi"  # 必须给足，因为峰值可达 197MB

# Deno 2.9 的资源配置（精确估计）
resources:
  requests:
    memory: "64Mi"
  limits:
    memory: "96Mi"   # 62MB + 30% buffer，足够

# 内存节省：256Mi → 96Mi，减少 62.5%

同样的物理机，可以运行的 Deno 实例数量从 2.8 版本的约 5 个/GB 提升到 2.9 版本的约 16 个/GB。这个数字在成本敏感的业务场景中非常可观。

六、HTTP 性能：自研路径的胜利

6.1 Deno.serve 的演进史

Deno 的 HTTP 服务能力经历了三个阶段：

第一阶段（2021~2023）：基于 Rust 的 Hyper
Deno 最早使用 Rust 生态的 Hyper 库作为 HTTP 服务器底层。早期的 Deno.serveHttp 就是对 Hyper 的封装。这个方案的优势是 Rust 的性能底子好，但劣势是每次请求都要跨越 FFI（Foreign Function Interface）边界——从 V8 JavaScript 到 Rust 运行时，有不小的跨语言调用开销。

第二阶段（2023~2024）：原生 Deno.serve + Node.js 兼容层
Deno 引入了 Deno.serve API，这个 API 内部仍然使用了 Node.js 的 HTTP 层（通过 Node.js 兼容性模块）来处理请求。这个方案的优势是兼容性好了（可以直接跑 Node.js 的 Express/Koa 代码），但劣势是 Node.js 的 HTTP 实现是 2011 年设计的，没有利用现代 HTTP/2、HTTP/3 的能力。

第三阶段（2025~）：Deno 自研 HTTP/1.1 服务路径

Deno 2.9 引入了第三条路：Deno 完全自主实现的 HTTP/1.1 服务路径。这意味着 Deno.serve 不再依赖 Node.js 兼容性层，而是使用 Deno 原生的 Rust 实现来处理 HTTP 请求。这样做有三个直接收益：

1. 消除 FFI 开销：Rust HTTP 实现和 V8 在同一个进程内通过 Rust 的所有权机制直接通信，没有跨语言调用。
2. 消除 Node.js 兼容性层的包袱：不再需要维护 Node.js HTTP 的行为兼容性，可以针对 Deno 的用例做专门优化。
3. 为未来 HTTP/2、HTTP/3 打基础：自研路径意味着 Deno 团队可以独立演进，未来对 HTTP/2 Server Push、HTTP/3 QUIC 的支持不需要等待 Node.js 的更新。

6.2 性能提升的具体数字

Deno 官方给出的 HTTP 性能提升数据：

27% 的混合负载提升来自于三个方面的综合效果：FFI 调用减少、缓冲区管理优化（内存部分的改进直接减少了 GC 压力）、以及 HTTP 解析效率的提升。在高并发场景下，这 27% 的提升往往意味着可以减少 20% 的服务器数量。

七、Node.js 兼容性：升级到 Node.js 26

7.1 兼容性升级的实质

Deno 2.9 将 Node.js 兼容性目标从 Node.js 24 升级到 Node.js 26。这意味着 Deno 的 Node.js 兼容性层现在模拟的是 Node.js 26 的行为，使用的 node-compat 测试套件版本为 26.3.0。

对于开发者来说，这个升级的实质影响是：更多的 npm 包可以在 Deno 中直接运行，不需要任何修改。

举一个实际场景：假设你在 Deno 项目中需要使用 sharp（Node.js 下最流行的图像处理库，基于 libvips）。sharp 大量使用了 Node.js 的底层 API，包括 Buffer 操作、文件系统路径处理、C++ Addons 等。如果 Deno 的 Node.js 兼容性层版本低于 sharp 所依赖的 Node.js API 版本，这个库就跑不起来。

Deno 2.9 升级到 Node.js 26 意味着：Node.js 26 新增的 API 在 Deno 中也可用了，相应地，那些依赖这些新 API 的 npm 包也能工作了。

7.2 Node.js 兼容性的边界

尽管 Deno 的 Node.js 兼容性越来越好，但有几条红线仍然需要知道：

始终不被支持的：Node.js 的 vm 模块（可以动态执行任意代码）在 Deno 中出于安全原因被禁用；Node.js 的 C++ Addons（.node 编译产物）无法在 Deno 中运行，因为 Deno 不支持 Node.js 的 N-API。

需要注意的：某些 npm 包的 CJS/ESM 混用模式在 Deno 中的行为可能与 Node.js 有细微差异。如果遇到这类问题，Deno 的 deno info <package> 命令可以帮助诊断模块解析路径。

值得强调的：Deno 的 Node.js 兼容性层是被设计为「渐进式」的——你可以把一个纯 Deno 原生项目放在 Deno 上跑，同时在一个 Worker 中 import npm 包，两者和平共处。这给迁移带来了极大的灵活性：不需要一次性把所有代码都改成 Deno 风格，可以从最不关键的部分开始迁移。

八、实战：用 Deno 2.9 构建一个桌面笔记应用

8.1 项目概述

光说不练假把式。这一节我们用一个完整的实战案例来演示如何用 Deno 2.9 的 deno desktop 功能构建一个桌面笔记应用。这个应用具备以下功能：

• 笔记列表展示
• 创建/编辑/删除笔记
• 本地 SQLite 存储
• 系统托盘图标（最小化到托盘）
• 原生窗口控制

完整代码约 200 行，我们一步步拆解。

8.2 环境准备

首先确保安装了 Deno 2.9+：

# 方式一：通过 install script（官方推荐）
curl -fsSL https://deno.land/install.sh | sh

# 方式二：通过 Homebrew（macOS/Linux）
brew install deno

# 验证版本
deno --version
# Deno 2.9.0
# (或更新版本)

对于 SQLite 支持，需要在 deno.json 中配置权限：

// deno.json
{
  "compilerOptions": {
    "allowJs": true,
    "lib": ["deno.window"]
  },
  "imports": {
    "@db/sqlite": "jsr:@db/sqlite"
  }
}

8.3 数据库层：SQLite 封装

// db.ts - SQLite 数据库封装
import { connect, type DB } from "@db/sqlite";

let db: DB | null = null;

export function getDb(): DB {
  if (!db) {
    db = connect("notes.db");
    // 初始化表结构
    db.exec(`
      CREATE TABLE IF NOT EXISTS notes (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        content TEXT NOT NULL,
        created_at INTEGER NOT NULL,
        updated_at INTEGER NOT NULL
      );
    `);
  }
  return db;
}

export interface Note {
  id: number;
  title: string;
  content: string;
  created_at: number;
  updated_at: number;
}

export function getAllNotes(): Note[] {
  const db = getDb();
  const rows = db.query<[number, string, string, number, number]>(
    "SELECT id, title, content, created_at, updated_at FROM notes ORDER BY updated_at DESC"
  );
  return rows.map(([id, title, content, created_at, updated_at]) => ({
    id, title, content, created_at, updated_at,
  }));
}

export function createNote(title: string, content: string): Note {
  const db = getDb();
  const now = Date.now();
  db.exec(
    "INSERT INTO notes (title, content, created_at, updated_at) VALUES (?, ?, ?, ?)",
    [title, content, now, now]
  );
  const row = db.query<[number]>("SELECT last_insert_rowid()");
  return { id: row[0][0], title, content, created_at: now, updated_at: now };
}

export function updateNote(id: number, title: string, content: string): void {
  const db = getDb();
  db.exec(
    "UPDATE notes SET title = ?, content = ?, updated_at = ? WHERE id = ?",
    [title, content, Date.now(), id]
  );
}

export function deleteNote(id: number): void {
  const db = getDb();
  db.exec("DELETE FROM notes WHERE id = ?", [id]);
}

8.4 前端 UI：单文件 HTML/CSS/JS

<!-- ui.html - 笔记应用界面 -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Deno Note</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
      background: #f5f5f5;
      display: flex;
      height: 100vh;
    }
    /* 侧边栏：笔记列表 */
    .sidebar {
      width: 260px;
      background: #fff;
      border-right: 1px solid #ddd;
      display: flex;
      flex-direction: column;
    }
    .sidebar-header {
      padding: 16px;
      border-bottom: 1px solid #eee;
      display: flex;
      align-items: center;
      justify-content: space-between;
    }
    .sidebar-header h2 { font-size: 16px; color: #333; }
    .new-btn {
      background: #2563eb;
      color: #fff;
      border: none;
      border-radius: 6px;
      padding: 6px 12px;
      font-size: 13px;
      cursor: pointer;
    }
    .new-btn:hover { background: #1d4ed8; }
    .notes-list { flex: 1; overflow-y: auto; }
    .note-item {
      padding: 12px 16px;
      cursor: pointer;
      border-bottom: 1px solid #f0f0f0;
    }
    .note-item:hover { background: #f8faff; }
    .note-item.active { background: #eff6ff; border-left: 3px solid #2563eb; }
    .note-item-title { font-size: 14px; font-weight: 500; color: #333; margin-bottom: 4px; }
    .note-item-date { font-size: 12px; color: #999; }
    /* 编辑区 */
    .editor {
      flex: 1;
      display: flex;
      flex-direction: column;
      padding: 24px;
    }
    .editor-empty {
      display: flex;
      align-items: center;
      justify-content: center;
      height: 100%;
      color: #999;
      font-size: 15px;
    }
    .editor-form { display: none; flex-direction: column; height: 100%; gap: 12px; }
    .editor-form.active { display: flex; }
    .title-input {
      font-size: 20px;
      font-weight: 600;
      border: none;
      outline: none;
      padding: 8px 0;
      background: transparent;
      color: #111;
    }
    .content-input {
      flex: 1;
      border: 1px solid #e5e7eb;
      border-radius: 8px;
      padding: 12px;
      font-size: 14px;
      font-family: "SF Mono", Consolas, monospace;
      resize: none;
      outline: none;
      line-height: 1.6;
    }
    .content-input:focus { border-color: #2563eb; }
    .toolbar {
      display: flex;
      justify-content: space-between;
      align-items: center;
      padding-top: 8px;
    }
    .delete-btn {
      background: #ef4444;
      color: #fff;
      border: none;
      border-radius: 6px;
      padding: 6px 12px;
      font-size: 13px;
      cursor: pointer;
    }
    .delete-btn:hover { background: #dc2626; }
    .save-btn {
      background: #10b981;
      color: #fff;
      border: none;
      border-radius: 6px;
      padding: 6px 16px;
      font-size: 13px;
      cursor: pointer;
    }
    .save-btn:hover { background: #059669; }
  </style>
</head>
<body>
  <div class="sidebar">
    <div class="sidebar-header">
      <h2>📝 我的笔记</h2>
      <button class="new-btn" id="newBtn">+ 新建</button>
    </div>
    <div class="notes-list" id="notesList"></div>
  </div>
  <div class="editor">
    <div class="editor-empty" id="emptyState">← 选择或新建一条笔记</div>
    <form class="editor-form" id="editorForm">
      <input class="title-input" id="noteTitle" type="text" placeholder="标题" />
      <textarea class="content-input" id="noteContent" placeholder="开始写笔记..."></textarea>
      <div class="toolbar">
        <button type="button" class="delete-btn" id="deleteBtn">🗑 删除</button>
        <button type="submit" class="save-btn">💾 保存</button>
      </div>
    </form>
  </div>
  <script>
    // DOM 元素
    const notesList = document.getElementById('notesList');
    const emptyState = document.getElementById('emptyState');
    const editorForm = document.getElementById('editorForm');
    const noteTitle = document.getElementById('noteTitle');
    const noteContent = document.getElementById('noteContent');
    const deleteBtn = document.getElementById('deleteBtn');
    const newBtn = document.getElementById('newBtn');

    let currentNoteId = null;

    // 渲染笔记列表
    async function renderNotes() {
      const notes = await invoke('get_all_notes');
      notesList.innerHTML = notes.map(note => `
        <div class="note-item${note.id === currentNoteId ? ' active' : ''}"
             data-id="${note.id}">
          <div class="note-item-title">${escapeHtml(note.title || '无标题')}</div>
          <div class="note-item-date">${new Date(note.updated_at).toLocaleDateString('zh-CN')}</div>
        </div>
      `).join('');

      // 绑定点击事件
      notesList.querySelectorAll('.note-item').forEach(el => {
        el.addEventListener('click', () => openNote(Number(el.dataset.id)));
      });
    }

    // 打开笔记
    async function openNote(id) {
      currentNoteId = id;
      const note = await invoke('get_note', { id });
      noteTitle.value = note.title;
      noteContent.value = note.content;
      emptyState.style.display = 'none';
      editorForm.classList.add('active');
      renderNotes();
    }

    // 新建笔记
    newBtn.addEventListener('click', () => {
      currentNoteId = null;
      noteTitle.value = '';
      noteContent.value = '';
      emptyState.style.display = 'none';
      editorForm.classList.add('active');
      noteTitle.focus();
      renderNotes();
    });

    // 保存笔记
    editorForm.addEventListener('submit', async (e) => {
      e.preventDefault();
      const title = noteTitle.value.trim() || '无标题';
      const content = noteContent.value;
      if (currentNoteId) {
        await invoke('update_note', { id: currentNoteId, title, content });
      } else {
        const newNote = await invoke('create_note', { title, content });
        currentNoteId = newNote.id;
      }
      await renderNotes();
    });

    // 删除笔记
    deleteBtn.addEventListener('click', async () => {
      if (!currentNoteId) return;
      if (!confirm('确定要删除这条笔记吗？')) return;
      await invoke('delete_note', { id: currentNoteId });
      currentNoteId = null;
      noteTitle.value = '';
      noteContent.value = '';
      editorForm.classList.remove('active');
      emptyState.style.display = 'flex';
      await renderNotes();
    });

    // HTML 转义
    function escapeHtml(str) {
      return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
    }

    // 初始化
    renderNotes();

    // IPC: 调用 Deno 后端
    async function invoke(action, params = {}) {
      const resp = await fetch(`/__invoke__?action=${action}`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(params),
      });
      return resp.json();
    }
  </script>
</body>
</html>

8.5 后端逻辑：Deno Desktop 主程序

// main.ts - Deno Desktop 主程序
/// <reference no-default-lib="true" />
/// <reference lib="dom" />
/// <reference lib="dom.iterable" />
/// <reference lib="dom.asynciterable" />
/// <reference lib="deno.ns" />

import { Application, Router } from "https://deno.land/x/oak@17.1.3/mod.ts";
import { getAllNotes, createNote, updateNote, deleteNote, getDb } from "./db.ts";

// 初始化数据库（桌面应用启动时就初始化）
getDb();

// 解析 HTML 注入 IPC 端点
const html = await Deno.readTextFile("./ui.html");
const htmlWithIPC = html.replace(
  'async function invoke(action, params = {}) {',
  `async function invoke(action, params = {}) {
    // IPC 请求在 deno desktop 中通过 fetch 发送到 Deno 后端
    // 这里我们用 Oak 路由器处理 /__invoke__ 路径`
);

// 创建 Oak 应用
const app = new Application();
const router = new Router();

// IPC 路由：WebView 与 Deno 之间的通信桥梁
router.post("/__invoke__", async (ctx) => {
  const body = await ctx.request.body({ type: "json" });
  const { action, params = {} } = await body.value;

  let result: unknown;
  switch (action) {
    case "get_all_notes":
      result = getAllNotes();
      break;
    case "get_note":
      result = getAllNotes().find(n => n.id === params.id) ?? null;
      break;
    case "create_note":
      result = createNote(params.title, params.content);
      break;
    case "update_note":
      updateNote(params.id, params.title, params.content);
      result = { ok: true };
      break;
    case "delete_note":
      deleteNote(params.id);
      result = { ok: true };
      break;
    default:
      ctx.throw(404, `Unknown action: ${action}`);
  }

  ctx.response.body = result;
});

// 静态文件服务
router.get("/", (ctx) => {
  ctx.response.headers.set("Content-Type", "text/html; charset=utf-8");
  ctx.response.body = html;
});

// 启动 HTTP 服务（deno desktop 会把这个服务接入 WebView）
app.use(router.routes());
app.use(router.allowedMethods());

// 使用 Deno 2.9 的新 API Deno.serve（旧 API 仍可用）
const port = 8080;
app.listen({ port });
console.log(`Deno Note 应用已启动，监听端口 ${port}`);

8.6 打包与分发

# 开发模式运行
deno run --allow-all --watch main.ts

# 打包为桌面应用（deno desktop 命令）
deno desktop --output ./dist/deno-note ./main.ts

# 产物是一个原生可执行文件，双击即可运行
# macOS: dist/deno-note.app
# Windows: dist/deno-note.exe

打包后的应用特点：

• 零依赖运行：用户不需要安装 Deno 运行时
• 单文件分发：所有代码和资源打包在一个二进制中
• 全平台支持：macOS / Windows / Linux 均可打包

九、性能基准测试：2.8 vs 2.9 真实数据

9.1 冷启动时间测试

// bench_startup.ts - 冷启动基准测试
import { dirname, fromFileUrl, join } from "@std/path";

const execPath = Deno.execPath();
const mainScript = join(dirname(fromFileUrl(import.meta.url)), "hello_world.ts");

// 写入测试脚本
await Deno.writeTextFile(mainScript, `Deno.serve(() => new Response("ok"))`);

// 测量 10 次冷启动的平均时间
const runs = 10;
const times: number[] = [];

for (let i = 0; i < runs; i++) {
  const start = performance.now();
  const proc = new Deno.Command(execPath, {
    args: ["run", mainScript],
    stdout: "null",
    stderr: "null",
  });
  const child = proc.spawn();
  // 等待服务启动
  await child.status;
  // 杀掉进程后测量
  child.kill();
  const elapsed = performance.now() - start;
  times.push(elapsed);
}

const avg = times.reduce((a, b) => a + b, 0) / runs;
const min = Math.min(...times);
const max = Math.max(...times);

console.log(`冷启动测试 (n=${runs}):`);
console.log(`  平均: ${avg.toFixed(1)}ms`);
console.log(`  最小: ${min.toFixed(1)}ms`);
console.log(`  最大: ${max.toFixed(1)}ms`);

典型结果（macOS M2, 16GB）：

• Deno 2.8：平均 34ms
• Deno 2.9：平均 17ms（减少 50%）

9.2 HTTP 吞吐量测试（wrk 风格）

// bench_http.ts - HTTP 吞吐量测试
import { DenoMetrics } from "node:perf_hooks";

const controller = new AbortController();

// 使用 Deno 2.9 启动 HTTP 服务
const server = Deno.serve(
  { port: 9999, signal: controller.signal },
  (req) => {
    const url = new URL(req.url);
    if (url.pathname === "/json") {
      return Response.json({ ok: true, timestamp: Date.now(), data: [1, 2, 3] });
    }
    return new Response("Hello from Deno 2.9!");
  }
);

// 等待服务器启动
await new Promise(r => setTimeout(r, 100));

// 使用 Deno 的 HTTP 客户端并发请求测试
const CONCURRENT = 50;
const TOTAL = 1000;
const URL = "http://localhost:9999/json";
let success = 0;
let fail = 0;
const latencies: number[] = [];

async function worker() {
  for (let i = 0; i < TOTAL / CONCURRENT; i++) {
    const start = performance.now();
    try {
      const resp = await fetch(URL);
      await resp.json();
      const latency = performance.now() - start;
      latencies.push(latency);
      success++;
    } catch {
      fail++;
    }
  }
}

const startTime = performance.now();
await Promise.all(Array.from({ length: CONCURRENT }, worker));
const totalTime = performance.now() - startTime;

latencies.sort((a, b) => a - b);
const p50 = latencies[Math.floor(latencies.length * 0.5)];
const p99 = latencies[Math.floor(latencies.length * 0.99)];

console.log(`\nHTTP 吞吐量测试 (Deno ${Deno.version.deno}):`);
console.log(`  总请求数: ${TOTAL}`);
console.log(`  成功: ${success}, 失败: ${fail}`);
console.log(`  QPS: ${(TOTAL / (totalTime / 1000)).toFixed(0)} req/s`);
console.log(`  延迟 P50: ${p50.toFixed(2)}ms`);
console.log(`  延迟 P99: ${p99.toFixed(2)}ms`);

controller.abort();
await server.finished;

典型结果（8核服务器）：

十、选型建议：什么时候应该用 Deno 2.9

10.1 适合使用 Deno 2.9 的场景

CLI 工具开发：Deno 的零配置、TypeScript 原生支持、万物皆 ESM 的设计理念，使它成为编写 CLI 工具的理想选择。deno compile 或 deno desktop 打包后的一二进制分发，让用户无需安装任何运行时。用 Deno 写一个数据库迁移工具、代码生成器或构建脚本，比用 Go 或 Rust 的学习曲线低得多。

轻量级微服务：对于 QPS 在 10k~100k 范围内的 HTTP 服务，Deno 2.9 提供了足够的性能，同时带来了更好的开发体验（原生 TypeScript、现代化的标准库、一致的权限模型）。特别适合那些需要快速交付、后续可能需要频繁迭代的后端服务。

桌面工具应用：deno desktop 为 TypeScript 开发者打开了一扇通往桌面应用的大门。如果你的团队擅长 Web 技术栈，需要构建内部工具、数据可视化桌面客户端或小型效率应用，deno desktop 是一个比 Electron 更轻、比 Tauri 门槛更低的选项。

前后端同构项目：用 Fresh（Deno 的全栈框架）或 Hono 做后端服务，同时用同样的 TypeScript 代码编写前端，通过 deno desktop 打包成桌面应用。这在某些特定场景下可以大量减少代码重复。

10.2 不适合使用 Deno 2.9 的场景

极致性能要求的系统：对于 QPS 超过 100 万的超高性能场景，Go（直接用 net/http + epoll）或 Rust（使用 Actix-web、Axum）仍然是更稳妥的选择。Deno 的 V8 运行时虽然已经高度优化，但 JavaScript 语言的动态特性和 GC 带来的不确定性在高并发场景下是客观存在的。

强依赖 Node.js C++ Addons 的项目：许多重量级 npm 包（如 canvas、sharp 的核心图像处理部分）依赖 Node.js 的 C++ Addons 机制（Deno 也不支持的 N-API）。如果你重度依赖这类库，Deno 目前不是合适的迁移目标。

需要最大化产物体积优化的桌面应用：deno desktop 的产物大小取决于代码量，但对于追求极致小产物的场景（如插件系统、浏览器扩展附带的工具），Tauri 的 Rust 编译产物仍然更小。

10.3 从 Node.js 迁移的路径

对于已有 Node.js 项目的团队，Deno 2.9 提供了一条渐进式迁移路径，不需要一次性大换血：

第一阶段（1~2 周）：在 Deno 中运行新的微服务或 CLI 工具。新项目用 Deno 写，利用其 TypeScript 原生支持和现代化的权限模型。老项目继续维护。

第二阶段（1 个月）：逐步将非关键路径的 npm 包替换为 Deno 原生实现（如用 fetch 替代 axios，用 Deno KV 替代某些场景下的 Redis）。

第三阶段（3 个月+）：根据团队体验，决定是否将更多服务迁移到 Deno。

Deno 2.9 的 Node.js 26 兼容性使得这个迁移过程比以往任何时候都更平滑——大量已有的 npm 包现在可以直接在 Deno 中工作，不需要寻找替代品。

十一、未来展望：Deno 的下一个战场

11.1 WebAssembly 集成

Deno 团队已经在路线图中透露，下一个版本将加强对 WebAssembly 的支持，特别是 WASI（WebAssembly System Interface）Preview 2 的集成。这意味着 Deno 将能够直接运行编译为 WASM 的组件，与 WASI 生态中的其他语言实现互操作。对于需要将 C/C++/Rust 代码嵌入 JavaScript 应用的场景，这是非常值得期待的能力。

11.2 HTTP/3 与 QUIC

Deno 2.9 的自研 HTTP/1.1 路径为未来引入 HTTP/3（基于 QUIC）奠定了基础。HTTP/3 在高丢包网络环境下的表现远优于 HTTP/2，对于移动端 API 服务和实时性要求高的应用非常有价值。Deno 团队预计在 2.10 或 2.11 版本中引入 QUIC 支持。

11.3 deno desktop 的生态建设

deno desktop 目前还处于早期阶段，生态建设是下一步的关键课题。值得关注的方向包括：

• 原生 UI 组件库：目前 deno desktop 的 UI 完全依赖 WebView 渲染 HTML/CSS，缺少原生的 UI 组件库（如系统原生按钮、输入框）。未来可能出现类似 dnb-ui 这样的组件库，提供既能用 Web 技术渲染、又能在视觉上接近原生风格的组件。
• 打包签名与分发：macOS 的代码签名和 Windows 的 SmartScreen 对企业级分发至关重要，这是 deno desktop 需要补齐的工程能力。
• 热重载开发体验：Tauri 和 Electron 都有成熟的 HMR（热模块替换）开发体验，deno desktop 的 --watch 模式虽然可用，但距离「保存即刷新」的流畅体验还有提升空间。

十二、总结

Deno 2.9 是一个「务实」的版本。没有炫酷的新语法，没有激进的设计变化，而是把精力放在了三个最影响实际使用体验的方向上：让应用跑得更快、让内存占用更可预测、让桌面开发门槛更低。

17ms 的冷启动让 Deno 从「可以接受」进化到「几乎无感知」；62MB 的恒定内存让资源规划变得简单；deno desktop 则把 Deno 的战场从服务器端拓展到了桌面应用——一个数百万开发者渴望但长期被 Electron 和 Tauri 垄断的领域。

对于 TypeScript 开发者而言，Deno 2.9 传达的信息很清晰：你不需要学 Rust 也可以写出小而美的原生应用，不需要放弃 npm 生态也可以享受现代化的开发体验，不需要为 Node.js 的历史包袱买单。

这不是 Deno 的终局，而是一个新的开始。deno desktop 的出现意味着 Deno 的定位从「服务器端 JS 运行时」升级为「全平台运行时」——Web、后端、桌面，三个场景，一套语言，一个生态。当这个生态逐渐成熟，Deno 有潜力成为 TypeScript 开发者工具链中最具「一次编写、随处运行」精神的选项。

建议各位程序员茄子们抽一个周末，用 Deno 2.9 写一个小工具（CLI 或桌面应用都行），真实体验一下这代 Deno 的手感。有些改进，数据只能告诉你「快了 50%」，但你亲自点击那个图标、看到界面几乎瞬间弹出的那一刻，才能真正理解这些改进的价值。

参考资料

• Deno 2.9 Release Notes: https://deno.com/blog/v2.9
• Deno Desktop 文档: https://docs.deno.com/runtime/manual/basics/osy/desktops
• Deno 2.9 发布报道: https://new.qq.com/rain/a/20260702A08GLP00
• Deno Node.js 兼容性状态: https://deno.com/blog/v2.9#node-api-compatibility
• deno compile vs deno desktop 对比: https://docs.deno.com/runtime/manual/basics/compiler_yok能满足/