Deno
Deno 是一个简单、现代且安全的 JavaScript 和 TypeScript 运行时环境，由 Node.js 的创始人 Ryan Dahl 开发，目标是解决 Node.js 的一些设计缺陷。Deno 于2020年正式发布，它内置了 V8 JavaScript 引擎和 Tokio 事件循环，提供了一系列默认的安全限制，并支持 TypeScript 的运行而无需额外的转译步骤。
Deno 的性能优化有哪些技巧？Deno 的性能优化对于构建高性能应用程序至关重要。了解 Deno 的性能特性和优化技巧可以帮助开发者充分发挥其潜力。
## 性能特性概述
Deno 基于 Rust 和 V8 引擎构建，具有良好的性能基础。通过合理的优化策略，可以进一步提升应用程序的性能。
## 启动性能优化
### 1. 减少依赖加载
```typescript
// 不好的做法：在顶层加载所有依赖
import { heavyModule1 } from "./heavy-module-1.ts";
import { heavyModule2 } from "./heavy-module-2.ts";
import { heavyModule3 } from "./heavy-module-3.ts";
// 好的做法：按需加载
async function processWithHeavyModule1() {
const { heavyModule1 } = await import("./heavy-module-1.ts");
return heavyModule1.process();
}
```
### 2. 使用缓存
```typescript
// 缓存编译结果
const cache = new Map<string, any>();
async function getCachedData(key: string, fetcher: () => Promise<any>) {
if (cache.has(key)) {
return cache.get(key);
}
const data = await fetcher();
cache.set(key, data);
return data;
}
```
### 3. 预热缓存
```typescript
// 应用启动时预热缓存
async function warmupCache() {
await Promise.all([
getCachedData("config", loadConfig),
getCachedData("translations", loadTranslations),
]);
}
warmupCache().then(() => {
console.log("Cache warmed up, ready to serve");
});
```
## 运行时性能优化
### 1. 使用高效的数据结构
```typescript
// 使用 Map 而不是 Object 进行频繁查找
const userMap = new Map<string, User>();
// 快速查找
function getUser(id: string): User | undefined {
return userMap.get(id);
}
// 使用 Set 进行快速存在性检查
const activeUsers = new Set<string>();
function isActiveUser(id: string): boolean {
return activeUsers.has(id);
}
```
### 2. 避免不必要的计算
```typescript
// 使用记忆化（Memoization）
function memoize<T extends (...args: any[]) => any>(fn: T): T {
const cache = new Map<string, ReturnType<T>>();
return ((...args: Parameters<T>) => {
const key = JSON.stringify(args);
if (cache.has(key)) {
return cache.get(key);
}
const result = fn(...args);
cache.set(key, result);
return result;
}) as T;
}
// 使用记忆化的函数
const expensiveCalculation = memoize((n: number): number => {
console.log(`Calculating for ${n}`);
let result = 0;
for (let i = 0; i < n * 1000000; i++) {
result += i;
}
return result;
});
// 第一次调用会计算
console.log(expensiveCalculation(100));
// 第二次调用使用缓存
console.log(expensiveCalculation(100));
```
### 3. 批量处理
```typescript
// 批量数据库操作
async function batchInsert(items: Item[]): Promise<void> {
const batchSize = 100;
for (let i = 0; i < items.length; i += batchSize) {
const batch = items.slice(i, i + batchSize);
await insertBatch(batch);
}
}
// 批量 API 请求
async function batchFetch(urls: string[]): Promise<Response[]> {
const batchSize = 10;
const results: Response[] = [];
for (let i = 0; i < urls.length; i += batchSize) {
const batch = urls.slice(i, i + batchSize);
const batchResults = await Promise.all(
batch.map(url => fetch(url))
);
results.push(...batchResults);
}
return results;
}
```
## 内存优化
### 1. 避免内存泄漏
```typescript
// 及时清理资源
class ResourceManager {
private resources: Set<Disposable> = new Set();
register(resource: Disposable) {
this.resources.add(resource);
}
cleanup() {
for (const resource of this.resources) {
resource.dispose();
}
this.resources.clear();
}
}
// 使用 WeakMap 避免强引用
const weakCache = new WeakMap<object, any>();
function cacheData(obj: object, data: any) {
weakCache.set(obj, data);
}
```
### 2. 流式处理大文件
```typescript
// 使用流处理大文件，避免一次性加载到内存
import { readableStreamFromIterable } from "https://deno.land/std@0.208.0/streams/mod.ts";
async function processLargeFile(filePath: string) {
const file = await Deno.open(filePath);
const reader = file.readable.getReader();
const buffer = new Uint8Array(1024 * 1024); // 1MB buffer
while (true) {
const { done, value } = await reader.read(buffer);
if (done) break;
// 处理数据块
processDataChunk(value);
}
file.close();
}
```
### 3. 对象池模式
```typescript
// 对象池重用对象，减少 GC 压力
class ObjectPool<T> {
private pool: T[] = [];
private factory: () => T;
private reset: (obj: T) => void;
constructor(
factory: () => T,
reset: (obj: T) => void,
initialSize: number = 10
) {
this.factory = factory;
this.reset = reset;
for (let i = 0; i < initialSize; i++) {
this.pool.push(factory());
}
}
acquire(): T {
return this.pool.pop() || this.factory();
}
release(obj: T) {
this.reset(obj);
this.pool.push(obj);
}
}
// 使用对象池
const bufferPool = new ObjectPool(
() => new Uint8Array(1024 * 1024),
(buffer) => buffer.fill(0),
5
);
async function processData() {
const buffer = bufferPool.acquire();
try {
// 使用 buffer 处理数据
await processWithBuffer(buffer);
} finally {
bufferPool.release(buffer);
}
}
```
## 并发性能优化
### 1. 使用 Worker 并行处理
```typescript
// 使用 Worker 进行 CPU 密集型任务
import { WorkerPool } from "./worker-pool.ts";
const pool = new WorkerPool("./data-processor.ts", 4);
async function parallelProcess(data: any[]) {
const promises = data.map(item => pool.execute(item));
return Promise.all(promises);
}
```
### 2. 控制并发数量
```typescript
// 控制并发请求数量
class ConcurrencyController {
private running: Set<Promise<any>> = new Set();
private maxConcurrent: number;
constructor(maxConcurrent: number) {
this.maxConcurrent = maxConcurrent;
}
async execute<T>(task: () => Promise<T>): Promise<T> {
while (this.running.size >= this.maxConcurrent) {
await Promise.race(this.running);
}
const promise = task().finally(() => {
this.running.delete(promise);
});
this.running.add(promise);
return promise;
}
}
const controller = new ConcurrencyController(10);
async function fetchWithConcurrency(urls: string[]) {
return Promise.all(
urls.map(url => controller.execute(() => fetch(url)))
);
}
```
### 3. 使用异步迭代器
```typescript
// 使用异步迭代器处理流式数据
async function* processStream(stream: ReadableStream<Uint8Array>) {
const reader = stream.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) break;
yield processChunk(value);
}
}
// 使用异步迭代器
for await (const result of processStream(dataStream)) {
console.log(result);
}
```
## I/O 性能优化
### 1. 使用异步 I/O
```typescript
// 始终使用异步 I/O 操作
async function readConfig(): Promise<Config> {
const content = await Deno.readTextFile("config.json");
return JSON.parse(content);
}
// 批量文件操作
async function batchReadFiles(filePaths: string[]): Promise<Map<string, string>> {
const results = new Map<string, string>();
await Promise.all(
filePaths.map(async (path) => {
const content = await Deno.readTextFile(path);
results.set(path, content);
})
);
return results;
}
```
### 2. 使用缓存策略
```typescript
// LRU 缓存实现
class LRUCache<K, V> {
private cache: Map<K, V>;
private maxSize: number;
constructor(maxSize: number) {
this.cache = new Map();
this.maxSize = maxSize;
}
get(key: K): V | undefined {
const value = this.cache.get(key);
if (value !== undefined) {
// 重新插入以更新访问顺序
this.cache.delete(key);
this.cache.set(key, value);
}
return value;
}
set(key: K, value: V): void {
if (this.cache.has(key)) {
this.cache.delete(key);
} else if (this.cache.size >= this.maxSize) {
// 删除最旧的项
const firstKey = this.cache.keys().next().value;
this.cache.delete(firstKey);
}
this.cache.set(key, value);
}
}
// 使用 LRU 缓存
const configCache = new LRUCache<string, Config>(100);
async function getConfigWithCache(key: string): Promise<Config> {
const cached = configCache.get(key);
if (cached) {
return cached;
}
const config = await loadConfig(key);
configCache.set(key, config);
return config;
}
```
### 3. HTTP 性能优化
```typescript
// 使用连接池
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
const handler = async (req: Request): Promise<Response> => {
// 启用压缩
const acceptEncoding = req.headers.get("accept-encoding");
let body = await getResponseBody();
if (acceptEncoding?.includes("gzip")) {
body = await compressGzip(body);
return new Response(body, {
headers: {
"Content-Encoding": "gzip",
"Content-Type": "application/json",
},
});
}
return new Response(body, {
headers: { "Content-Type": "application/json" },
});
};
// 使用 HTTP/2
await serve(handler, {
port: 8000,
alpnProtocols: ["h2"],
});
```
## 监控和调试
### 1. 性能监控
```typescript
// 性能监控工具
class PerformanceMonitor {
private metrics: Map<string, number[]> = new Map();
record(operation: string, duration: number) {
if (!this.metrics.has(operation)) {
this.metrics.set(operation, []);
}
this.metrics.get(operation)!.push(duration);
}
getStats(operation: string) {
const durations = this.metrics.get(operation);
if (!durations || durations.length === 0) {
return null;
}
const sorted = [...durations].sort((a, b) => a - b);
return {
count: durations.length,
min: sorted[0],
max: sorted[sorted.length - 1],
avg: durations.reduce((a, b) => a + b, 0) / durations.length,
p50: sorted[Math.floor(sorted.length * 0.5)],
p95: sorted[Math.floor(sorted.length * 0.95)],
p99: sorted[Math.floor(sorted.length * 0.99)],
};
}
}
// 使用性能监控
const monitor = new PerformanceMonitor();
async function measurePerformance<T>(
operation: string,
fn: () => Promise<T>
): Promise<T> {
const start = performance.now();
try {
return await fn();
} finally {
const duration = performance.now() - start;
monitor.record(operation, duration);
}
}
// 使用示例
await measurePerformance("database-query", async () => {
return await db.query("SELECT * FROM users");
});
```
### 2. 内存分析
```typescript
// 内存使用监控
function getMemoryUsage() {
return {
rss: Deno.memoryUsage().rss / 1024 / 1024, // MB
heapTotal: Deno.memoryUsage().heapTotal / 1024 / 1024,
heapUsed: Deno.memoryUsage().heapUsed / 1024 / 1024,
external: Deno.memoryUsage().external / 1024 / 1024,
};
}
// 定期报告内存使用
setInterval(() => {
const usage = getMemoryUsage();
console.log("Memory usage:", usage);
}, 60000); // 每分钟
```
## 最佳实践
1. **测量优先**：在优化前先测量性能瓶颈
2. **渐进优化**：一次优化一个方面，避免过度优化
3. **使用缓存**：合理使用缓存减少重复计算
4. **异步优先**：始终使用异步 I/O 操作
5. **批量处理**：批量操作减少开销
6. **资源管理**：及时释放不再使用的资源
7. **监控持续**：持续监控性能指标
Deno 提供了良好的性能基础，通过合理的优化策略，可以构建高性能的应用程序。记住，过早优化是万恶之源，始终基于实际测量进行优化。
服务端 · 2月19日 19:55
Deno 和 Node.js 有哪些主要区别？Deno 和 Node.js 是两个流行的 JavaScript/TypeScript 运行时环境，它们各有特点和适用场景。了解它们的区别有助于开发者选择合适的工具。
## 历史背景
### Node.js
- 创建者：Ryan Dahl
- 发布时间：2009年
- 目标：让 JavaScript 能够在服务器端运行
- 架构：C++ + V8 JavaScript 引擎
### Deno
- 创建者：Ryan Dahl（Node.js 的创始人）
- 发布时间：2020年
- 目标：解决 Node.js 的设计缺陷，提供更现代的解决方案
- 架构：Rust + V8 JavaScript 引擎 + Tokio 事件循环
## 核心区别
### 1. 模块系统
#### Node.js
```javascript
// CommonJS
const fs = require('fs');
const express = require('express');
// ES Modules
import fs from 'fs';
import express from 'express';
```
#### Deno
```typescript
// 仅支持 ES Modules，使用 URL 导入
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
import { Application } from "https://deno.land/x/oak@v12.6.1/mod.ts";
```
**区别**：
- Node.js 支持 CommonJS 和 ES Modules
- Deno 仅支持 ES Modules
- Deno 使用 URL 直接导入模块，无需 package.json
### 2. 包管理
#### Node.js
```json
// package.json
{
"dependencies": {
"express": "^4.18.2",
"lodash": "^4.17.21"
}
}
```
```bash
npm install
npm install express --save
```
#### Deno
```typescript
// 直接从 URL 导入
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
```
```bash
# 无需安装，直接运行
deno run app.ts
# 缓存依赖
deno cache app.ts
```
**区别**：
- Node.js 使用 npm/yarn/pnpm 和 package.json
- Deno 无需包管理器，直接从 URL 导入
- Deno 自动缓存下载的模块
### 3. 安全性
#### Node.js
```bash
# 默认无安全限制
node app.js
```
```javascript
// 可以自由访问文件系统、网络等
const fs = require('fs');
fs.readFileSync('/etc/passwd'); // 无限制
```
#### Deno
```bash
# 默认安全，需要显式授权
deno run app.ts # 无任何权限
deno run --allow-read app.ts # 允许读取
deno run --allow-net app.ts # 允许网络访问
deno run --allow-all app.ts # 允许所有权限（不推荐）
```
```typescript
// 需要权限才能访问
const content = await Deno.readTextFile("/etc/passwd"); // 需要 --allow-read
```
**区别**：
- Node.js 默认无安全限制
- Deno 默认安全，需要显式授权
- Deno 提供细粒度的权限控制
### 4. TypeScript 支持
#### Node.js
```bash
# 需要安装 TypeScript
npm install -D typescript @types/node
# 需要配置 tsconfig.json
tsc app.ts
node app.js
```
```json
// tsconfig.json
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"strict": true
}
}
```
#### Deno
```bash
# 原生支持，无需配置
deno run app.ts
```
```typescript
// 直接运行 TypeScript
interface User {
id: number;
name: string;
}
const user: User = { id: 1, name: "John" };
console.log(user);
```
**区别**：
- Node.js 需要安装 TypeScript 编译器和类型定义
- Deno 原生支持 TypeScript，无需额外配置
- Deno 运行时进行类型检查
### 5. API 设计
#### Node.js
```javascript
// 回调风格
fs.readFile('file.txt', (err, data) => {
if (err) throw err;
console.log(data);
});
// Promise 风格
fs.promises.readFile('file.txt')
.then(data => console.log(data))
.catch(err => console.error(err));
```
#### Deno
```typescript
// 统一使用 Promise
const data = await Deno.readTextFile('file.txt');
console.log(data);
```
**区别**：
- Node.js 混合使用回调和 Promise
- Deno 统一使用 Promise 和 async/await
- Deno API 更现代化
### 6. 标准库
#### Node.js
```javascript
// 内置模块
const fs = require('fs');
const http = require('http');
const path = require('path');
```
#### Deno
```typescript
// 从 URL 导入标准库
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
import { ensureDir } from "https://deno.land/std@0.208.0/fs/mod.ts";
import { join } from "https://deno.land/std@0.208.0/path/mod.ts";
```
**区别**：
- Node.js 模块内置在运行时中
- Deno 标准库托管在网络上
- Deno 标准库更新更频繁
### 7. 工具链
#### Node.js
```bash
# 需要安装各种工具
npm install -D prettier eslint jest webpack
npx prettier --write .
npx eslint .
npm test
```
#### Deno
```bash
# 内置工具
deno fmt . # 格式化
deno lint . # 检查
deno test . # 测试
deno compile app.ts # 编译
```
**区别**：
- Node.js 需要安装多个外部工具
- Deno 内置所有必要工具
- Deno 工具链更统一
### 8. 全局对象
#### Node.js
```javascript
// 全局对象
global
process
Buffer
__dirname
__filename
require
module
exports
```
#### Deno
```typescript
// 全局对象
Deno
window (浏览器兼容)
fetch (Web 标准)
URL (Web 标准)
URLSearchParams (Web 标准)
```
**区别**：
- Node.js 有独特的全局对象
- Deno 更接近 Web 标准
- Deno 移除了 require/module 等 CommonJS 相关对象
### 9. 文件扩展名
#### Node.js
```javascript
// .js 文件
// .ts 文件需要编译
```
#### Deno
```typescript
// .ts 文件
// .js 文件
// .mts 文件
// .mjs 文件
```
**区别**：
- Node.js 主要使用 .js
- Deno 推荐 .ts，但也支持其他扩展名
### 10. 配置文件
#### Node.js
```json
// package.json
{
"name": "my-app",
"version": "1.0.0",
"dependencies": {},
"devDependencies": {},
"scripts": {}
}
// tsconfig.json
{
"compilerOptions": {}
}
```
#### Deno
```json
// deno.json
{
"compilerOptions": {
"strict": true
},
"tasks": {
"dev": "deno run --watch app.ts",
"test": "deno test"
},
"imports": {
"std/": "https://deno.land/std@0.208.0/"
}
}
```
**区别**：
- Node.js 需要 package.json 和 tsconfig.json
- Deno 只需要一个 deno.json 文件
- Deno 配置更简洁
## 性能对比
### 启动时间
- **Node.js**: 较快，C++ 实现
- **Deno**: 稍慢，但差距在缩小
### 运行时性能
- **Node.js**: 成熟优化，性能稳定
- **Deno**: 使用 Rust 和 Tokio，在某些场景下更快
### 内存使用
- **Node.js**: 内存占用较低
- **Deno**: 内存占用稍高，但仍在优化
## 生态系统对比
### 包数量
- **Node.js**: npm 上有超过 200 万个包
- **Deno**: deno.land/x 上有数千个包，增长迅速
### 社区规模
- **Node.js**: 庞大的社区，丰富的资源
- **Deno**: 快速增长的社区，活跃的开发
### 学习资源
- **Node.js**: 大量教程、文档、视频
- **Deno**: 文档完善，教程逐渐增多
## 适用场景
### 选择 Node.js
- 需要使用大量 npm 包
- 现有项目基于 Node.js
- 团队熟悉 Node.js 生态
- 需要成熟的生态系统
- 企业级应用，稳定性要求高
### 选择 Deno
- 新项目，追求现代化开发体验
- 需要更好的安全性
- TypeScript 优先
- 需要内置工具链
- 微服务架构
- 快速原型开发
## 迁移考虑
### 从 Node.js 迁移到 Deno
1. 重写模块导入（require → import）
2. 移除 package.json，使用 URL 导入
3. 更新 API 调用（Node.js API → Deno API）
4. 配置权限标志
5. 更新测试框架
### 从 Deno 迁移到 Node.js
1. 安装依赖（npm install）
2. 配置 TypeScript
3. 重写模块导入（URL → npm 包）
4. 更新 API 调用（Deno API → Node.js API）
5. 移除权限相关代码
## 总结
Deno 和 Node.js 各有优势：
- **Node.js**: 成熟稳定，生态丰富，适合大型项目
- **Deno**: 现代安全，开发体验好，适合新项目
选择哪个取决于项目需求、团队技能和长期规划。两者都在不断发展，未来可能会有更多的融合和借鉴。
服务端 · 2月18日 22:23
Deno 有哪些内置工具？如何使用它们？Deno 提供了一套完整的内置工具链，使得开发者无需安装额外的工具就能完成格式化、测试、linting、打包等开发任务。这些工具都集成在 Deno CLI 中，使用简单且高效。
## 内置工具概览
Deno 的内置工具包括：
1. **deno fmt** - 代码格式化
2. **deno lint** - 代码检查
3. **deno test** - 测试运行
4. **deno compile** - 编译为可执行文件
5. **deno bundle** - 打包为单个文件
6. **deno doc** - 生成文档
7. **deno bench** - 性能基准测试
## 代码格式化 (deno fmt)
### 基本用法
```bash
# 格式化当前目录所有文件
deno fmt
# 格式化指定文件
deno fmt src/main.ts
# 检查格式（不修改文件）
deno fmt --check
# 使用特定配置
deno fmt --options-line-width=100
```
### 配置选项
```bash
# 设置行宽
deno fmt --options-line-width=120
# 设置缩进
deno fmt --options-indent-width=2
# 使用单引号
deno fmt --options-single-quote
# 使用分号
deno fmt --options-use-tabs
```
### 示例
```typescript
// 格式化前
const name="Deno";
function hello(name:string){
console.log(`Hello,${name}!`);
}
// 格式化后
const name = "Deno";
function hello(name: string) {
console.log(`Hello, ${name}!`);
}
```
## 代码检查 (deno lint)
### 基本用法
```bash
# 检查当前目录
deno lint
# 检查指定文件
deno lint src/main.ts
# 自动修复问题
deno lint --fix
# 忽略特定规则
deno lint --ignore=no-unused-vars
```
### 配置规则
```bash
# 使用配置文件
deno lint --config=deno.json
# 排除文件
deno lint --exclude=**/*.test.ts
# 查看所有规则
deno lint --rules
```
### 常见规则
```typescript
// 错误示例
function foo() {
var x = 1; // no-var: 使用 let 或 const
const unused = 2; // no-unused-vars: 未使用的变量
}
// 正确示例
function foo() {
const x = 1;
return x;
}
```
## 测试 (deno test)
### 基本用法
```bash
# 运行所有测试
deno test
# 运行指定测试文件
deno test src/main_test.ts
# 监听模式（文件变化时自动运行）
deno test --watch
# 显示详细输出
deno test --verbose
# 并行运行测试
deno test --parallel
```
### 编写测试
```typescript
// math_test.ts
import { assertEquals, assertThrows } from "https://deno.land/std@0.208.0/testing/asserts.ts";
function add(a: number, b: number): number {
return a + b;
}
function divide(a: number, b: number): number {
if (b === 0) {
throw new Error("Division by zero");
}
return a / b;
}
Deno.test("add function adds two numbers", () => {
assertEquals(add(1, 2), 3);
assertEquals(add(-1, 1), 0);
});
Deno.test("divide function divides numbers", () => {
assertEquals(divide(10, 2), 5);
assertEquals(divide(5, 2), 2.5);
});
Deno.test("divide throws error on zero", () => {
assertThrows(
() => divide(10, 0),
Error,
"Division by zero"
);
});
```
### 异步测试
```typescript
Deno.test("async function", async () => {
const data = await fetchData();
assertEquals(data.length, 10);
});
Deno.test("timeout test", async () => {
const result = await slowOperation();
assertEquals(result, "done");
}, { timeout: 5000 });
```
### 测试钩子
```typescript
Deno.test("with setup and teardown", {
sanitizeOps: false,
sanitizeResources: false,
fn: async () => {
// Setup
const db = await connectDatabase();
try {
// Test
const user = await db.createUser({ name: "John" });
assertEquals(user.name, "John");
} finally {
// Teardown
await db.close();
}
}
});
```
## 编译为可执行文件 (deno compile)
### 基本用法
```bash
# 编译为可执行文件
deno compile src/main.ts
# 指定输出文件名
deno compile --output=myapp src/main.ts
# 指定目标平台
deno compile --target=x86_64-unknown-linux-gnu src/main.ts
# 包含权限
deno compile --allow-net --allow-read src/main.ts
```
### 示例
```typescript
// cli.ts
#!/usr/bin/env -S deno run
const name = Deno.args[0] || "World";
console.log(`Hello, ${name}!`);
```
编译：
```bash
deno compile --output=hello cli.ts
./hello Deno # 输出: Hello, Deno!
```
## 打包 (deno bundle)
### 基本用法
```bash
# 打包为单个文件
deno bundle src/main.ts bundle.js
# 指定输出文件
deno bundle src/main.ts dist/app.bundle.js
# 指定源映射
deno bundle --source-map=inline src/main.ts bundle.js
```
### 示例
```typescript
// main.ts
import { greet } from "./greet.ts";
import { farewell } from "./farewell.ts";
console.log(greet("Deno"));
console.log(farewell("Deno"));
```
打包：
```bash
deno bundle main.ts app.bundle.js
```
## 文档生成 (deno doc)
### 基本用法
```bash
# 生成文档
deno doc src/main.ts
# 生成 HTML 文档
deno doc --html src/main.ts
# 查看特定符号的文档
deno doc src/main.ts MyFunction
# 生成 JSON 文档
deno doc --json src/main.ts
```
### 编写文档
```typescript
/**
* 计算两个数的和
*
* @param a - 第一个数
* @param b - 第二个数
* @returns 两个数的和
*
* @example
* ```ts
* add(1, 2); // 返回 3
* ```
*/
export function add(a: number, b: number): number {
return a + b;
}
/**
* 用户接口
*/
export interface User {
/** 用户 ID */
id: number;
/** 用户名 */
name: string;
/** 用户邮箱 */
email: string;
}
```
## 性能基准测试 (deno bench)
### 基本用法
```bash
# 运行基准测试
deno bench
# 运行指定文件
deno bench src/bench.ts
```
### 编写基准测试
```typescript
import { bench, runBenchmarks } from "https://deno.land/std@0.208.0/testing/bench.ts";
bench("for loop", () => {
let sum = 0;
for (let i = 0; i < 1000; i++) {
sum += i;
}
});
bench("reduce", () => {
const arr = Array.from({ length: 1000 }, (_, i) => i);
arr.reduce((sum, num) => sum + num, 0);
});
await runBenchmarks();
```
## 配置文件
使用 `deno.json` 或 `deno.jsonc` 统一配置：
```json
{
"compilerOptions": {
"strict": true
},
"lint": {
"files": {
"include": ["src/"],
"exclude": ["src/test/"]
},
"rules": {
"tags": ["recommended"],
"exclude": ["no-unused-vars"]
}
},
"fmt": {
"files": {
"include": ["src/"],
"exclude": ["dist/"]
},
"options": {
"useTabs": false,
"lineWidth": 100,
"indentWidth": 2,
"singleQuote": true,
"proseWrap": "preserve"
}
},
"tasks": {
"dev": "deno run --watch src/main.ts",
"test": "deno test --allow-net",
"build": "deno compile src/main.ts"
}
}
```
## 任务运行
Deno 支持定义和运行任务：
```bash
# 列出所有任务
deno task
# 运行特定任务
deno task dev
# 运行测试任务
deno task test
```
## 最佳实践
1. **使用配置文件**：在 `deno.json` 中统一配置所有工具
2. **自动化检查**：在 CI/CD 中集成 lint 和 test
3. **保持一致性**：使用 fmt 确保代码风格统一
4. **编写测试**：为关键功能编写测试
5. **文档化代码**：使用 JSDoc 注释生成文档
6. **性能优化**：使用 bench 识别性能瓶颈
Deno 的内置工具链提供了完整的开发体验，无需安装额外的依赖，大大简化了项目配置和维护工作。
服务端 · 2月18日 22:22