JavaScript异步编程：从回调地狱到链式错误处理

1. 异步编程的演进与痛点

2009年Node.js的横空出世让回调函数（Callback）成为JavaScript异步编程的主流模式。我至今还记得第一次用fs.readFile时那种层层嵌套的回调地狱：

javascript复制fs.readFile('file1.txt', (err, data1) => {
  if (err) throw err;
  fs.readFile('file2.txt', (err, data2) => {
    if (err) throw err;
    // 更多嵌套...
  });
});

这种模式最致命的问题是错误处理分散且不可控。2015年Promise的ES6标准化带来了转机，配合then/catch的链式调用让代码有了纵向扩展的可能：

javascript复制readFilePromise('file1.txt')
  .then(data1 => readFilePromise('file2.txt'))
  .then(data2 => { /* 处理数据 */ })
  .catch(err => console.error('统一捕获:', err));

但真正的革命发生在ES2017引入async/await之后。我第一次用await替换then链时，那种同步写法般的体验令人惊艳：

javascript复制async function readFiles() {
  try {
    const data1 = await readFilePromise('file1.txt');
    const data2 = await readFilePromise('file2.txt');
    // 同步风格的代码
  } catch (err) {
    console.error('try-catch捕获:', err);
  }
}

2. 传统try-catch的局限性

2.1 代码结构膨胀问题

在真实项目中，我经常遇到需要处理多个异步操作的场景。比如这个用户注册流程：

javascript复制async function register(user) {
  try {
    const validated = await validateUser(user);
    const hashed = await hashPassword(validated.password);
    const saved = await db.users.create({ ...validated, password: hashed });
    await sendWelcomeEmail(saved.email);
    return saved;
  } catch (err) {
    if (err instanceof ValidationError) {
      return { error: '验证失败', details: err.errors };
    } else if (err instanceof DatabaseError) {
      return { error: '数据库操作失败' };
    } else {
      throw err; // 未预期的错误继续抛出
    }
  }
}

这种模式会导致：

1. try块内代码快速膨胀
2. 错误类型判断逻辑复杂化
3. 不同错误的处理耦合在一起

2.2 错误类型判断的负担

在微服务架构中，一个API调用可能涉及多种错误：

javascript复制try {
  const payment = await paymentService.charge(order);
  const shipment = await logisticsService.createShipment(order);
  await notificationService.sendReceipt(order.userId);
} catch (err) {
  if (err instanceof PaymentError) {
    // 支付失败处理
  } else if (err instanceof NetworkError) {
    // 网络问题处理
  } else if (err instanceof ServiceUnavailableError) {
    // 服务降级处理
  }
  // 更多else if...
}

这种模式在Go和Rust中同样存在。比如Go的经典模式：

go复制result, err := someAsyncOperation()
if err != nil {
    // 错误处理
}

3. 链式错误处理方案设计

3.1 核心设计思想

受Promise链式调用的启发，我设计了一个包装函数：

javascript复制function asyncChain(fn) {
  return {
    then: nextFn => asyncChain(async ctx => {
      try {
        const result = await fn(ctx);
        return nextFn({ ...ctx, result });
      } catch (err) {
        return { ...ctx, error: err };
      }
    }),
    catch: handler => asyncChain(async ctx => {
      if (ctx.error) {
        return handler(ctx.error, ctx);
      }
      return ctx;
    }),
    exec: () => fn({})
  };
}

3.2 完整实现方案

经过多次迭代，最终版本支持：

1. 中间件模式
2. 错误冒泡机制
3. 上下文传递

javascript复制class AsyncChain {
  constructor(executor) {
    this.chain = [executor];
  }

  then(handler) {
    this.chain.push(async (ctx, next) => {
      try {
        ctx.result = await handler(ctx.result);
        return next();
      } catch (err) {
        ctx.error = err;
        return ctx;
      }
    });
    return this;
  }

  catch(handler) {
    this.chain.push(async (ctx, next) => {
      if (ctx.error) {
        ctx.result = await handler(ctx.error, ctx);
        ctx.error = null;
      }
      return next();
    });
    return this;
  }

  async execute(initialValue) {
    const ctx = { result: initialValue, error: null };
    let index = 0;
    
    const next = async () => {
      if (index < this.chain.length) {
        const current = this.chain[index++];
        return current(ctx, next);
      }
      return ctx;
    };

    return (await next()).result;
  }
}

4. 实战应用对比

4.1 用户登录流程改造

传统方式：

javascript复制async function login(username, password) {
  try {
    const user = await User.findOne({ username });
    if (!user) throw new Error('用户不存在');
    
    const valid = await bcrypt.compare(password, user.password);
    if (!valid) throw new Error('密码错误');
    
    const token = jwt.sign({ userId: user.id }, SECRET);
    return { success: true, token };
  } catch (err) {
    return {
      success: false,
      error: err.message
    };
  }
}

链式改造后：

javascript复制function login(username, password) {
  return new AsyncChain(async ctx => {
    ctx.user = await User.findOne({ username });
    return ctx;
  })
  .then(ctx => {
    if (!ctx.user) throw new Error('用户不存在');
    return ctx;
  })
  .then(async ctx => {
    ctx.valid = await bcrypt.compare(password, ctx.user.password);
    return ctx;
  })
  .then(ctx => {
    if (!ctx.valid) throw new Error('密码错误');
    ctx.token = jwt.sign({ userId: ctx.user.id }, SECRET);
    return ctx;
  })
  .catch((err, ctx) => {
    ctx.error = err.message;
    return ctx;
  })
  .execute();
}

4.2 电商订单处理

复杂业务场景下的优势更明显：

javascript复制function processOrder(orderId) {
  return new AsyncChain()
    .then(async () => {
      const order = await Order.findById(orderId);
      if (!order) throw new OrderNotFoundError();
      return { order };
    })
    .then(async ctx => {
      const stock = await Inventory.check(ctx.order.productId);
      if (stock < ctx.order.quantity) throw new OutOfStockError();
      return ctx;
    })
    .catch(OrderNotFoundError, () => ({ status: 'order_not_found' }))
    .catch(OutOfStockError, () => ({ status: 'out_of_stock' }))
    .then(async ctx => {
      if (ctx.status) return ctx; // 跳过已处理的错误
      
      await Payment.capture(ctx.order.total);
      await Inventory.decrement(ctx.order.productId, ctx.order.quantity);
      return { ...ctx, status: 'completed' };
    })
    .catch(PaymentError, () => ({ status: 'payment_failed' }))
    .execute();
}

5. 高级特性实现

5.1 错误类型匹配

扩展catch处理特定错误类型：

javascript复制class AsyncChain {
  // ...其他代码
  
  catch(errorType, handler) {
    this.chain.push(async (ctx, next) => {
      if (ctx.error && ctx.error instanceof errorType) {
        ctx.result = await handler(ctx.error, ctx);
        ctx.error = null;
      }
      return next();
    });
    return this;
  }
}

5.2 上下文共享机制

通过ctx对象实现跨步骤数据传递：

javascript复制asyncChain()
  .then(() => ({ userId: 123 })) // 初始化上下文
  .then(async ctx => {
    ctx.user = await User.findById(ctx.userId);
    return ctx;
  })
  .then(async ctx => {
    ctx.profile = await Profile.findByUser(ctx.userId);
    return ctx;
  })
  .execute();

5.3 并行处理支持

结合Promise.all处理并行任务：

javascript复制asyncChain()
  .then(async () => {
    const [user, products] = await Promise.all([
      User.findById(123),
      Product.find({ featured: true })
    ]);
    return { user, products };
  })
  // ...后续处理

6. 性能与调试考量

6.1 性能开销测试

通过基准测试对比（Node.js 16.x）：

虽然链式方案有约20%的性能损耗，但对于大多数应用场景可以接受。

6.2 调试技巧

1. 中间件调试模式：

javascript复制function debugMiddleware(label) {
  return async (ctx, next) => {
    console.time(label);
    await next();
    console.timeEnd(label);
    console.log('上下文:', ctx);
  };
}

asyncChain()
  .use(debugMiddleware('用户查询'))
  .then(/* ... */)
  .use(debugMiddleware('库存检查'))
  // ...

2. 错误堆栈增强：

javascript复制class AsyncChain {
  // ...其他代码
  
  then(handler) {
    this.chain.push(async (ctx, next) => {
      try {
        const start = new Error().stack; // 捕获当前堆栈
        const result = await handler(ctx.result);
        return next();
      } catch (err) {
        err.chainStack = new Error().stack;
        ctx.error = err;
        return ctx;
      }
    });
    return this;
  }
}

7. 多语言实现参考

7.1 Go语言版本

利用Go的接口特性实现：

go复制type ChainHandler func(ctx context.Context) (context.Context, error)

type AsyncChain struct {
    handlers []ChainHandler
}

func (ac *AsyncChain) Then(handler ChainHandler) *AsyncChain {
    ac.handlers = append(ac.handlers, handler)
    return ac
}

func (ac *AsyncChain) Catch(handler func(err error, ctx context.Context) context.Context) *AsyncChain {
    ac.handlers = append(ac.handlers, func(ctx context.Context) (context.Context, error) {
        if err := ctx.Value("error"); err != nil {
            newCtx := handler(err.(error), ctx)
            return newCtx, nil
        }
        return ctx, nil
    })
    return ac
}

func (ac *AsyncChain) Execute(initialCtx context.Context) (context.Context, error) {
    var err error
    ctx := initialCtx
    
    for _, handler := range ac.handlers {
        ctx, err = handler(ctx)
        if err != nil {
            ctx = context.WithValue(ctx, "error", err)
        }
    }
    
    return ctx, nil
}

7.2 Rust实现

利用Rust的Result和宏：

rust复制struct AsyncChain<T, E> {
    steps: Vec<Box<dyn Fn(Result<T, E>) -> Result<T, E>>>,
}

impl<T, E> AsyncChain<T, E> {
    fn new() -> Self {
        AsyncChain { steps: Vec::new() }
    }
    
    fn then<F>(mut self, f: F) -> Self 
    where
        F: Fn(T) -> Result<T, E> + 'static,
    {
        self.steps.push(Box::new(move |res| res.and_then(|x| f(x))));
        self
    }
    
    fn catch<F>(mut self, f: F) -> Self 
    where
        F: Fn(E) -> Result<T, E> + 'static,
    {
        self.steps.push(Box::new(move |res| res.or_else(|e| f(e))));
        self
    }
    
    fn execute(self, init: Result<T, E>) -> Result<T, E> {
        self.steps.into_iter().fold(init, |res, step| step(res))
    }
}

// 使用示例
let result = AsyncChain::new()
    .then(|x| Ok(x + 1))
    .then(|x| if x > 10 { Err("too big") } else { Ok(x) })
    .catch(|_| Ok(5))
    .execute(Ok(8));

8. 生产环境最佳实践

8.1 错误分类策略

建议将业务错误分为三类处理：

1. 可恢复错误：通过catch转换为正常业务响应

   javascript复制.catch(InvalidInputError, err => ({ 
     status: 400,
     message: err.message 
   }))
   

2. 不可恢复错误：记录日志后抛出

   javascript复制.catch(DatabaseError, err => {
     logger.error('数据库错误', err);
     throw err;
   })
   

3. 预期外错误：统一转换为系统错误

   javascript复制.catch(err => ({
     status: 500,
     message: '系统繁忙，请稍后重试'
   }))
   

8.2 中间件组合

推荐的项目结构：

code复制middlewares/
  ├── errorLogger.js
  ├── requestValidator.js
  ├── responseFormatter.js
  └── index.js

组合使用示例：

javascript复制const chain = new AsyncChain()
  .use(errorLogger)
  .use(requestValidator)
  .then(controllerHandler)
  .use(responseFormatter);

8.3 TypeScript支持

完整的类型定义：

typescript复制interface ChainContext<T = any> {
  result?: T;
  error?: Error;
  [key: string]: any;
}

type ChainHandler<T, R> = (ctx: ChainContext<T>) => Promise<ChainContext<R>>;
type ErrorHandler<T> = (err: Error, ctx: ChainContext<T>) => Promise<ChainContext>;

class AsyncChain<T = void> {
  private chain: Array<ChainHandler<any, any>> = [];

  then<R>(handler: (input: T) => Promise<R>): AsyncChain<R>;
  then<R>(handler: (input: T) => R): AsyncChain<R>;
  
  catch(handler: ErrorHandler<T>): AsyncChain<T>;
  catch<E extends Error>(
    errorType: new (...args: any[]) => E,
    handler: ErrorHandler<T>
  ): AsyncChain<T>;
  
  use<R>(middleware: ChainHandler<T, R>): AsyncChain<R>;
  
  execute(initialValue?: T): Promise<T>;
}