可扩展JS架构

ES6的Class继承

参考：
http://es6.ruanyifeng.com/#docs/class-extends

redux-compose

实现了一组函数的从左到右的组合。

function chained(funcs) {
  return function(input){
    return funcs.reduce(function(input, fn){ return fn(input) }, input);
  }
}

function chained(...funcs) {
    if (funcs.length === 0) {
       return arg => arg
    }

    if (funcs.length === 1) {
      return funcs[0]
    }

    return funcs.reduceRight((a, b) => (...args) => a(b(...args)))
}

function chained() {
    for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
        funcs[_key] = arguments[_key];
    }

    if (funcs.length === 0) {
        return function (arg) {
            return arg;
        };
    }

    if (funcs.length === 1) {
        return funcs[0];
    }

    return funcs.reduceRight(function (a, b) {
        return function () {
            return a(b.apply(undefined, arguments));
        };
    });
}



function f1(x){ return x*2 }
function f2(x){ return x+2 }
function f3(x){ return Math.pow(x,2) }

chained(f1,f2,f3)(0) === 4

参考：
https://www.jianshu.com/p/c9dfe57c4a4e

不足：
只能组合同步函数，不能组合异步函数。

koa-compose

中间件模式

洋葱架构

适用于请求参数验证函数的封装和组合。
适用于对象的一层层装饰处理。

解决了react-compose无法异步函数组合的问题。

const compose = require('..')

function wait (ms) {
  return new Promise((resolve) => setTimeout(resolve, ms || 1))
}

const arr = []
const stack = []

stack.push(async (context, next) => {
    arr.push(1)
    await wait(1)
    await next()
    await wait(1)
    arr.push(6)
})

stack.push(async (context, next) => {
    arr.push(2)
    await wait(1)
    await next()
    await wait(1)
    arr.push(5)
})

stack.push(async (context, next) => {
    arr.push(3)
    await wait(1)
    await next()
    await wait(1)
    arr.push(4)
})

await compose(stack)({})
arr === [1, 2, 3, 4, 5, 6]
// => true

参考：
github：https://github.com/koajs/compose
以及它的test用例

node的事件驱动机制的基础EventEmitter

EventEmitter是一个观察者模式的实现。
观察者模式：
建立被观察者和观察者的一对多关系。
当被观察者发生改变（事件），所有依赖它的观察者得到通知。

代码层面：
函数调用位置不受限。
函数调用可批量。

不足：
观察者只能串行执行。
依赖同一个被观察者的观察者之间无法传递消息。

参考
https://github.com/forthealllight/blog/issues/21

webpack插件体系tapable

将观察者比作一个插件。
在tapable中，
SyncHook 为串行同步执行，不关心事件处理函数的返回值，在触发事件之后，会按照事件注册的先后顺序执行所有的事件处理函数。
SyncBailHook 同样为串行同步执行，如果事件处理函数执行时有一个返回值不为空（即返回值为 undefined），则跳过剩下未执行的事件处理函数（如类的名字，意义在于保险）。
SyncWaterfallHook 为串行同步执行，上一个事件处理函数的返回值作为参数传递给下一个事件处理函数，依次类推，正因如此，只有第一个事件处理函数的参数可以通过 call 传递，而 call 的返回值为最SyncLoopHook 为串行同步执行，事件处理函数返回 true 表示继续循环，即循环执行当前事件处理函数，返回 undefined 表示结束循环。SyncLoopHook 与 SyncBailHook 的循环不同，SyncBailHook 只决定是否继续向下执行后面的事件处理函数，而 SyncLoopHook 的循环是指循环执行每一个事件处理函数，直到返回 undefined 为止，才会继续向下执行其他事件处理函数，执行机制同理。

以上的插件同步执行机制同样适用于异步执行。
这个机制解决了EventEmitter的不足。

参考：
https://juejin.im/post/5b92caa16fb9a05cfc54b46f

Akka架构

待续...