如何构建带有条件分支的Promise链？

这个问题我太有共鸣了！之前写Promise链的时候也踩过这种分支扩散的坑，写出来的代码全是if-else判断，维护起来头大。给你分享几个我常用的清晰写法：

1. 把分支逻辑封装成独立函数，让主流程只做“分支选择” #

核心思路是：把每个分支的完整异步流程单独封装成函数，主Promise链只负责根据初始条件选择走哪个分支，后续就不用再判断分支类型了。

比如针对你的场景，我们可以这么改：

// 主流程：只负责选择分支
getIndexes(searchString)
  .then(indexes => {
    if (indexes.length) {
      // 走「有索引」的完整流程
      return handleIndexedSearch(indexes);
    } else {
      // 走「无索引」的完整流程
      return handleFullSearch(searchString);
    }
  })
  .then(finalResult => {
    // 这里拿到的是两个分支最终统一的结果，不用再做任何判断
    console.log('最终处理结果:', finalResult);
  })
  .catch(err => {
    // 统一捕获所有分支的错误
    console.error('搜索流程出错:', err);
  });

// 封装「有索引」分支的完整逻辑
function handleIndexedSearch(indexes) {
  return searchByIndex(indexes, 1, 5)
    // 这个分支直接返回查询到的records即可
    .then(records => records);
}

// 封装「无索引」分支的完整逻辑
function handleFullSearch(searchString) {
  return searchAllRecords(searchString)
    // 无索引分支需要额外创建索引
    .then(records => createIndexes(records, searchString));
}

这样改造后，每个分支的逻辑都被收拢到单独的函数里，主流程干净清爽，后续维护的时候要改某个分支的逻辑，直接找对应的函数就行，不会影响到其他部分。

2. 用async/await写，可读性拉满 #

如果你的环境支持ES2017+，那async/await绝对是处理异步分支的最优解，写法和同步代码几乎一模一样，完全不用嵌套then，分支逻辑一眼就能看明白：

async function performSearch(searchString) {
  try {
    // 先获取索引
    const indexes = await getIndexes(searchString);
    let finalResult;

    if (indexes.length) {
      // 有索引的情况：直接查询并返回结果
      const records = await searchByIndex(indexes, 1, 5);
      finalResult = records;
    } else {
      // 无索引的情况：全量查询后创建索引
      const records = await searchAllRecords(searchString);
      finalResult = await createIndexes(records, searchString);
    }

    console.log('最终结果:', finalResult);
    return finalResult;
  } catch (err) {
    // 统一处理所有异步操作的错误
    console.error('搜索失败:', err);
    throw err; // 可以把错误抛出去让上层处理
  }
}

// 调用这个异步函数
performSearch(searchString);

这种写法把异步流程“线性化”了，完全不用考虑Promise链的嵌套问题，写的时候就像写普通的同步if-else一样，谁看谁懂。

3. 分支后有公共逻辑？抽成公共函数复用 #

如果两个分支走完之后，还有一些相同的处理逻辑（比如结果格式化、日志上报），可以把这部分公共逻辑抽成独立函数，让两个分支的结果都经过这个函数处理：

// 公共处理函数：比如格式化结果
function formatSearchResult(result) {
  return result.map(item => ({
    id: item.id,
    title: item.title,
    isIndexed: !!item.indexId // 统一添加标识字段
  }));
}

getIndexes(searchString)
  .then(indexes => {
    // 直接在分支里写完各自的流程
    return indexes.length 
      ? searchByIndex(indexes, 1, 5)
      : searchAllRecords(searchString).then(records => createIndexes(records, searchString));
  })
  .then(formatSearchResult) // 两个分支的结果都走公共格式化
  .then(formattedResult => {
    console.log('格式化后的结果:', formattedResult);
  })
  .catch(err => console.error('流程出错:', err));

这种方式适合分支后有统一操作的场景，能减少代码重复，让主流程更简洁。

最后总结一下 #

不管用哪种方式，核心原则都是不要让分支判断扩散到整个Promise链的每个then中，尽量把分支逻辑内聚，要么封装成独立函数，要么用async/await线性化写法，这样写出来的代码不仅清晰，维护起来也轻松很多。

备注：内容来源于stack exchange，提问作者gib65