一、回调地狱

  首先我们知道在JS中异步执行机制具有非常重要的地位，而Node.js中readFile就是一个异步操作，这里我们先进行一个小实验，分别读取data文件夹下a、b、c三个文件并输出：

var fs = require('fs');

fs.readFile('./data/a.txt','utf8',function(err,data){
    if(err) throw err;
    console.log(data);
});
fs.readFile('./data/b.txt','utf8',function(err,data){
    if(err) throw err;
    console.log(data);
});
fs.readFile('./data/c.txt','utf8',function(err,data){
    if(err) throw err;
    console.log(data);
});

执行结果

  从上图的执行结果中可以看到，异步操作的执行结果并不是按照代码的顺序执行，而如果我们想保证这三个异步操作的顺序，就可以使用回调嵌套的方式：

var fs = require('fs');

fs.readFile('./data/a.txt','utf8',function(err,data){
    if(err) throw err;
    console.log(data);
    fs.readFile('./data/b.txt','utf8',function(err,data){
      if(err) throw err;
      console.log(data);
      fs.readFile('./data/c.txt','utf8',function(err,data){
      if(err) throw err;
      console.log(data);
     });  
  });
});

回调嵌套执行结果

  目前只是执行三个函数，还不是很复杂，如果出现了d、e、f...时，嵌套过深，代码会非常的难看，同时不利于维护，而这种金字塔型的代码就可以称之为回调地狱。

二、Promise基本语法

  为了解决上述编码方式带来的问题，ES6中新增了一个API--Promise，以下是示意图： image.png

  我们可以将Promise看作是一个大的容器，容器中存放了一个异步任务，默认该异步认为分为三种状态，即Pending(正在执行)，Pending结果只能有一种状态，要么成功(Resolved)，要么失败(Reject)。接下来就是代码实现：

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执行结果

  这里值得注意的地方在于，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);
});

三、Promise如何解决嵌套问题

  链式调用异步编程

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

3.1 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));

执行结果

  需要特别注意的是，Promise.all获得的成功结果的数组里面的数据顺序和Promise.all接收到的数组顺序是一致的，即pro1的输入顺序如果在前，即便pro1的结果获取的比pro2要晚，但结果数组中还是pro1在前。这带来了一个绝大的好处：在前端开发请求数据的过程中，偶尔会遇到发送多个请求并根据请求顺序获取和使用数据的场景，使用Promise.all毫无疑问可以解决这个问题。

3.2 Promise.race的使用

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

  上述代码中，只要pro1、pro2、pro3中有个一实例率先改变状态，p的状态就随着改变。那个率先改变的Promise实例的返回值就是传递给p的回调函数。目前我还想不到在实际运用中有什么场景能用到，遇到后补充。