• 对多个异步进程的监听，对未来事件进行统一的管理 ```javascript // 等待者模式 / waiter.wait(异步事件1, 异步事件2 ….).done(fn).fail(fn); /

    function Watier() { var dfd = []; // 存放所有的异步事件 var doneArr = []; // 存放成功的回调 var failArr = []; // 存放失败的回调 this.when = function () { // 将类数组arguments转成真数组，赋给dfd dfd = Array.prototype.slice.call(arguments); for (var i = dfd.length - 1; i >= 0; i—) { var d = dfd[i]; // 判断是否为异步函数 if (!d || d.rejected || d.resolved || !(d instanceof Defer)) { // 如果不是，就剔除掉 dfd.splice(i, 1); } } // 以便链式调用 return this; }

    this.done = function () { var args = Array.prototype.slice.call(arguments); doneArr = doneArr.concat(args); // 将args拼进doneArr return this; }

    this.fail = function () { var args = Array.prototype.slice.call(arguments); failArr = failArr.concat(args); // 将args拼进doneArr return this; }

    this.Deferred = function () { return new Defer(); }

    var Defer = function () { // 状态值 this.resolved = false; this.rejected = false; }

    Defer.prototype = { resolve: function () { this.resolved = true; for (var i = 0; i < dfd.length; i++) { if (!dfd[i].resolved) { return; } } // 如果resolve全为true，就不return 出去 // 执行成功的回调函数 _exec(doneArr); }, reject: function () { this.rejected = true; // 执行失败的回调函数 _exec(failArr); } }

    function _exec(arr) { for (var i = 0; i < arr.length; i++) { arr[i] && arri; } }

    }

    var waiter = new Watier(); // 异步事件1 var async1 = function () { var dfd = waiter.Deferred(); setTimeout(function () { console.log(‘async1 done’); dfd.resolve(); }, 1000); return dfd; } //异步事件2 var async2 = function () { var dfd = waiter.Deferred(); setTimeout(function () { console.log(‘async2 done’); dfd.resolve(); }, 2000); return dfd; }

    waiter.when(async1(), async2()).done(function () { console.log(‘success’); }).fail(function () { console.log(‘fail’); }) ```