深入探索 Deno：从安装到第一个应用 – wiki基地

作者： /

深入探索 Deno：从安装到第一个应用

导言：Node.js 的演进与 Deno 的诞生

在现代 Web 开发的浪潮中，JavaScript 和 TypeScript 早已超越了浏览器边界，凭借 Node.js 的崛起，成功占据了服务器端编程的半壁江山。Node.js 以其事件驱动、非阻塞 I/O 的特性，以及统一前后端开发语言的优势，极大地提升了开发效率。然而，随着 Node.js 生态的日益庞大和复杂，一些历史包袱和设计缺陷也逐渐显现，例如臭名昭著的 node_modules 文件夹、缺乏内置的 TypeScript 支持、以及默认不安全的权限模型等。

正是在这样的背景下，Node.js 的创始人 Ryan Dahl 于 2018 年，在一次名为 “10 Things I Regret About Node.js” 的演讲中，提出了一个全新的 JavaScript/TypeScript 运行时——Deno。Deno 是 “Node” 的字母倒置，其设计初衷就是为了纠正 Node.js 过去的一些不足，并拥抱现代 Web 标准和安全理念。Deno 从诞生之初就备受瞩目，被视为下一代 JavaScript/TypeScript 运行时的有力竞争者。

本文将带领读者深入探索 Deno，从其核心理念、安装配置，到权限模型、模块系统、内置工具链等关键特性，并最终通过一个实际的 Web 服务器应用案例，展现 Deno 的强大与优雅。无论您是经验丰富的 Node.js 开发者，还是对服务器端 JavaScript/TypeScript 感兴趣的新手，本文都将为您提供一份全面而详尽的 Deno 入门指南。

第一章：Deno 的诞生背景与核心理念

Deno 的设计哲学与 Node.js 截然不同，它更像一个“浏览器在服务器端”的运行时，尽可能地拥抱 Web 标准。Ryan Dahl 对 Node.js 的“十大遗憾”直接催生了 Deno 的核心设计思想：

  1. 安全性优先（Security First）：Node.js 默认可以访问文件系统、网络等一切资源，这在无意中为恶意代码敞开了大门。Deno 则颠覆了这一模式，默认情况下不允许脚本进行任何 I/O 操作（包括文件、网络、环境变量、子进程等），除非通过显式权限标志授予。
  2. 原生支持 TypeScript（TypeScript Native）：TypeScript 在大型项目中已成为事实标准，Node.js 需要通过 Babel 或 ts-node 等工具链来支持。Deno 则内置了 TypeScript 编译器，可以直接运行 TypeScript 文件，无需额外配置。
  3. 拥抱 Web 标准（Embrace Web Standards）：Deno 尽可能地使用 Web 兼容的 API，例如内置了 fetch API（用于网络请求）、WebSockets API、URL、TextEncoder/Decoder 等，使得浏览器端代码更容易在 Deno 中复用，也降低了开发者的学习成本。
  4. 无包管理器，去中心化模块（No node_modules, Decentralized Modules）：Node.js 的 node_modules 目录结构和中心化的 npm 仓库带来了体积庞大、依赖地狱等问题。Deno 采用 URL 导入模块的方式，直接通过 HTTP(S) 或文件路径加载模块，并内置了模块缓存机制。这使得 Deno 更加轻量，也更符合 Web 的去中心化精神。
  5. 单一可执行文件，内置工具链（Single Executable, Built-in Toolchain）：Deno 运行时是一个独立的、包含所有必要工具（如格式化、Linter、测试运行器、文档生成器、打包器、编译器等）的二进制文件。这意味着开发者无需安装额外的工具（如 Prettier、ESLint、Jest、Webpack 等），开箱即用，极大地简化了项目配置和管理。
  6. ES Modules 原生支持（ES Modules Native）：Deno 从一开始就全面支持 ES Modules，这也是 JavaScript 模块化的未来方向，无需像 Node.js 那样纠结 CommonJS 与 ES Modules 的互操作性。

这些核心理念使得 Deno 在设计上更加简洁、安全、高效，旨在提供一个现代化的、开箱即用的开发体验。

第二章：Deno 的安装与环境配置

Deno 的安装非常简单，因为它是一个单一的可执行文件，无需复杂的依赖项。以下是不同操作系统的安装方法：

2.1 通过 Shell 脚本安装（推荐）

这是最通用和推荐的安装方式。

macOS / Linux:

打开终端，运行以下命令：

bash
curl -fsSL https://deno.land/x/install/install.sh | sh

此命令会将 Deno 可执行文件下载到 $HOME/.deno/bin 目录下，并自动将其添加到你的 PATH 环境变量中。安装完成后，你需要重新启动终端或运行 source ~/.bashrc (或 ~/.zshrc, 具体取决于你的 Shell) 来使 PATH 生效。

Windows (PowerShell):

打开 PowerShell，运行以下命令：

powershell
irm https://deno.land/x/install/install.ps1 | iex

同样，Deno 会被安装到 $HOME\.deno\bin 目录下，并尝试添加到 PATH。你可能需要重启 PowerShell 或计算机。

2.2 通过包管理器安装

Deno 也支持通过常见的包管理器安装，这对于习惯使用包管理器的开发者来说更为便捷。

macOS (Homebrew):

bash
brew install deno

Windows (Chocolatey):

bash
choco install deno

Windows (Scoop):

bash
scoop install deno

Linux (Nix):

bash
nix-env -iA nixpkgs.deno

2.3 验证安装

安装完成后，打开一个新的终端或命令提示符，运行以下命令来验证 Deno 是否安装成功并查看其版本：

bash
deno --version

你将看到类似以下输出：

deno 1.x.x (release, x86_64-apple-darwin)
v8 12.x.x
typescript 5.x.x

这表明 Deno 运行时、其内置的 V8 引擎版本和 TypeScript 版本都已准备就绪。

2.4 Deno 的更新

Deno 的更新也非常简单，只需运行：

bash
deno upgrade

这会将 Deno 更新到最新稳定版本。如果想安装特定版本或预发布版本，可以使用 --version 或 --canary 标志。

2.5 集成开发环境（IDE）配置

虽然 Deno 可以独立运行，但在开发过程中，使用一个功能强大的 IDE（如 VS Code）能够极大地提高效率。

Visual Studio Code (VS Code):

VS Code 是 Deno 开发的首选 IDE。你只需要安装官方的 Deno 扩展：

  1. 打开 VS Code。
  2. 进入扩展视图 (Ctrl+Shift+X 或 Cmd+Shift+X)。
  3. 搜索 “Deno”。
  4. 安装由 “Deno Land” 发布的官方扩展。

安装此扩展后，VS Code 将自动检测并使用 Deno 的内置 TypeScript 语言服务，提供类型检查、代码补全、格式化和 Linting 等功能，无需手动配置 tsconfig.json 或其他工具。它还能理解 Deno 的 URL 模块导入方式，并提供相应的提示。

第三章：Deno 基础：Hello World

让我们从最简单的 “Hello World” 开始，感受 Deno 的运行方式。

3.1 创建一个简单的 Deno 程序

创建一个名为 hello.ts 的文件（Deno 原生支持 TypeScript，所以我们用 .ts 扩展名）：

typescript
// hello.ts
console.log("Hello, Deno!");

3.2 运行 Deno 程序

在终端中，导航到 hello.ts 所在的目录，然后运行：

bash
deno run hello.ts

你将看到输出：

Hello, Deno!

这看起来和 Node.js 类似，但接下来我们将探索 Deno 最重要的特性之一：权限模型。

第四章：深入 Deno 核心特性

Deno 的核心特性是其区别于 Node.js 的关键所在。理解这些特性对于高效地使用 Deno 至关重要。

4.1 安全模型：默认受限的运行时

Deno 的安全模型是其最显著的特性。默认情况下，Deno 运行的脚本是沙箱化的，无法访问文件系统、网络、环境变量或执行子进程。这增强了应用的安全性，防止了恶意或意外的代码行为。

当你需要脚本访问这些资源时，必须通过命令行参数明确授予权限。这些权限以 --allow-* 标志的形式提供。

常用权限标志：

  • --allow-read[=<路径>]: 允许文件读取。
    • --allow-read: 允许读取所有文件。
    • --allow-read=/path/to/dir: 仅允许读取指定目录及其子目录。
    • --allow-read=/path/to/file: 仅允许读取指定文件。
  • --allow-write[=<路径>]: 允许文件写入。用法同 --allow-read。
  • --allow-net[=<地址>]: 允许网络访问。
    • --allow-net: 允许访问所有网络地址。
    • --allow-net=google.com: 仅允许访问 google.com。
    • --allow-net=:8000: 仅允许监听 8000 端口。
  • --allow-env: 允许访问环境变量。
  • --allow-run: 允许运行子进程。这是一个高风险权限，应谨慎使用。
  • --allow-ffi: 允许外部函数接口 (Foreign Function Interface) 调用，用于与 C/C++ 库交互。
  • --allow-sys: 允许访问系统信息，例如操作系统类型、CPU 架构等。
  • --unstable: 允许使用 Deno 的不稳定 API。Deno 的一些新功能在成熟之前会被标记为不稳定，需要此标志才能使用。

示例：一个需要网络权限的应用

假设你有一个 Deno 脚本 fetch_data.ts，它需要从外部 API 获取数据：

“`typescript
// fetch_data.ts
const url = “https://api.github.com/users/denoland”;

async function fetchData() {
try {
const response = await fetch(url);
const data = await response.json();
console.log(“GitHub User Data:”, data);
} catch (error) {
console.error(“Error fetching data:”, error.message);
}
}

fetchData();
“`

直接运行 deno run fetch_data.ts 会报错：

error: Uncaught (in promise) PermissionDenied: Network access to "https://api.github.com/users/denoland" was blocked.
Use --allow-net to enable network access.

这是因为 Deno 默认阻止了网络访问。你需要显式授予权限：

bash
deno run --allow-net fetch_data.ts

现在，脚本将能够成功获取并打印数据。

4.2 模块系统：URL 导入与去中心化

Deno 摒弃了 node_modules 和中心化的包注册机制。它直接通过 URL 导入模块，这与浏览器加载脚本的方式一致。

示例：从 URL 导入模块

Deno 提供了标准库（deno.land/std），其中包含了许多常用的工具模块，例如 HTTP 服务器、文件系统操作等。

“`typescript
// example_module_import.ts
import { serve } from “https://deno.land/[email protected]/http/server.ts”; // 导入 serve 函数

async function handler(req: Request) {
const url = new URL(req.url);
if (url.pathname === “/”) {
return new Response(“Hello, Deno! This is the root.”, { status: 200 });
} else if (url.pathname === “/greet”) {
const name = url.searchParams.get(“name”) || “World”;
return new Response(Hello, ${name}!, { status: 200 });
}
return new Response(“Not Found”, { status: 404 });
}

console.log(“Server running on http://localhost:8000/”);
serve(handler, { port: 8000 });
“`

运行此文件需要网络和端口监听权限：

bash
deno run --allow-net example_module_import.ts

首次运行 deno run 时，Deno 会从指定的 URL 下载并缓存模块。后续运行将直接使用缓存的模块，无需再次下载。这与浏览器的工作方式非常相似。

模块缓存：

所有下载的模块都存储在 Deno 的全局缓存目录中（通常是 $HOME/.deno/deps）。你可以使用 deno cache <file_or_url> 命令手动预下载和缓存模块。

导入映射（Import Maps）：

对于复杂的项目，URL 路径可能会变得冗长且难以管理。Deno 支持 Web 标准的 “Import Maps”，允许你为模块路径创建别名或替换。这通常在 deno.json 或 deno.jsonc 配置文件中定义。

json
// deno.json
{
"imports": {
"@std/": "https://deno.land/[email protected]/",
"oak/": "https://deno.land/x/[email protected]/"
}
}

有了这个配置，你的代码可以这样导入：

typescript
// my_app.ts
import { serve } from "@std/http/server.ts"; // 使用别名导入
import { Application, Router } from "oak/"; // 使用别名导入

这样既保持了代码的简洁性，又提供了灵活的模块管理方式。

4.3 内置工具链：开箱即用的开发体验

Deno 最大的亮点之一是其内置了一整套开发工具，这些工具集成在 Deno 可执行文件中，无需额外安装或配置。这极大地简化了项目设置。

  • deno fmt (格式化): 自动格式化 TypeScript 和 JavaScript 代码，遵循 Deno 官方的风格指南。
    bash
    deno fmt # 格式化当前目录所有文件
    deno fmt my_file.ts # 格式化指定文件
  • deno lint (代码检查): 检查代码中的潜在问题和风格错误。
    bash
    deno lint
    deno lint my_file.ts

  • deno test (测试运行器): 运行项目中定义的测试。Deno 内置了测试框架，支持异步测试和断言。
    “`typescript
    // my_test.ts
    import { assertEquals } from “https://deno.land/[email protected]/assert/assert_equals.ts”;

    Deno.test(“addition test”, () => {
    assertEquals(1 + 2, 3);
    });

    Deno.test(“async operation”, async () => {
    const result = await Promise.resolve(“done”);
    assertEquals(result, “done”);
    });
    运行测试：bash
    deno test
    * **`deno doc` (文档生成)**: 为 Deno 模块生成 HTML 或 JSON 格式的文档。bash
    deno doc main.ts # 在终端打印文档
    deno doc –html –output docs/ main.ts # 生成 HTML 文档到 docs 目录
    * **`deno bundle` (打包)**: 将 Deno 模块及其所有依赖打包成一个独立的 JavaScript 文件，可以在浏览器或其他环境中运行。bash
    deno bundle main.ts bundle.js
    * **`deno compile` (编译为独立可执行文件)**: 这是 Deno 的一个杀手级功能。它将 Deno 脚本及其运行时编译成一个完全独立的、跨平台的可执行文件。这个文件不依赖 Deno 运行时环境，可以直接在目标机器上运行。bash
    deno compile –allow-net –output my_app main.ts

    这将生成一个名为 ‘my_app’ (或 ‘my_app.exe’ 在 Windows 上) 的二进制文件

    可以在没有 Deno 环境的机器上直接运行 ‘./my_app’

    这个功能非常适合分发 CLI 工具或独立的后台服务。
    * **`deno task` (任务运行器)**: 类似于 Node.js 的 `npm scripts`，允许你在 `deno.json` 中定义自定义脚本命令。    json
    // deno.json
    {
    “tasks”: {
    “start”: “deno run –allow-net main.ts”,
    “dev”: “deno run –watch –allow-net main.ts”,
    “test”: “deno test”,
    “build”: “deno compile –allow-net –output my_server main.ts”
    }
    }
    运行任务：bash
    deno task start
    deno task dev
    “`

4.4 Web 兼容性 API

Deno 旨在成为一个“Web 浏览器之外的 Web 运行时”，因此它尽可能地兼容 Web 标准 API，这极大地降低了开发者学习曲线，并促进了前后端代码的复用。

  • fetch API: Deno 全局暴露了 fetch 函数，用于进行网络请求，用法与浏览器完全一致。
  • WebSockets API: Deno 内置了 WebSocket 类，用于构建实时通信应用。
  • URL 和 URLSearchParams: 用于解析和构建 URL。
  • TextEncoder 和 TextDecoder: 用于在字符串和字节之间进行转换。
  • Crypto API: 提供加密功能。
  • ReadableStream, WritableStream, TransformStream: Web Streams API，用于处理数据流。

这些内置的 Web API 使得 Deno 的代码具有更好的可移植性和互操作性。

第五章：构建你的第一个 Deno 应用：一个简单的 Web 服务器

现在，我们将综合运用前面学到的知识，构建一个简单的 RESTful API 服务器。这个服务器将提供用户数据的增删改查接口。

我们将使用 Deno 标准库中的 http 模块来搭建服务器，并模拟一些用户数据。

5.1 项目结构

创建一个新的目录 deno_api_server，并在其中创建以下文件：

deno_api_server/
├── deno.jsonc
├── main.ts
└── data.ts

5.2 准备 deno.jsonc (可选，但推荐)

为了更好地管理模块导入和任务，我们先创建 deno.jsonc。

jsonc
// deno.jsonc
{
"imports": {
"@std/http/": "https://deno.land/[email protected]/http/",
"@std/uuid/": "https://deno.land/[email protected]/uuid/"
},
"tasks": {
"start": "deno run --allow-net main.ts",
"dev": "deno run --allow-net --watch main.ts"
},
"lint": {
"rules": {
"exclude": ["no-explicit-any"]
}
},
"fmt": {
"options": {
"lineWidth": 80,
"indentWidth": 2,
"singleQuote": true
}
}
}

  • imports: 定义了 Deno 标准库 http 和 uuid 模块的别名，方便导入。
  • tasks: 定义了 start 和 dev 两个任务，方便运行服务器。
  • lint 和 fmt: 配置了 Linting 和格式化规则。

5.3 模拟数据 (data.ts)

为了简单起见，我们不连接数据库，而是用一个数组来模拟用户数据。

“`typescript
// data.ts
import { v4 } from “@std/uuid/v4.ts”; // 导入 UUID 生成器

export interface User {
id: string;
name: string;
email: string;
}

// 模拟用户数据
export let users: User[] = [
{ id: v4.generate(), name: “Alice”, email: “[email protected]” },
{ id: v4.generate(), name: “Bob”, email: “[email protected]” },
];

/*
* 查找所有用户
/
export function getAllUsers(): User[] {
return users;
}

/*
* 根据 ID 查找用户
/
export function getUserById(id: string): User | undefined {
return users.find((user) => user.id === id);
}

/*
* 添加新用户
/
export function addUser(name: string, email: string): User {
const newUser: User = { id: v4.generate(), name, email };
users.push(newUser);
return newUser;
}

/*
* 更新用户
/
export function updateUser(id: string, updates: Partial): User | undefined {
const userIndex = users.findIndex((user) => user.id === id);
if (userIndex === -1) {
return undefined;
}
users[userIndex] = { …users[userIndex], …updates };
return users[userIndex];
}

/*
* 删除用户
/
export function deleteUser(id: string): boolean {
const initialLength = users.length;
users = users.filter((user) => user.id !== id);
return users.length < initialLength;
}
“`

5.4 主应用逻辑 (main.ts)

这是服务器的核心文件，负责处理路由和请求。

“`typescript
// main.ts
import { serve } from “@std/http/server.ts”; // 从标准库导入 serve 函数
import {
getAllUsers,
getUserById,
addUser,
updateUser,
deleteUser,
User,
} from “./data.ts”;

const PORT = 8000;

console.log(HTTP server running on http://localhost:${PORT}/);

// 请求处理函数
async function handler(req: Request): Promise {
const url = new URL(req.url);
const path = url.pathname;
const method = req.method;

// 设置 CORS 响应头，允许所有来源进行简单请求
const headers = new Headers({
“Content-Type”: “application/json”,
“Access-Control-Allow-Origin”: “*”,
“Access-Control-Allow-Methods”: “GET, POST, PUT, DELETE, OPTIONS”,
“Access-Control-Allow-Headers”: “Content-Type”,
});

// 处理 OPTIONS 预检请求 (CORS)
if (method === “OPTIONS”) {
return new Response(null, { status: 204, headers });
}

// — API 路由 —

// GET /users – 获取所有用户
if (path === “/users” && method === “GET”) {
const allUsers = getAllUsers();
return new Response(JSON.stringify(allUsers), { status: 200, headers });
}

// GET /users/:id – 获取单个用户
if (path.startsWith(“/users/”) && method === “GET”) {
const id = path.split(“/”).pop(); // 获取路径中的 ID
if (id) {
const user = getUserById(id);
if (user) {
return new Response(JSON.stringify(user), { status: 200, headers });
} else {
return new Response(JSON.stringify({ message: “User not found” }), {
status: 404,
headers,
});
}
}
}

// POST /users – 添加新用户
if (path === “/users” && method === “POST”) {
try {
const body: Partial = await req.json();
if (!body.name || !body.email) {
return new Response(JSON.stringify({ message: “Name and email are required” }), {
status: 400,
headers,
});
}
const newUser = addUser(body.name, body.email);
return new Response(JSON.stringify(newUser), { status: 201, headers });
} catch (error) {
return new Response(JSON.stringify({ message: “Invalid JSON body”, error: error.message }), {
status: 400,
headers,
});
}
}

// PUT /users/:id – 更新用户
if (path.startsWith(“/users/”) && method === “PUT”) {
const id = path.split(“/”).pop();
if (id) {
try {
const body: Partial = await req.json();
const updatedUser = updateUser(id, body);
if (updatedUser) {
return new Response(JSON.stringify(updatedUser), { status: 200, headers });
} else {
return new Response(JSON.stringify({ message: “User not found” }), {
status: 404,
headers,
});
}
} catch (error) {
return new Response(JSON.stringify({ message: “Invalid JSON body”, error: error.message }), {
status: 400,
headers,
});
}
}
}

// DELETE /users/:id – 删除用户
if (path.startsWith(“/users/”) && method === “DELETE”) {
const id = path.split(“/”).pop();
if (id) {
const deleted = deleteUser(id);
if (deleted) {
return new Response(null, { status: 204, headers }); // 204 No Content
} else {
return new Response(JSON.stringify({ message: “User not found” }), {
status: 404,
headers,
});
}
}
}

// 未匹配的路由
return new Response(JSON.stringify({ message: “Not Found” }), { status: 404, headers });
}

// 启动服务器
serve(handler, { port: PORT });
“`

代码解释：

  1. 导入 serve 函数: 从 deno.land/std/http/server.ts 导入 Deno 内置的 HTTP 服务器功能。
  2. 导入数据模块: 导入我们模拟的用户数据和操作函数。
  3. handler 函数: 这是核心的请求处理器。它接收一个 Request 对象，并返回一个 Response 对象。
    • URL 对象用于解析请求的 URL，获取路径和查询参数。
    • req.method 获取 HTTP 方法。
    • 我们通过 if 条件语句模拟路由，根据路径和方法来执行不同的逻辑。
    • req.json() 用于解析 POST/PUT 请求的 JSON 请求体。
    • JSON.stringify() 将 JavaScript 对象转换为 JSON 字符串作为响应体。
    • new Response() 创建一个 HTTP 响应，可以设置状态码和响应头（例如 Content-Type: application/json 和 CORS 头）。
    • 特别处理了 CORS 的 OPTIONS 预检请求，这是现代 Web 应用与不同源的 API 交互时必需的。
  4. serve 调用: 最后，serve(handler, { port: PORT }) 启动服务器，监听 PORT 端口，并将所有传入的请求交给 handler 函数处理。

5.5 运行你的应用

打开终端，进入 deno_api_server 目录，然后运行：

bash
deno task start

这将执行 deno.jsonc 中定义的 start 任务，等同于 deno run --allow-net main.ts。注意，我们必须使用 --allow-net 权限，因为我们的服务器需要监听网络端口并处理网络请求。

如果一切顺利，你将在终端看到：

HTTP server running on http://localhost:8000/

5.6 测试你的 API

你可以使用浏览器、Postman、Insomnia 或 curl 命令来测试你的 API：

  1. 获取所有用户 (GET /users):
    在浏览器中访问 http://localhost:8000/users 或在终端运行：
    bash
    curl http://localhost:8000/users
    你应该会看到一个包含两个用户（Alice 和 Bob）的 JSON 数组。

  2. 获取单个用户 (GET /users/:id):
    从上一步的响应中复制一个用户 ID (例如 Alice 的 ID)，然后替换到 URL 中：
    bash
    curl http://localhost:8000/users/<ALICE_ID>

  3. 添加新用户 (POST /users):
    bash
    curl -X POST -H "Content-Type: application/json" -d '{"name": "Charlie", "email": "[email protected]"}' http://localhost:8000/users
    你将收到新创建用户的 JSON 对象，状态码为 201。再次执行 GET /users 将看到 Charlie 已经被添加。

  4. 更新用户 (PUT /users/:id):
    假设 Charlie 的 ID 是 <CHARLIE_ID>：
    bash
    curl -X PUT -H "Content-Type: application/json" -d '{"email": "[email protected]"}' http://localhost:8000/users/<CHARLIE_ID>
    你将收到更新后的 Charlie 用户信息。

  5. 删除用户 (DELETE /users/:id):
    bash
    curl -X DELETE http://localhost:8000/users/<CHARLIE_ID>
    你将收到 204 No Content 响应。再次执行 GET /users，Charlie 应该已不在列表中。

恭喜！你已经成功搭建并运行了你的第一个 Deno Web 服务器。

第六章：Deno 的生态与未来展望

尽管 Deno 相对年轻，但其生态系统正在迅速发展：

  1. Deno 标准库 (deno.land/std): 提供了大量的实用模块，涵盖 HTTP、文件系统、测试、UUID 等，是 Deno 开发的基础。
  2. 第三方模块 (deno.land/x): 这是一个去中心化的模块注册表，开发者可以在这里发布和发现 Deno 模块。许多流行的 Web 框架和工具（如 Oak、Fresh、Ultra 等）都托管在这里。
    • Oak: Deno 上最流行的 Web 框架之一，其 API 设计类似于 Koa.js，提供了强大的中间件支持和路由功能。
    • Fresh: Deno 官方推出的全栈 Web 框架，主打零 JavaScript 客户端发送、基于 Islands 架构，提供开箱即用的服务器端渲染和文件系统路由。
  3. 工具与服务: 围绕 Deno 出现了一些云服务提供商，如 Deno Deploy (现在是 Vercel 的一部分)，它为 Deno 应用提供了极速的全球部署能力，特别适合边缘计算和无服务器函数。
  4. 应用场景: Deno 非常适合构建：
    • RESTful API 和微服务
    • 命令行工具 (CLI)
    • Web 服务器端渲染 (SSR) 应用
    • 自动化脚本
    • 边缘计算和无服务器函数

Deno 并不是要取代 Node.js，而是提供一个现代化的替代方案。Node.js 庞大的生态和成熟度使其在许多场景下依然是不可撼动的选择。但 Deno 凭借其创新的设计理念，在安全、开发体验、以及拥抱 Web 标准方面展现出巨大潜力，特别是在追求极致简洁、高性能和安全性新项目上，Deno 无疑是一个非常吸引人的选择。

随着 WebAssembly (Wasm) 和边缘计算的日益普及，Deno 这种轻量、安全、高性能的运行时将扮演越来越重要的角色。

总结

本文从 Deno 的诞生背景出发，详细阐述了其核心理念：安全优先、TypeScript 原生支持、去中心化模块、拥抱 Web 标准以及内置工具链。我们一步步演示了 Deno 的安装过程，并通过 “Hello World” 初探其运行方式。随后，我们深入探索了 Deno 最具特色的权限模型，理解了如何授予和管理应用对系统资源的访问。模块的 URL 导入方式和强大的内置工具链（如 deno fmt, deno test, deno compile）也得到了详细的介绍。

最后，我们通过构建一个简单的 RESTful API 服务器，将所学知识付诸实践，展示了 Deno 在 Web 开发中的应用能力。通过这个案例，您可以直观地感受到 Deno 在开发体验上的简洁和高效。

Deno 的出现为 JavaScript/TypeScript 生态注入了新的活力，它代表着对现有工具链的深思熟虑和对未来 Web 开发模式的探索。虽然它仍在不断发展完善中，但其独特的优势和日益壮大的社区已经证明了其价值。

希望通过本文，您能对 Deno 有一个全面而深入的理解，并能够开始您的 Deno 探索之旅。未来属于那些敢于尝试和拥抱新技术的开发者，Deno 无疑是其中一颗璀璨的新星。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部