什么是node中间件

const middleware = (req, res, next) => {
  // 请求处理逻辑  next()}

// 定义几个中间间函数const m1 = (req, res, next) => {
  console.log('m1 run')
  next()}const m2 = (req, res, next) => {
  console.log('m2 run')
  next()}const m3 = (req, res, next) => {
  console.log('m3 run')
  next()}// 中间件集合const middlewares = [m1, m2, m3]function useApp (req, res) {
  const next = () => {
    // 获取第一个中间件    const middleware = middlewares.shift()
    if (middleware) {
      middleware(req, res, next)
    }
  }
  next()}// 第一次请求流进入useApp()

m1 runm2 runm3 run

const m2 = (req, res, next) => {
  fetch('/xxxxx').then(res => {
    next()
  })}

function useApp (req, res) {
  const next = () => {
    const middleware = middlewares.shift()
    if (middleware) {
      // 将返回值包装为Promise对象      return Promise.resolve(middleware(req, res, next))
    }else {
      return Promise.resolve("end")
    }
  }
  next()}

const m1 = (req, res, next) => {
  console.log('m1 start')
  return next().then(() => {
    console.log('m1 end')
  })}

const m1 = async (req, res, next) => {
    // something...    let result = await next();
  }

  const m2 = async (req, res, next) => {
    // something...    let result = await next();
  }
  const m3 = async (req, res, next) => {
    // something...    let result = await next();
    return result;
  }const middlewares = [m1, m2, m3];function useApp (req, res) {
    const next = () => {
      const middleware = middlewares.shift()
      if (middleware) {
        return Promise.resolve(middleware(req, res, next))
      }else {
        return Promise.resolve("end")
      }
    }
    next()
  }// 启动中间件useApp()

function compose (middleware) {
  // 提前判断中间件类型,防止后续错误  if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
  for (const fn of middleware) {
    // 中间件必须为函数类型    if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
  }
  return function (context, next) {
    // 采用闭包将索引缓存,来实现调用计数    let index = -1
    return dispatch(0)
    function dispatch (i) {
      // 防止next()方法重复调用      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        // 包装next()返回值为Promise对象        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        // 异常处理        return Promise.reject(err)
      }
    }
  }}

// 模拟数据库操作const token = db.user();// router或者koa的中间件一定要用await处理next，否则将不能正常响应数据export default async (ctx, next) => {
  const t = ctx.request.header.authorization
  let uid = ctx.request.header['x-requested-with']
  let uidArr = uid.split(',')
  if(uidArr.length > 1) {
      uid = uidArr.pop().trim()
  }
    if(token[uid] && token[uid][1] === t) {
        await next()
    }else {
        ctx.status = 403;
        ctx.body = {
            state: 403,
            msg: '你没有权限操作'
        }
    }  }