JS 生成器与迭代器协议 - 实现自定义可迭代对象的完整指南

class MyRange {
  constructor(start, end) {
    this.start = start;
    this.end = end;
  }

  // 关键：实现Symbol.iterator方法，并使用生成器函数
  *[Symbol.iterator]() {
    let current = this.start;
    while (current < this.end) {
      yield current; // 每次yield都会暂停执行，并返回一个值
      current++;
    }
    // 当循环结束，生成器函数自然完成，next()会返回 { value: undefined, done: true }
  }

  // 当然，你也可以添加其他方法，比如一个步长功能
  *[Symbol.iteratorWithStep](step = 1) {
    if (step <= 0) throw new Error("步长必须大于0");
    let current = this.start;
    while (current < this.end) {
      yield current;
      current += step;
    }
  }
}

// 使用示例
const myNumbers = new MyRange(1, 5);

console.log("--- 使用for...of遍历 ---");
for (const num of myNumbers) {
  console.log(num); // 输出 1, 2, 3, 4
}

console.log("\n--- 手动调用迭代器 ---");
const iterator = myNumbers[Symbol.iterator]();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
// ... 持续调用直到 done: true

// 如果我们想用自定义的步长迭代器
console.log("\n--- 使用自定义步长迭代器遍历 ---");
const myNumbersWithStep = new MyRange(0, 10);
// 注意：这里我们不能直接用for...of，因为Symbol.iterator是默认的
// 如果想用，需要将Symbol.iteratorWithStep赋值给Symbol.iterator，或者直接调用
const stepIterator = myNumbersWithStep[Symbol.iteratorWithStep](2);
for (const num of stepIterator) {
  console.log(num); // 输出 0, 2, 4, 6, 8
}

// 对比：手动实现迭代器（更复杂）
function createRangeIterator(start, end) {
  let current = start;
  return {
    next() {
      if (current < end) {
        return { value: current++, done: false };
      } else {
        return { value: undefined, done: true };
      }
    }
  };
}

const manualIter = createRangeIterator(1, 3);
console.log(manualIter.next()); // { value: 1, done: false }
console.log(manualIter.next()); // { value: 2, done: false }
console.log(manualIter.next()); // { value: undefined, done: true }

// 使用生成器实现（更简洁）
function* createRangeGenerator(start, end) {
  let current = start;
  while (current < end) {
    yield current++;
  }
}

const genIter = createRangeGenerator(1, 3);
console.log(genIter.next()); // { value: 1, done: false }
console.log(genIter.next()); // { value: 2, done: false }
console.log(genIter.next()); // { value: undefined, done: true }

// 假设有一个模拟的数据源，比如日志文件中的行
function* readLogLines() {
  const logs = [
    "ERROR: User 123 failed login",
    "INFO: User 456 accessed dashboard",
    "WARN: Disk space low",
    "ERROR: Database connection lost",
    "INFO: User 123 logged out"
  ];
  for (const line of logs) {
    yield line;
  }
}

// 转换器：将日志行解析成结构化对象
function* parseLogEntry(logLinesIterator) {
  for (const line of logLinesIterator) {
    const parts = line.split(': ');
    if (parts.length >= 2) {
      yield { level: parts[0], message: parts.slice(1).join(': ') };
    }
  }
}

// 过滤器：只获取错误级别的日志
function* filterErrors(logEntriesIterator) {
  for (const entry of logEntriesIterator) {
    if (entry.level === 'ERROR') {
      yield entry;
    }
  }
}

// 消费者：处理最终的错误日志
function processErrorLogs(errorLogIterator) {
  console.log("--- 处理错误日志 ---");
  for (const error of errorLogIterator) {
    console.log(`[${error.level}] ${error.message}`);
    // 实际应用中，这里可能会发送告警、记录到错误日志系统等
  }
}

// 构建数据处理管道
const logLines = readLogLines(); // 获取原始日志行迭代器
const parsedEntries = parseLogEntry(logLines); // 解析日志条目迭代器
const errorLogs = filterErrors(parsedEntries); // 过滤错误日志迭代器

// 消费最终的错误日志
processErrorLogs(errorLogs);
/*
输出：
--- 处理错误日志 ---
[ERROR] User 123 failed login
[ERROR] Database connection lost
*/