Javascript 对于同步异步之间的代码重用有什么 idea 吗

您可以使用生成器函数来抽象出循环:

function* regExp(str, pat) {
  let loc = 0;
  let res;
  while((res = pat.exec(str.substring(loc)))){
    yield res;
    loc += res.length + res.index;
  }
}
function regExpSync(str, pat, fn) {
  for (const res of regExp(str, pat)) {
    const rtn = fn(res);
    if(rtn) return rtn;
  }
}
async function regExpAsync(str, pat, fn) {
  for (const res of regExp(str, pat)) {
    const rtn = await fn(res);
    if (rtn) return rtn;
  }
}

请注意，使用regExp返回的迭代器，您甚至可以使用iterator helper methods进一步简化:

 const regExpSync = (str, pat, fn) => regExp(str, pat).some(fn);
 // or strictly
 const regExpSync = (str, pat, fn) => regExp(str, pat).map(fn).find(Boolean);

 const regExpAsync = (str, pat, fn) => AsyncIterator.from(regExp(str, pat)).some(fn);

但是，如果这不符合您的要求，您实际上可以为整个逻辑使用生成器函数yield，其中promise 可能需要await次，然后同步运行(只需跳过输出值并立即将其传回)或异步运行(通过等待输出值并传递/抛回其结果):

function regExp*(str, pat, fn) {
  let loc = 0;
  let res;
  while((res = pat.exec(str.substring(loc)))){
    const rtn = yield fn(res);
    if(rtn) return rtn;
    loc += res.length + res.index;
  }
}
function syncRun(generatorFn) {
  return function(...args) {
    const generator = generatorFn.apply(this, args);
    let result = {done: false, value: undefined};
    while (!result.done) {
      result = generator.next(result.value);
    }
    return result.value;
  };
}
function asyncRun(generatorFn) {
  return async function(...args) {
    const generator = generatorFn.apply(this, args);
    let method = "next", done = false, value = undefined;
    while (!done) {
      ({value, done} = generator[method](value));
      [method, value] = await Promise.resolve(value).then(
        result => ["next", result],
        error => ["throw", error]
      );
    }
    return value;
  };
}

const regExpSync = syncRun(regExp);
const regExpAsync = asyncRun(regExp);