Promise异步处理

Promise异步处理

Node中的异步操作无法指定代码执行顺序，例如fs模块的readFile方法。
可以使用回调函数嵌套解决这个问题，但使用回调函数时一旦异步方法使用较多就会形成回调地狱，影响代码整洁增加维护成本。

为了解决上述编码方式带来的问题，ES6中新增了一个API–Promise
我们可以将Promise看作是一个大的容器，容器中存放了一个异步任务，默认该异步认为分为三种状态，即Pending(正在执行)，Pending结果只能有一种状态，要么成功(Resolved)，要么失败(Reject)。

```javascript
var fs = require('fs');
console.log(1);
//创建Promise容器--Promise容器一旦创建，就立即执行里面的代码
var promise = new Promise(function(){
    console.log(2);
    fs.readFile('./data/a.txt','utf8',function(err,data){
        console.log(3);
        if(err){
            console.log(err);
        }else{
            console.log(data);
        }
    });
});
console.log(4);

Promise本身不是异步操作，内部的readFile才是异步方法，因此整个执行顺序为1-2-4-3-aaa。这里只是对Promise容器的特性进行一个说明

语法标准:

var fs = require('fs');
//创建Promise容器--Promise容器一旦创建，就立即执行里面的代码
var promise = new Promise(function (resolve, reject) {
    fs.readFile('./data/a.txt', 'utf8', function (err, data) {
        if (err) {
            //Promise容器改为Reject
            reject(err);
        } else {
            //Promise容器改为Resolve
            resolve(data);
        }
    });
});
//当promise执行完了，然后做指定操作
promise.then(function (data) {
    //then方法接收的第一个函数就是容器中的resolve函数
    console.log(data);
}, function (err) {
    //then方法接收的第二个函数就是容器中的reject函数
    console.log(err);
});

解决嵌套问题

链式调用异步编程

var fs = require('fs');
var pro1 = new Promise(function(resolve,reject){
    fs.readFile('./data/a.txt','utf8',function(err,data){
        if(err) reject(err);
        else resolve(data);
    });
});
var pro2 = new Promise(function(resolve,reject){
    fs.readFile('./data/b.txt','utf8',function(err,data){
        if(err) reject(err);
        else resolve(data);
    });
});
var pro3 = new Promise(function(resolve,reject){
    fs.readFile('./data/c.txt','utf8',function(err,data){
        if(err) reject(err);
        else resolve(data);
    });
});

pro1
.then((data)=>{
    console.log(data);
    return pro2;
},(err)=>console.log(err))
.then((data)=>{
    console.log(data);
    return pro3;
})
.then((data)=>console.log(data))

对以上进行封装

var fs = require('fs');

function pReadFile(filepath){
    return new Promise((resolve,reject)=>{
        fs.readFile(filepath,'utf8',(err,data)=>{
            if(err) reject(err);
            else resolve(data);
        })
    })
};
pReadFile('./data/a.txt')
    .then((data)=>{
        console.log(data);
        return pReadFile('./data/b.txt')
    })
    .then((data)=>{
        console.log(data);
        return pReadFile('./data/c.txt');
    })
    .then((data)=>{
        console.log(data);
    })

Promise.all和Promise.race

Promise.all

Promise.all可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一个结果数组，而失败的时候则返回最先被reject失败状态的值。

var fs = require('fs');

function pReadFile(filepath) {
    return new Promise((resolve, reject) => {
        fs.readFile(filepath, 'utf8', (err, data) => {
            if (err) reject(err);
            else resolve(data);
        })
    })
}

Promise.all([pReadFile('./data/a.txt'),pReadFile('./data/b.txt'),pReadFile('./data/c.txt')])
.then((arr)=>{
    console.log(arr);
},(err)=>console.log(err));

结果为:
['aaa','bbb','ccc']

Promise.all获得的成功结果的数组里面的数据顺序和Promise.all接收到的数组顺序是一致的，即pro1的输入顺序如果在前，即便pro1的结果获取的比pro2要晚，但结果数组中还是pro1在前。在请求数据的过程中，偶尔会遇到发送多个请求并根据请求顺序获取和使用数据的场景，使用Promise.all可以解决这个问题。

Promise.race

var p = Promise.race([pro1,pro2,pro3]);

只要pro1、pro2、pro3中有个一实例率先改变状态，p的状态就随着改变。那个率先改变的Promise实例的返回值就是传递给p的回调函数。