标题：如何通过生成器函数实现同步与异步逻辑的高效复用

本文介绍使用生成器函数（generator）抽象公共迭代逻辑，使同一核心算法既能以同步方式运行，也能无缝适配异步回调，显著减少重复代码和维护成本。

在实际开发中，我们常遇到这样一类问题：一段核心业务逻辑（如正则匹配遍历、数据流处理、状态机推进等）既需要同步执行（用于服务端预渲染、单元测试或轻量计算），又需支持异步变体（如调用 API、读取文件或等待数据库响应）。若为两者分别编写几乎相同的循环结构，不仅违反 DRY 原则，还极易因漏改一处导致行为不一致。

上述示例中，regExpSync 与 regExpAsync 的差异仅在于 fn(res) 是否被 await，其余控制流（定位更新、匹配循环、提前退出）完全一致。理想解法是将“可迭代过程”与“执行模式”解耦——这正是生成器函数（function*）的天然优势。

✅ 推荐方案：生成器 + 迭代器驱动

首先，提取纯同步、无副作用的匹配逻辑为生成器：

function* regExp(str, pat) {
  let loc = 0;
  let res;
  while ((res = pat.exec(str.substring(loc)))) {
    yield res; // 每次产出一个匹配结果
    loc += res.length + res.index;
  }
}

该生成器不关心 fn 是同步还是异步，只负责按序产出匹配项。后续只需用不同“驱动器”消费它：

// 同步版本：直接 for...of 遍历
function regExpSync(str, pat, fn) {
  for (const res of regExp(str, pat)) {
    const rtn = fn(res);
    if (rtn) return rtn;
  }
}

// 异步版本：同样 for...of，但 await 回调
async function regExpAsync(str, pat, fn) {
  for (const res of regExp(str, pat)) {
    const rtn = await fn(res);
    if (rtn) return rtn;
  }
}

✅ 优势明显：

• 核心循环逻辑（regExp）唯一定义、一次维护；
• 同步/异步入口函数体积极小，语义清晰；
• 可自由组合其他迭代器方法（如 Array.from(regExp(...)) 收集全部结果）。

? 进阶：统一入口 + 自动模式识别（可选）

若项目中需大量此类函数，还可进一步封装为通用执行器。利用 yield 暂停特性，让生成器主动“请求”回调执行结果：

function* regExpDriver(str, pat, fn) {
  let loc = 0;
  let res;
  while ((res = pat.exec(str.substring(loc)))) {
    const rtn = yield fn(res); // 暂停，等待 fn 执行结果
    if (rtn) return rtn;
    loc += res.length + res.index;
  }
}

// 同步执行器：忽略 yield 值，立即传回
function syncRun(genFn) {
  return function (...args) {
    const gen = genFn(...args);
    let result = gen.next();
    while (!result.done) result = gen.next(result.value);
    return result.value;
  };
}

// 异步执行器：await yield 出的 Promise，再传回结果
function asyncRun(genFn) {
  return async function (...args) {
    const gen = genFn(...args);
    let result = gen.next();
    while (!result.done) {
      result = await Promise.resolve(result.value)
        .then(val => gen.next(val))
        .catch(err => gen.throw(err));
    }
    return result.value;
  };
}

// 统一暴露
const regExpSync = syncRun(regExpDriver);
const regExpAsync = asyncRun(regExpDriver);

⚠️ 注意事项：

• syncRun 中 Promise.resolve(result.value) 确保能安全处理同步值（避免 TypeError: Cannot read property 'then' of undefined）；
• asyncRun 的 .catch() 处理了异步 fn 抛出错误并正确传递给生成器（gen.throw()）；
• 此方案适用于逻辑复杂、暂停点明确的场景；简单用例推荐前一种更直观的 for...of 方式。

? 补充：利用现代迭代器辅助方法（ES2025+）

若目标环境支持 Iterator Helpers（Chrome 128+、Node.js 22+），可进一步简化：

// 同步：利用 some() 短路特性
const regExpSync = (str, pat, fn) => [...regExp(str, pat)].some(fn);

// 异步：需配合 AsyncIterator（暂未原生支持，可用 polyfill 或手写）
const regExpAsync = async (str, pat, fn) => {
  for await (const res of AsyncIterator.from(regExp(str, pat))) {
    if (await fn(res)) return true;
  }
  return false;
};

? 提示：AsyncIterator.from() 尚未进入标准，生产环境建议使用 iter-tools 等成熟库替代。

✅ 总结

• 核心思想：用生成器分离“数据生产”与“消费模式”，消除重复控制流；
• 首选实践：function* + for...of（清晰、兼容性好、易调试）；
• 进阶选择：yield + 自定义执行器（适合框架级抽象，但增加心智负担）；



• 长期趋势：关注 Iterator Helpers 和 AsyncIterator 标准化进程，拥抱更声明式的异步迭代。

从此，修改一次核心逻辑，同步与异步版本自动同步更新——代码更健壮，维护更轻松。

# ai  # js  # 循环  # Property  # chrome  # node  # 封装  # throw  # catch  # for  # node.js  # Array 

相关栏目： <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 AI推广<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 SEO优化<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 技术百科<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 谷歌推广<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 百度推广<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 网络营销<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 案例网站<？ｍｕｍａ echo $count; ?> 】 <？ｍｕｍａ $count = M('archives')->where(['typeid'=>$field['id']])->count(); ?> 【 精选文章<？ｍｕｍａ echo $count; ?> 】