1
// 一个典型的 2026 年 Cloudflare Worker
2
// 在边缘做个性化内容渲染 + AI 内容推荐
3
export default {
4
  async fetch(request: Request, env: Env): Promise<Response> {
5
    const url = new URL(request.url);
6
    const country = request.cf?.country || 'US';
7
    const userAgent = request.headers.get('User-Agent') || '';
8
    const isMobile = /Mobile|Android/i.test(userAgent);
9

10
    // 1. 在边缘读取缓存
11
    const cacheKey = `layout:${country}:${isMobile ? 'mobile' : 'desktop'}`;
12
    const cached = await env.KV_NAMESPACE.get(cacheKey);
13
    if (cached) {
14
      return new Response(cached, {
15
        headers: { 'Content-Type': 'text/html', 'X-Cache': 'HIT' },
16
      });
17
    }
18

19
    // 2. 根据用户地理位置获取本地化内容
20
    const [products, promotions] = await Promise.all([
21
      env.DB.prepare(
22
        'SELECT * FROM products WHERE region = ? AND active = 1 ORDER BY score DESC'
23
      ).bind(country).all(),
24
      env.KV_NAMESPACE.get(`promo:${country}`, 'json'),
25
    ]);
26

27
    // 3. 在边缘渲染 HTML（不需要回源站）
28
    const html = renderHTML({ products: products.results, promotions, country });
29

30
    // 4. 缓存结果
31
    await env.KV_NAMESPACE.put(cacheKey, html, { expirationTtl: 300 });
32

33
    return new Response(html, {
34
      headers: { 'Content-Type': 'text/html', 'X-Cache': 'MISS' },
35
    });
36
  },
37
};

1
// Deno Deploy 上运行的一个 WebSocket 服务
2
// 在边缘节点处理实时协作编辑
3
import { serve } from 'https://deno.land/std/http/server.ts';
4
import { WebSocketServer } from 'https://deno.land/x/websocket/mod.ts';
5

6
const wss = new WebSocketServer(8080);
7

8
// 房间管理 —— 存在边缘 KV 中
9
const rooms = new Map<string, Set<WebSocket>>();
10

11
wss.on('connection', (ws: WebSocket) => {
12
  let roomId: string;
13

14
  ws.on('message', (data: string) => {
15
    const msg = JSON.parse(data);
16

17
    switch (msg.type) {
18
      case 'join': {
19
        roomId = msg.roomId;
20
        if (!rooms.has(roomId)) rooms.set(roomId, new Set());
21
        rooms.get(roomId)!.add(ws);
22
        // 通知房间其他人
23
        broadcast(roomId, { type: 'user-joined', user: msg.user }, ws);
24
        break;
25
      }
26
      case 'edit': {
27
        // 实时广播编辑操作
28
        broadcast(roomId, msg, ws);
29
        break;
30
      }
31
      case 'cursor': {
32
        // 广播光标位置（多人协作必备）
33
        broadcast(roomId, { type: 'cursor', user: msg.user, position: msg.position }, ws);
34
        break;
35
      }
36
    }
37
  });
38

39
  ws.on('close', () => {
40
    if (roomId && rooms.has(roomId)) {
41
      rooms.get(roomId)!.delete(ws);
42
      broadcast(roomId, { type: 'user-left', userId: ws.userId });
43
    }
44
  });
45
});
46

47
function broadcast(roomId: string, message: unknown, exclude?: WebSocket) {
48
  const room = rooms.get(roomId);
49
  if (!room) return;
50
  const data = JSON.stringify(message);
51
  for (const client of room) {
52
    if (client !== exclude && client.readyState === WebSocket.OPEN) {
53
      client.send(data);
54
    }
55
  }
56
}
57

58
serve(() => new Response('WebSocket server running'), { port: 8080 });

1
// 使用 `isolate` 级别的代码隔离 + 预编译快照
2
// 将启动时间从 100ms+ 降到 5ms 以内
3

4
// wrangler.toml (Cloudflare Workers 配置文件)
5
name = "my-edge-app"
6
main = "src/index.ts"
7
compatibility_date = "2026-06-01"
8

9
# 开启模块预编译
10
workers_dev = true
11

12
# 预加载模块缓存
13
[placement]
14
mode = "smart"
15

16
# 配置代码快照
17
[snapshot]
18
path = "./snapshot.bin"

1
// 使用 Durable Objects + 版本号策略
2
// 保证边缘数据的最终一致性
3

4
export class ShoppingCart extends DurableObject {
5
  private state: Map<string, number>;
6
  private version: number = 0;
7

8
  constructor(ctx: DurableObjectState, env: Env) {
9
    super(ctx, env);
10
    this.state = new Map();
11
    ctx.blockConcurrencyWhile(async () => {
12
      const stored = await ctx.storage.get<Map<string, number>>('cart');
13
      this.state = stored || new Map();
14
    });
15
  }
16

17
  async fetch(request: Request): Promise<Response> {
18
    const { action, sku, quantity, clientVersion } = await request.json();
19

20
    // 版本冲突检测
21
    if (clientVersion && clientVersion < this.version) {
22
      return new Response(JSON.stringify({
23
        error: '版本冲突，请刷新重试',
24
        currentVersion: this.version,
25
      }), { status: 409 });
26
    }
27

28
    switch (action) {
29
      case 'add':
30
        this.state.set(sku, (this.state.get(sku) || 0) + quantity);
31
        break;
32
      case 'remove':
33
        this.state.delete(sku);
34
        break;
35
      case 'update':
36
        this.state.set(sku, quantity);
37
        break;
38
    }
39

40
    this.version++;
41
    await ctx.storage.put('cart', this.state);
42

43
    return new Response(JSON.stringify({
44
      items: Array.from(this.state.entries()),
45
      version: this.version,
46
    }));
47
  }
48
}

1
// Edge Worker 中的 A/B 实验分流示例
2
export default {
3
  async fetch(request: Request, env: Env): Promise<Response> {
4
    const url = new URL(request.url);
5
    const cookie = request.headers.get('Cookie') || '';
6

7
    // 在边缘解析用户身份
8
    const userId = parseUserId(cookie);
9
    const abTestGroup = await getABTestGroup(userId, url.pathname, env);
10

11
    // 直接在边缘修改响应内容
12
    const response = await fetch(request);
13
    const html = await response.text();
14

15
    const modifiedHtml = injectABTestVariant(html, abTestGroup);
16

17
    return new Response(modifiedHtml, {
18
      headers: {
19
        'Content-Type': 'text/html',
20
        'X-AB-Test': abTestGroup.name,
21
        'X-AB-Variant': abTestGroup.variant,
22
      },
23
    });
24
  },
25
};