02 - Codex 核心特点详解

/**
 * 令牌桶限流中间件
 * @module rate-limiter
 */

class TokenBucket {
  constructor(capacity, refillRate) {
    this.capacity = capacity;        // 桶容量
    this.tokens = capacity;          // 当前令牌数
    this.refillRate = refillRate;    // 每秒补充的令牌数
    this.lastRefill = Date.now();    // 上次补充时间
  }

  /**
   * 尝试消耗一个令牌
   * @returns {boolean} 是否成功获取令牌
   */
  consume() {
    this.refill();

    if (this.tokens >= 1) {
      this.tokens -= 1;
      return true;
    }

    return false;
  }

  /**
   * 补充令牌
   */
  refill() {
    const now = Date.now();
    const timePassed = (now - this.lastRefill) / 1000; // 转换为秒
    const tokensToAdd = timePassed * this.refillRate;

    this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
    this.lastRefill = now;
  }
}

/**
 * 创建限流中间件
 * @param {Object} options 配置选项
 * @param {number} options.capacity 桶容量（最大突发请求数）
 * @param {number} options.refillRate 每秒补充的令牌数
 * @returns {Function} Express 中间件函数
 */
function createRateLimiter(options = {}) {
  const {
    capacity = 10,
    refillRate = 1,
    keyGenerator = (req) => req.ip,
    onRateLimitExceeded = (req, res) => {
      res.status(429).json({
        error: 'Too Many Requests',
        message: '请求过于频繁，请稍后再试'
      });
    }
  } = options;

  // 存储每个 IP 的令牌桶
  const buckets = new Map();

  return function rateLimiter(req, res, next) {
    const key = keyGenerator(req);

    // 获取或创建令牌桶
    if (!buckets.has(key)) {
      buckets.set(key, new TokenBucket(capacity, refillRate));
    }

    const bucket = buckets.get(key);

    // 尝试消耗令牌
    if (bucket.consume()) {
      // 添加速率限制信息到响应头
      res.setHeader('X-RateLimit-Limit', capacity);
      res.setHeader('X-RateLimit-Remaining', Math.floor(bucket.tokens));
      next();
    } else {
      onRateLimitExceeded(req, res);
    }
  };
}

module.exports = { createRateLimiter, TokenBucket };

// 使用示例
/*
const express = require('express');
const { createRateLimiter } = require('./rate-limiter');

const app = express();

// 应用限流中间件
app.use(createRateLimiter({
  capacity: 20,      // 最多 20 个令牌
  refillRate: 5      // 每秒补充 5 个令牌
}));

app.get('/api/data', (req, res) => {
  res.json({ message: 'Success' });
});

app.listen(3000);
*/

/**
 * 创建一个带缓存功能的函数包装器（记忆化）
 * 
 * @template T - 函数的返回类型
 * @param {Function} fn - 需要缓存结果的函数
 * @returns {Function} 包装后的函数，会自动缓存相同参数的计算结果
 * 
 * @description
 * 该函数使用 Map 来缓存函数调用的结果。
 * 当使用相同参数调用时，直接返回缓存的结果，避免重复计算。
 * 
 * @example
 * // 创建一个斐波那契函数
 * const fibonacci = memoize(function(n) {
 *   if (n <= 1) return n;
 *   return fibonacci(n - 1) + fibonacci(n - 2);
 * });
 * 
 * console.log(fibonacci(10)); // 第一次计算
 * console.log(fibonacci(10)); // 直接从缓存返回
 * 
 * @performance
 * - 时间复杂度：O(1) 对于缓存命中的情况
 * - 空间复杂度：O(n) n 为不同参数组合的数量
 * 
 * @note
 * - 参数使用 JSON.stringify 序列化为缓存键
 * - 不适用于参数包含函数或循环引用的情况
 * - 适合纯函数，不适合有副作用的函数
 */
function memoize(fn) {
  const cache = new Map();
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

// 从 API 获取用户数据
const userData =

const userData = await fetch('/api/user').then(res => res.json());

function fibonacci(n, memo = {}) {
  if (n in memo) {
    return memo[n];
  }
  
  if (n <= 1) {
    return n;
  }
  
  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
}

// 生成前10个斐波那契数
const result = Array.from({ length: 10 }, (_, i) => fibonacci(i));
console.log(result);

async function loadUserData() {
  const users = await fetchUsers();
  
  // 问题：forEach 不等待异步操作
  users.forEach(async (user) => {
    user.profile = await fetchProfile(user.id);
  });
  
  return users;  // profile 可能还未加载完成
}

async function loadUserData() {
  const users = await fetchUsers();
  
  /**
   * 修复说明：
   * 1. forEach 不会等待异步操作完成
   * 2. 改用 Promise.all + map 来并行处理
   * 3. 确保所有 profile 加载完成后再返回
   */
  await Promise.all(
    users.map(async (user) => {
      user.profile = await fetchProfile(user.id);
    })
  );
  
  return users;
}

// 替代方案（串行处理）：
async function loadUserDataSequential() {
  const users = await fetchUsers();
  
  for (const user of users) {
    user.profile = await fetchProfile(user.id);
  }
  
  return users;
}

// 文件：models/User.js
class User {
  constructor(id, name, email) {
    this.id = id;
    this.name = name;
    this.email = email;
  }
}

// 文件：services/UserService.js
// 只需写注释，Copilot 会理解 User 模型
// 创建函数，根据 ID 查找用户
async function findUserById(id) {
  // Copilot 自动生成，知道返回类型是 User
}