这是一个很典型的connect中间件方式

function connect (/*f1, f2, ...*/) {
    var middlewares = [];
    for (var i = 0, len = arguments.length; i < len; i++) {
        if(typeof arguments[i] === 'function') {
            middlewares.push(arguments[i]);
        }
    }
    return function (req, res) {
        var self = this,
            args = arguments,
            i = 0;
        /*
        middlewares.forEach(function (middleware) {
            middleware.apply(self, args);
        });
        */

        function next () { 
            var middleware = middlewares[i],
                nextArgs;
            if(typeof middleware === 'function') {
                nextArgs = Array.prototype.slice.call(arguments);
                nextArgs.push(next);
                i++;
                middleware.apply(self, nextArgs);
            }
        }
        next.apply(self, args);
    };
}

@ravenwang

这就是违反了抽象、职责单一的原则。

一个函数，应该是完成工作的。看一下next方式的函数，都做了些什么:

function print () {
    // ...
   if (...) {...}
   else { next() }
}

有许多时候，为了能实现跳转，你不得不在函数中写逻辑。 而这些逻辑恰恰是摧毁函数可用性的源头。 这很像在写goto，而我们知道c语言是严禁goto的。

function print () {
    // ...
   if (...) {...}
   else { goto:log; }
}

print()的任务就是打印，不应该包含判断输出是否正确，下一个目标是不是A。

当你的代码容量膨胀到一定程度，你想在next这种组件上扩充的时候，你就要非常小心了。而且，当你拿到一些next代码的时候，你要理解作者的意图，恐怕是非常困难的。

@ravenwang

connect只不过是在模型上用了些函数式的东西，而不是完全的OO组合模式，但是他们的本质是一样的。而且connect的函数式风格并不纯粹，他只在组织函数栈上使用了函数式。

@ravenwang

区别大了.

作为print(callback)这个函数，是原子级别的抽象。 对于next, 你将需要自己建立栈保存函数组，

function a (next) { print(next); } 请问你能告诉我控制器a打算干什么吗？

res.on('a', function () { prtint(emit('b')); })

我们把内容放大一下:

exports.index = c([
    function (next) { parse(next); },
    function (next) { print(next); },
    function (next) { logger(next); },
]);

或者

exports.index = c([
    parse(next),
    print(next),
    logger(next),
]);

exports.index = function (req, res) {
    res.on('parse', parse(emit(res, 'print')));
    res.on('print', function () { console.log('Hellow world!') });
    res.on('print', function () { ... test(...); ... });
    res.on('logger', logger(emit(res, '...')));
    ...
    res.on('print', print(emit(res, 'logger')));
};

哪一种具备可读和易分发，我想一目了然

@ravenwang

使用数据结构和算法来表示逻辑，而不是用对象。 使用独立的函数来封装逻辑，而不是用对象。

function Tree () { … } Tree.prototype.each = function (f) {}; Tree.prototype.next = function (f) {};

function each (tree, f) function next (tree, f)

下面的2个函数可以脱离关系，只要tree满足需要的结构。 上面的两个方法则必须要绑定在一起。

要扩展tree操作的时候，对于Tree，有时候需要考虑是否进行子对象的构建，以免Tree做了过多的事情。 而对于函数来讲，大家都是相互独立的，无需为其他外部因素考虑更多。

@ravenwang

connect最大的问题就是抽象，这个语法糖并没有很好的解决模式面临的问题。