一步一步实现基于Task的Promise库（四）无参数的WorkItem

接着上一篇我直接给出代码，现在支持了new Task(), then(), all(), any() 这些不传参的调用方式。

 (function(){
     var isFunction = function (target) {
         return target instanceof Function;
     };
     var isArray = function (target) {
         return target instanceof Array;
     };

     //自定义事件管理(代码摘抄自http://www.cnblogs.com/dolphinX/p/3254017.html)
     var EventManager = function(){
         this.handlers = {};
     };
     EventManager.prototype = {
         constructor: EventManager,
         addHandler: function(type, handler){
             if(typeof this.handlers[type] == 'undefined'){
                 this.handlers[type] = new Array();
             }
             this.handlers[type].push(handler);
         },
         removeHandler: function(type, handler){
             if(this.handlers[type] instanceof Array){
                 var handlers = this.handlers[type];
                 for(var i=0; i<handlers.length; i++){
                     if(handler[i] == handler){
                         handlers.splice(i, 1);
                         break;
                     }
                 }
             }
         },
         trigger: function(type, event){
             /*
             if(!event.target){
                 event.target = this;
             }
             */
             if(this.handlers[type] instanceof Array){
                 var handlers = this.handlers[type];
                 for(var i=0; i<handlers.length; i++){
                     handlers[i](event);
                 }
             }
         }
     };

     var WorkItem = function(arrayArgs){
         var _subItems = [];
         var _checkFunc = function(args){
             if(isFunction(args[0])){
                 if(args.length == 2 && isArray(args[1])){
                     _subItems.push({'isFunc': true, 'func': args[0], 'args': args[1]});
                 }
                 else{
                     _subItems.push({'isFunc': true, 'func': args[0], 'args': args.slice(1)});
                 }
                 return true;
             }
             return false;
         };
         var _checkTask = function(task){
             if(task instanceof Task){
                 _subItems.push({'isFunc': false, 'task': task});
             }
         };
         if(!_checkFunc(arrayArgs)){
                 for(var i=0; i<arrayArgs.length; i++){
                     if(!_checkFunc(arrayArgs[i])){
                         _checkTask(arrayArgs[i]);
                     }
                 }
             }
         var _startSubItem = function(subItemIndex, context){
             var subItem = _subItems[subItemIndex];
             if(subItem.isFunc){
                 var workItemCxt = context.getWorkItemContext(subItemIndex);
                 subItem.func.apply(workItemCxt, subItem.args);
             }
             else{
                 if(subItem.task.getStatus() == TaskStatus.finished){
                     context.end(subItem.task.getOutput(), subItemIndex)
                 }
                 else{
                     subItem.task.finished(function(output){
                         context.end(output, subItemIndex);
                     });
                     subItem.task.start(context.inputParams);
                 }
             }
         };

         this.condition = "";
         this.start = function(context){
             context.setItemsCount(_subItems.length);
             for(var i=0; i<_subItems.length; i++){
                 _startSubItem(i, context);
             }
         }
     };
     //无参数的WorkItem,用于对前一个WorkItem的条件判断,例如all();
     //ConditionWorkItem和WorkItem可以看做实现了一个接口{condition:string,start:function}
     var ConditionWorkItem = function(){
         this.condition = "";
         this.start = function(context){
             context.triggerEnd();
         }
     };

     var Context = function(endCallback, inputParams){
         var _this = this;
         var _rawOutputParams = [];
         var _itemCount;
         //如果无需Test,_isNonTest就等于true(当调用triggerEnd方法时,就应该无需Test,直接下一个WorkItem)
         var _isNonTest = false;
         var _condition = {
             then: function(){
                 _this.outputParams = _rawOutputParams[0].value;
                 return true;
             },
             all: function(){
                 _this.outputParams = [];
                 for(var i=0; i<_itemCount; i++){
                     if(_rawOutputParams[i]){
                         _this.outputParams[i] = _rawOutputParams[i].value;
                     }
                     else{
                         return false;
                     }
                 }
                 return true;
             },
             any: function(){
                 for(var i=0; i<_itemCount; i++){
                     if(_rawOutputParams[i]){
                         _this.outputParams = _rawOutputParams[i].value;
                         return true;
                     }
                 }
                 return false;
             }
         };

         this.inputParams = inputParams;
         this.outputParams = null;
         this.setItemsCount = function(itemCount){
             _itemCount = itemCount;
         };
         this.testCondition = function(key){
             //如果无需Test直接返回true,否则才用Test
             return _isNonTest || _condition[key]();
         };
         this.end = function(output, index){
             _rawOutputParams[index] = {
                 value: output
             };
             if(endCallback){
                 endCallback(output);
             }
         };
         this.getWorkItemContext = function(index){
             return {
                 param: _this.inputParams,
                 end: function(output){
                     _this.end(output, index);
                 }
             };
         };
         //手动触发EndCallback,(这个上下文设置成无需Test,this.outputParams就设置成this.inputParams,这样参数就可以传递到下一个WorkItem了)
         this.triggerEnd = function(){
             _isNonTest = true;
             _this.outputParams = _this.inputParams;
             if(endCallback){
                 endCallback(_this.outputParams);
             }
         };
     };

     var TaskStatus = {
         //未开始
         pending: 0,
         //正在进行
         doing: 1,
         //已完成
         finished: 2
     };

     window.Task = function(){
         var _status = TaskStatus.pending;
         var _wItemQueue = [], _currentItem, _currentContext;
         var _eventManager = new EventManager();
         var _output;
         var _initWorkItem = function(args){
             var item;
             if(args.length == 0){
                 item = new ConditionWorkItem();
             }
             else{
                 var arrayArgs = [];
                 for(var i=0; i<args.length; i++){
                     arrayArgs[i] = args[i];
                 }
                 item = new WorkItem(arrayArgs);
             }
             _wItemQueue.push(item);
             return item;
         };
         var _setItemCondition = function(item, condition){
             if(condition){
                 item.condition = condition;
             }
         };
         var _tryDoNextItem = function(output){
             var next = _getCurNextItem();
             if(next){
                 if(_currentContext.testCondition(next.condition)){
                     _currentItem = next;
                     _doCurrentItem();
                 }
             }
             else{
                 _status = TaskStatus.finished;
                 _output = output;
                 _eventManager.trigger("finish", output);
             }
         };
         var _doCurrentItem = function(contextParam){
             if(contextParam) {
                 _currentContext = new Context(_tryDoNextItem, contextParam);
             }
             else{
                 if(_currentContext){
                     _currentContext = new Context(_tryDoNextItem, _currentContext.outputParams);
                 }
                 else{
                     _currentContext = new Context(_tryDoNextItem);
                 }
             }
             _currentItem.start(_currentContext);
         };
         var _getCurNextItem = function(){
             var i=0;
             for(; i<_wItemQueue.length; i++){
                 if(_currentItem == _wItemQueue[i]){
                     break;
                 }
             }
             return _wItemQueue[i + 1];
         };
         _currentItem = _initWorkItem(arguments);

         this.getStatus = function(){
             return _status;
         };
         this.getOutput = function(){
             return _output;
         };
         this.finished = function(callback){
             if(callback){
                 _eventManager.addHandler("finish", callback);
             }
         };
         this.start = function(contextParam){
             if(_status == TaskStatus.pending){
                 _status = TaskStatus.doing;
                 _doCurrentItem(contextParam);
             }
             return this;
         };
         this.then = function(){
             var workItem = _initWorkItem(arguments);
             _setItemCondition(workItem, 'then');
             return this;
         };
         this.all = function(){
             //这个arguments现在可能是空的了!
             var workItem = _initWorkItem(arguments);
             _setItemCondition(workItem, 'all');
             return this;
         };
         this.any = function(){
             var workItem = _initWorkItem(arguments);
             _setItemCondition(workItem, 'any');
             return this;
         };
     };
 })();

var task = new Task([readFile, "aa.txt"], [readFile, "bb.txt"]).all(writeBack, "cc.txt").start();

现在上面的调用形式同样可以用下面的代码代替：

 //测试1
 var taskExp_1 = new Task([readFile, "aa.txt"], [readFile, "bb.txt"]).all().then(writeBack, "cc.txt").start();
 //测试2
 var taskExp_2 = new Task([readFile, "aa.txt"], [readFile, "bb.txt"]).all();
 var taskExp_3 = new Task(taskExp_2).then(writeBack, "cc.txt").start();
 //测试3
 var taskExp_4 = new Task([readFile, "aa.txt"], [readFile, "bb.txt"]).all();
 var taskExp_5 = new Task().then(taskExp_4).then(writeBack, "cc.txt").start();

在下一篇，我们再来实现waitFor方法。