机制

2023年05月31日

柏拉文

越努力，越幸运

一、同步

---

1.1 同步拼接

function compose(middleware) {
  if (!Array.isArray(middleware)) {
    return new TypeError("middleware 必须是一个函数数组");
  }

  for (const fn of middleware) {
    if (typeof fn !== "function") {
      return new TypeError("middleware 必须是一个函数");
    }
  }

  return function (context, next) {
    let index = -1;

    function dispatch(i) {
      if (i <= index) {
        return Promise.reject(new Error("next() 函数不可以调用多次"));
      }

      index = i;
      let fn = middleware[index];
      if (index === middleware.length) {
        fn = next;
      }
      if (!fn) {
        return Promise.resolve();
      }

      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (error) {
        return Promise.reject(error);
      }
    }

    return dispatch(0);
  };
}

let fn1 = async function (ctx, next) {
  ctx.message = "aaa";
  next();
  console.log(ctx.message);
};
let fn2 = async function (ctx, next) {
  ctx.message += "bbb";
  next();
};
let fn3 = async function (ctx, next) {
  ctx.message += "ccc";
};

let middleware = [fn1, fn2, fn3];
compose(middleware)({});

结果: aaabbbccc

分析: 其实express和koa同步实现没有什么区别，都是从上往下执行，当执行到next的时候，会将控制权交给下一个中间件，直到下一个中间件不再执行 next() 后，将会沿路折返，将控制权依次交还给前一个中间件，当交还到第一个中间件res.end时候，req.message里面就为aaabbbccc。

二、异步

---

2.1 异步拼接

function compose(middleware) {
  if (!Array.isArray(middleware)) {
    return new TypeError("middleware 必须是一个函数数组");
  }

  for (const fn of middleware) {
    if (typeof fn !== "function") {
      return new TypeError("middleware 必须是一个函数");
    }
  }

  return function (context, next) {
    let index = -1;

    function dispatch(i) {
      if (i <= index) {
        return Promise.reject(new Error("next() 函数不可以调用多次"));
      }

      index = i;
      let fn = middleware[index];
      if (index === middleware.length) {
        fn = next;
      }
      if (!fn) {
        return Promise.resolve();
      }

      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (error) {
        return Promise.reject(error);
      }
    }

    return dispatch(0);
  };
}

async function middleware1(ctx, next) {
  ctx.message = "aaa";
  await next();
  console.log(ctx.message);
}
async function middleware2(ctx, next) {
  ctx.message += "bbb";
  await next();
}

function promiseFun() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("ccc");
    }, 3000);
  });
}
async function middleware3(ctx, next) {
  const result = await promiseFun();
  ctx.message += result;
}

let middleware = [middleware1, middleware2, middleware3];
compose(middleware)({});

结果: aaabbbccc

分析: 在koa中next返回的是Promise可以包含异步操作，所以可以加上await使其变为同步执行最后拿到请求的结果。