学步园

特别推荐一下国产的continuation.js，可以将复杂的回调函数展平。

https://github.com/BYVoid/continuation

回调函数的方法，会遇到“回调金字塔”的问题，比如

var err, stats, obj;

setTimeout(function () {

  fs.lstat('/path', function () {

    err = arguments[0];

    stats = arguments[1];

    fs.readdir('/path', function () {

      err = arguments[0];

      obj.files = arguments[1];

    });

  });

}, 1000);

而是用continuation.js就可以这样写

function textProcessing(ret) {

  fs.readFile('somefile.txt', 'utf-8', cont(err, contents));

  if (err) return ret(err);

  contents = contents.toUpperCase();

  fs.readFile('somefile2.txt', 'utf-8', cont(err, contents2));

  if (err) return ret(err);

  contents += contents2;

  fs.writeFile('somefile_concat_uppercase.txt', contents, cont(err));

  if (err) return ret(err);

  ret(null, contents);

}

textProcessing(cont(err, contents));

if (err)

  console.error(err);

事件监听 和发布/订阅 内部实现，原理是一样的。发布/订阅其实也是事件。

引用小铱的发言：

特别推荐一下国产的continuation.js，可以将复杂的回调函数展平。

在 Node.js 的开发中，由于逻辑分层所致，会出现多层回调。易于引发异常处理混乱、闭包过于复杂、代码难以维护等问题。
没有了解过 continuation.js 项目，不过国内
Jeffery Zhao 的项目 Jscex 做了一项有意思的事，就是使用一定的技巧将异步后续步骤的蹩脚语法整理成常见方式。
项目开源地址：https://github.com/JeffreyZhao/jscex

引用陈计节的发言：

在 Node.js 的开发中，由于逻辑分层所致，会出现多层回调。易于引发异常处理混乱、闭包过于复杂、代码难以维护等问题。
没有了解过 continuation.js 项目，不过国内 Jeffery Zhao 的项目 Jscex 做了一项有意思的事，就是使用一定的技巧将异步后续步骤的蹩脚语法整理成常见方式。
项目开源地址：https://github.com/JeffreyZhao/jscex

Jscex现在已经改名为windjs。continuation.js和那个有点相似，都是基于js解析编译的新语法。这种方法虽然很酷不过是在难以让人放心，想不起来还是promise和async.js这种平坦化方式更让人放心一点。

你的配图并不十分准确. 配图里面是同步无并发执行和并发执行的区别. 在JavaScript中, 是无法进行并发执行的. 所有的例子中, 没有任何两个函数或者两段代码是同时执行的.

JavaScript可以通过快速的异步执行切换来模拟并发.

引用lixiong的发言：

你的配图并不十分准确. 配图里面是同步无并发执行和并发执行的区别. 在JavaScript中, 是无法进行并发执行的. 所有的例子中, 没有任何两个函数或者两段代码是同时执行的.

JavaScript可以通过快速的异步执行切换来模拟并发.

配图没错，那是loading资源，确是是并发的。没有并发的是loading之后的callback。

@lixiong：

配图改过了，现在应该准确一点了。

第二种不一定比第三种好或者差,当订阅者到达一定数量时发布中心承受的压力是需要考虑的,全局消息充斥整个程序也见得很好

异步的实现就是用定时器函数改变代码的执行顺序吗？

引用hafeyang的发言：

事件监听 和发布/订阅 内部实现，原理是一样的。发布/订阅其实也是事件。

是的，自定义事件和发布/订阅模式的实现代码一模一样，只不过换了个叫法而已，
《JavaScript程序员参考手册》中就有相关实现的代码。

这篇文章不错，浅显易懂。
实际上用任何语言进行异步处理都要面临相同的问题。原理才是重要的。

发布/订阅模式，还能携带参数和返回值。

var invokeMapping = {}, addInvokeListener = function addInvokeListener (opCode, func) {
(invokeMapping[opCode] = invokeMapping[opCode] || []).push(func);
}, invokeAndWait = function invokeAndWait (opCode, inParam, outParam) {
var listeners = invokeMapping[opCode];
if (listeners) {
listeners.forEach(function (func, index) {
func(inParam, outParam);
});
}
};

//使用方法：
addInvokeListener("hello", function (inParam, outParam) {
alert(inParam);
outParam.result = "success";
});
var ret = {};
invokeAndWait("hello", "hello world", ret);
alert(ret.result); // 输出success

引用小涛的发言：

异步的实现就是用定时器函数改变代码的执行顺序吗？

这只是异步编程，并不是异步执行，
我的理解，javascript应该只有单线程，即使使用了异步编程，在执行层面上还是一步一步执行的，只是会随时有插队的而已

在一个系统中有多个被监听对象时，订阅/发布（观察者模式）确实比监听模式可以集中管理事件处理，事件的触发也可以做成统一模型，程序的结构更加清晰。

不管怎样，观察者模式是监听模式的高级演进版，监听模式是基础。

当需要监听的对象只有一两个时，就没有必要再使用观察者模式了，使用反而增加了系统的复杂度。

根据java jdk的api，监听模式至少要实现两个接口java.util.EventListener和java.util.Event，Event的构造函数里有一个保留事件发生点的钩子（对象），用于在监听对象里回调钩子相关的东西。

我看作者给出的例子都比较简单，这里给出js监听模式的具体实现，仅供大家讨论。

// 事件对象
var Event = function(obj) {
this.obj = obj;
this.getSource = function() {
return this.obj;
}
}

// 监听对象
var F2 = function() {
this.hander = function(event) {
var f2 = event.getSource();
console.log("f2 do something!");
f2.callback();
}
}

// 被监听对象
var F1 = function() {
this.abc = function() {
console.log("f1 do something one!");
// 创建事件对象
var e = new Event(this);
// 发布事件
this.f2.hander(e);
console.log("f1 do something two!");
}

this.on = function(f2) {
this.f2 = f2;
}

this.callback = function() {
console.log("f1 callback invoke!");
}
}

// 主函数
function main() {
var f1 = new F1();
var f2 = new F2();
// 加入监听
f1.on(f2);
f1.abc();
}

// 运行主函数
main();

执行结果是:

f1 do something one!
f2 do something!
f1 callback invoke!
f1 do something two!

我自认为是个经验比较丰富的web开发人员，但是一般情况下用setTimeout就完了。没发现平时的开发中需要这么复杂的异步操作。

其实异步也是用ajax比较多，ajax是你阐述的异步编程中的一种吗。

我来分享一个自己实现的基于事件驱动的单线程异步框架 ：http://www.oschina.net/code/snippet_103999_14286

欢迎拍砖

异步编程的关键是切分任务，并且保证每个任务足够小，执行得足够快。注意，任务能被快速执行是关键中的关键。因为在单线程环境中，只要有一个任务的执行时间稍长，就会导致排在后面的任务被延后。

楼主提到将

f1();
f2();

改成

function f1(callback){
　　　　setTimeout(function () {
　　　　　　// f1的任务代码
　　　　　　callback();
　　　　}, 1000);
　　}

便不会阻塞程序的执行的说法有失偏颇。

因为当执行f1的任务代码时, setTimeout的回调函数：

function(){
// f1的任务代码
　　　callback();
}

会独占当前的执行线程， 直至执行完毕；除非虚拟机（或运行时）允许基于单线程的多任务(函数)抢占式调度(即一个函数执行了一半时被中断，切换到另一个函数中执行)。至少目前nodejs不支持所谓的基于单线程的多任务(函数)抢占式调度

个人认为，不管是上述哪四种方式来实现异步，原理都是一样的。那就是有一个任务队列存放待执行的任务，一个工作线程不断从任务队列中取出任务然后执行；另外还需要一个事件监控线程来捕捉事件并把事件封装成新的任务放入任务队列中。

js 的异步其更多的是为了和界面UI 的分时，所以尽量将任务切割为细粒度的小任务，每次执行完一段小任务只耗费一段足够小的时间然后让出时间给UI，这样UI就不会卡死。如果任务切割得不好，任务段仍然耗时长，那么无论使什么花样，一样卡死UI。因为js的异步实现不了真正并行。

我用IE9 查看你的主页时，里面的链接一个都不能点击；刷新了几次仍然不能点击，换成火狐浏览器 就一切正常了。

@路人：

我都没发觉……这是因为加了雪花特效，现在取消了。

其实还是单线程执行，只是改变了顺序，将执行时间长的代码片断(假设为片断A)给延迟执行了
但...如果某个函数的执行必须基于这个片断A的执行结果，那异步编程也就无意义了

你好阮老师：
1.回调函数，如下这么写难道不是等“f1的任务代码”执行完再执行callback()吗？
这还是同步呀。
f1(f2);
function f1(callback){

　　　　setTimeout(function () {

　　　　　　// f1的任务代码

　　　　　　callback();

　　　　}, 1000);

　　}

to Evan
"同步或异步"要从调用方来判断。

同步函数返回表示工作已完成或发生异常，接下来依赖此结果的的代码被调用方继续执行。

异步函数返回表示工作已发布出去，什么时候完成不知道，接下来的代码无法依赖一个未知的结果，所以要传入一个回调在完成后处理。