Promise的使用及原理（三）：Promise上的方法及promisify

5、Promise的all方法

• Promise的all方法提供了并行执行异步操作的能力，并且在所有异步操作执行完后才执行回调
• 三个异步操作的并行执行的，等到它们都执行完后才会进到then里面，三个异步操作的返回数据会放进一个数组中传给then
• 首先我们先来了解下其使用

    function runAsync1(){
        return new Promise(function(resolve,reject){
            setTimeout(function(){
                resolve('随便什么数据1');
            },0);
        })
    }
    function runAsync2(){
        return new Promise(function(resolve,reject){
            setTimeout(function(){
                resolve('随便什么数据2');
            },0);
        })
    }
    function runAsync3(){
        return new Promise(function(resolve,reject){
            setTimeout(function(){
                resolve('随便什么数据3');
            },0);
        })
    }
    
    
    Promise
        .all([runAsync1(), runAsync2(), runAsync3()])
        .then(function(results){
            console.log(results);
        },err => {
             console.log("err-------------"+err);
        });

    // 输出为：
    // [ '随便什么数据1', '随便什么数据2', '随便什么数据3' ]

• 如果其中执行了reject，那么会进all方法执行后then中的reject，Promise.all如下：

    Promise.all = function(values){
        return new Promise((resolve, reject) => {
            if (!Array.isArray(values)) {
                return reject(new TypeError('arguments must be an array'));
            }
            let arr = [];
            let index = 0;
            function processData(key, value) {
                index++;
                arr[key] = value;
                if (index === values.length){
                    resolve(arr);
                }
            }
            values.forEach((value, index) => {
                if (value && value.then && typeof value.then === "function"){
                    value.then(y => {
                        processData(index, y);
                    }, reject);
                }else {
                    processData(index, value);
                }
            })
        })
    };

6、Promise的race方法

• all方法的效果实际上是「谁跑的慢，以谁为准执行回调」，那么相对的就有另一个方法「谁跑的快，以谁为准执行回调」，这就是race方法；race的实现如下：

    Promise.race = function(values){
        return new Promise((resolve, reject) => {
            if (!Array.isArray(values)) {
                return reject(new TypeError('arguments must be an array'));
            }
            values.forEach((value, index) => {
                if (value && value.then && typeof value.then === "function"){
                    value.then(resolve, reject);
                }else {
                    resolve(value);
                }
            })
        })
    };

7、Promise的resolve和reject方法

• 正常情况下，我们写一个promise，都是new一个Promise，在里面执行其成功还是失败，如果我们希望直接得到一个成功或者失败的Promise，那么可以使用Promise的resolve和reject方法，使用如下；

// 进入成功回调
    Promise.resolve().then(data => {
        console.log("OK");
    }).catch(err => {
        console.log("err");
    });
    // 进入catch
    Promise.reject().then(data => {
        console.log("OK");
    }).catch(err => {
        console.log("err");
    });

8、Promisify

• 随着Promise的广泛使用，我们习惯于将一般的使用回调的函数，转为返回Promise对象的函数，以供书写同步代码；
• 我们知道，在node中，大部分方法都是异步的方法，如果每一个方法都写一个转为返回Promise对象的函数，那么相同的逻辑其实在大量存在的，此时，我们可以使用bluebird库中promisify来返回一个Promise对象的函数，使用如下：

    let bluebird = require("bluebird");
    let fs = require("fs");
    let readFile = bluebird.promisify(fs.readFile);
    
    Promise.all([readFile("./age.txt","utf8"),readFile("./name.txt","utf8")]).then(data => {
        console.log(data);
    }).catch(err => {
        console.log("err");
    });

• 其简单实现如下：

    function promisify(fn){ // node中util模块自带的功能
        return function (...args) {
            return new Promise((resolve, reject) => {
                fn(...args,(err, data) => {
                    if (err) reject(err);
                    resolve(data);
                });
            })
        }
    }

以上就完成了promise的用法及原理，以及promisify的使用及原理，如有错误，请留言更正，谢谢！