[WinJS] Promise 用法

初学 WinJS, 可能对 Promise 的用法不大清楚，本文简要说明一下 WinJS中 promise 的基本用法。

主要参考自：http://try.buildwinjs.com/#promises

Promise是 WinJS中实现异步模式编程的实现形式，

它其实更多的是一种规范，用来规范和简化 javascript 中的异步编程。

在promise被提出来之前，javascript中的异步编程通常是直接使用回调来完成的。

 

var  getParentList =  function  (getParentListCallback) {
    // do get parent list data cost about 1 or more seconds
    // ...
    var  parentList = XXX;
    // when get the data sucessfully, call the callback
    getParentListCallback(parentList);
}

 

使用的时候，就是这样的：

getParentList( function  getParentListCallback(parentList) {
    // get children data according to the parentList data
    for  ( var  i = 0; i < parentList.length; i++) {
        //
        getChildrenList(parentList[i]);
    }
});

一个函数执行可能会花费比较长的时间，逻辑上不需要等待这个函数返回，就可以执行后面的代码，

这是非常常见的场景，使用上面回调函数的方法，完全可以解决问题。

但如果场景更复杂一些，或者需要考虑更多的情况，例如异常处理，根据不同的返回值，调用不同的回调函数，

就会发现这种写法非常的ugly。如果有三层回调的话，代码可能是这样的：

getParentList(
    // success callback
    function getParentListCallback(parentList) {
        // get children data according to the parentList data
        for  (var i =  0 ; i < parentList.length; i++) {
            //
            getChildrenList(parentList[i],
                // success callback
                function getChildrenListCallback(childrenList) {
                    for  (var j =  0 ; j < childrenList.length; j++) {
                        getChildDetail(childrenList[j],
                            // success callback
                            function getChildDetailCallback(detailInfo) {
                            },
                            // error callback
                            function errorCallback() {
                            })
                    }
                },
                // error callback
                function errorCallback() {
                });
        }
    },
    // error callback
    function errorCallback() {
        // Do something to handle the error
    }
);

感觉如何？同一逻辑的的suc和error隔着很多其它的代码，代码的嵌套层次还特别深，

这还是在大部分逻辑没有展开的情况下看到的样子呢，如果在实际项目中使用，逻辑全部展开，最终的代码估计自己写完都不想再看第二遍。

 

OK，promise来了，promise有个 Promises/A+ 实现规范，有兴趣的可以抽时间看下。

现在，我们直接看下使用 promise 后的代码：

getParentList()
    .then(
        function  (parentList) {
            var  promiseArray = [];
            for  ( var  i = 0; i < parentList.length; i++) {
                promiseArray.push(getChildrenList(parentList[i]));
            }
            return  promiseArray.join();
        },
        function  error() {
        })
    .then(
        function  (chilrenList) {
            var  promiseArray = [];
            for  ( var  i = 0; i < chilrenList.length; i++) {
                promiseArray.push(getChildDetail(chilrenList[i]));
            }
            return  promiseArray.join();
        },
        function  error() {
        })
    .done(
        function  (detailInfo) {

        },
        function  error() {
        });

直观上看，promise让原来的代码嵌套层次少了，更加扁平可读了，而且逻辑功能上的suc和err处理放到一起了。

但 promise 并不仅仅这么简单。

个人理解，promise把原来的函数之间的嵌套调用，演化成了链式的关系。

.then ... .then 做为链中的一环，直到 .done，表示到了链的最后一环。（.done仅仅表明不再向后链接了，并不强制要求使用。）

所以说， promise其实本质上是一种规范，或者说是一种编程模式。

对于这个模式，各基于 javascript 的开发工具都有自己的实现，像 WinJS, NodeJs等。

WinJS的的 promise 是如何使用的呢？

首先，创建一个 promise:

项目开发中，对于比较耗时的操作，通常通过如下形式创建 promise 来执行：

// Do an add asynchronously (via setTimeout)
function  asyncAdd(num1, num2) {
    return  new  WinJS.Promise( function  (complete) {
        setTimeout( function  () {
            var  sum = num1 + num2;
            // this promise is completed when the complete() function is called which also
            // returns the value (result) of the promise.
            complete(sum);
        }, 1000);
    });
}

这样，使用时，即可如下使用：

asyncAdd(1, 2).
    then( function  (v) {
       // 此处，v === 3
    })

然后，我们可能已经有了一个同步执行的函数，如何让它以promise的形式来调用它呢？

如下进行：

// add two numbers together synchronously
function  nonPromiseAdd(num1, num2) {
    return  num1 + num2;
}

// wrap the regular non-synchronous method in Promise.as() to treat it as a promise
WinJS.Promise.as(nonPromiseAdd(3, 4)).
then( function  (v){
    // 此处，v === 7
});

好，接下来的功能，就是 promise的强大之外了。

1. promise之 cancel。 异步操作时，通常会遇到上下文，或者说场景，context已经失效了，异步操作还没有完成，或者异步操作完成了，但context失效，已经没有意义了。相信大家都有自己的解决方法。使用 promise的话，很简单，直接把 promise cancel掉就行了。

   var  loadImagePromise = WinJS.Promise.as(loadImage());
   
   function  unload() {
       loadImagePromise.cancel();
   }

   有一点需要注意的是，promise执行过程中被cancel掉的话，promise.then会被调用，这时候需要判断 promise的状态，promise._state.name 的值，可能是success，或者是canceled。

2. promise之join。多个异步操作同时执行的话，就会有异步操作之前协调的问题。promise.join提供一个promise的数组做参数，表示这个数组中的所有promise都执行完成后，promise.join才会视为执行完成，即 promise.join(promiseArray).then(){}中的then才会被执行。

   var  p = [];
   var  index = 0;
   // create a promise that completes in 2000ms, then add it to the promise array
   p[index++] = WinJS.Promise.timeout(2000).
   then( function  () {
       output( "<br/> First promise is fullfilled after 2 seconds" );
   }
   );
   // create a promise that completes in 3000ms, then add it to the promise array
   p[index++] = WinJS.Promise.timeout(3000).
   then( function  () {
       output( "<br/> Second promise is fullfilled after 3 seconds" );
   }
   );
   // pass the promise array to Promise.join() to create a promise that will not be completed until all
   // promises have been completed.
   WinJS.Promise.join(p).
   then( function  () {
       output( "<br/> Calling join will ensure this function will not be called until the both promises have been completed." );
   });

3. promise之any。同上类似的场景，如果要求 promise数组中，任意一个promise执行完成即可的话，就使用promise.any。
   
   

OK，上面仅是 WinJS支持的 promise功能。由于 javascript的开源特性，很多其它基于js的工具包中的 promise，是可以直接拿来使用的（在遵守开源许可的情况下，把代码引入到我们的项目中即可）。所以我们可以非常方便的使用诸如 NodeJS里面的promise功能。为什么要使用他们的呢，他山之石，可以攻玉，比如我们项目中常用的 Async.js （https://github.com/caolan/async），是为NodeJS设计使用的，但它没有第三方依赖，实现代码只有一个 js 文件，可以直接引用，它的promise提供以下常用功能（仅列举常用，详细请参数 Anync.js的 github 网站）：

1. async.each。async不需要手动创建promise，它支持直接以数组为参数。async.each的函数原型如下：

   each(array, functionForEachItem, errorCallback)

   针对每个 array里面的item, 都会执行一次functionForEachItem， 使用起来是这样的：

   // assuming openFiles is an array of file names
   async.each(openFiles,  function ( file, callback) {
     // Perform operation on file here.
     console.log( 'Processing file '  + file);
   
     if ( file.length > 32 ) {
       console.log( 'This file name is too long' );
       callback( 'File name too long' );
     }  else  {
       // Do work to process file here
       console.log( 'File processed' );
       callback();
     }
   },  function (err){
       // if any of the file processing produced an error, err would equal that error
       if ( err ) {
         // One of the iterations produced an error.
         // All processing will now stop.
         console.log( 'A file failed to process' );
       }  else  {
         console.log( 'All files have been processed successfully' );
       }
   });

2. async.eachSeries. 同each类似，但是eachSeries可以保证针对每个 array里面的item, 执行functionForEachItem是顺执行，且只有前面的item执行完成，才会执行后面的item。
   
   async提供很多其它方便的功能，请大家https://github.com/caolan/async 了解更多，仔细查看，你会有一种只有想不到，没有做不到的感觉。