Various implementation principles of function composition

Time:2021-10-25

//Responsibility chain model (executed one by one)

const fn1 = (x, y) => x + y;
const fn2 = (z) => z * z;

//Normal combination

const compose = (fn1, ...other) => (...args) => {
  let ret = fn1(...args);
  other.forEach(item => {
    ret = item(ret);
  });
  return ret;
}

//Redux middleware combination mode

const reduxCompose = (...fns) => fns.reduce((a, b) => (...args) => b(a(...args)))

const fn = reduxCompose(fn1, fn2);

console.log(fn(1, 2));

//Onion ring model (half and half)

const koaCompose = (middlewares) => {
  return function () {
    return dispatch(0);
    function dispatch(idx) {
      const fn = middlewares[idx];
      if (!fn) {
        return Promise.resolve();
      }
      return Promise.resolve(
        fn(function next() {
          return dispatch(idx + 1)
        })
      )
    }
  }
};

async function func1(next) {
  console.log("func1");
  await next();
  console.log("func1 end");
}
async function func2(next) {
  console.log("func2");
  await delay();
  await next();
  console.log("func2 end");
}
async function func3(next) {
  console.log("func3");
}
async function delay() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve();
    }, 2000);
  })
}
const middlewares = [func1, func2, func3];
const finaFn = koaCompose(middlewares);
finaFn()