1.Promise的概念

所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一个异步操作），并且这个事件提供统一的 API，可供进一步处理。

​ promise 有三个状态：

1
2
3
1.正在进行中   Pending
2.成功          Resolved  当在promise中显示调用resolve()的时候，此时promise的状态被改变，对应promise后的then的第一个function就会执行了
3.失败          Rejected  当在promise中显示调用reject()的时候，此时promise的状态被改变，对应promise后的then的第二个function就会执行了

2.Promise的作用

​ Promise的出现主要是解决地狱回调的问题，比如你需要结果需要请求很多个接口，这些接口的参数需要另外那个的接口返回的数据作为依赖，这样就需要我们一层嵌套一层，但是有了Promise 我们就无需嵌套。

​ 注意：Promise本身不是异步的(Promise中的function会立马执行)，只不过Promise中可以有异步任务，当异步任务的执行有结果之后，我们通过resolve和reject来改变promise的状态，当promise的状态改变之后此时promise的then就会执行了

3.使用Promise读取文件举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const fs = require('fs');
console.log("1")   //----1
//promise中的function是立马执行的
var promise = new Promise(function(resolve,reject){
    console.log("2")   //----2
    //读取文件操作
fs.readFile("./aa.json",function(err,data){
    console.log("3");
    //读取文件失败
    if(err){
        //当文件读取失败之后，会自动执行promise的then的第二个function
        reject("错了,文件不存在");
        return;
    }
    //当文件读取成功之后，会自动执行promise的then的第一个function
    resolve(data.toString())
})
})
promise.then(function(msg){
    console.log("4",msg);
},function(msg){
    console.log("6",msg);
})
console.log("5")

4.Promise链

1
2
3
4
5
6
promise.then(function(){
   return new Promise(...)
 }).then(function(){
   return new Promise(..)
 }).then(function(){
 })

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
console.log(1)   
new Promise(function(resolve,reject){
    console.log(2)  
    setTimeout(() => {
        resolve();
    }, 2000);
}).then(function(){
    return new Promise(function(resolve,reject){
        console.log(3)
        setTimeout(() => {
            resolve()
        }, 2000);
    });

}).then(function(msg){
    console.log(4,msg)
},function(msg){
    console.log(6,msg)
})
console.log(5)

当一个Promise完成（fulfilled）或者失败（rejected），返回函数将被异步调用（由当前的线程循环来调度完成）。具体的返回值依据以下规则返回：
• 如果then中的回调函数返回一个值，那么then返回的Promise将会成为接受状态，并且将返回的值作为接受状态的回调函数的参数值。
• 如果then中的回调函数没有返回值，那么then返回的Promise将会成为接受状态，并且该接受状态的回调函数的参数值为 undefined。
• 如果then中的回调函数抛出一个错误，那么then返回的Promise将会成为拒绝状态，并且将抛出的错误作为拒绝状态的回调函数的参数值。
• 如果then中的回调函数返回一个已经是接受状态的Promise，那么then返回的Promise也会成为接受状态，并且将那个Promise的接受状态的回调函数的参数值作为该被返回的Promise的接受状态回调函数的参数值。
• 如果then中的回调函数返回一个已经是拒绝状态的Promise，那么then返回的Promise也会成为拒绝状态，并且将那个Promise的拒绝状态的回调函数的参数值作为该被返回的Promise的拒绝状态回调函数的参数值。
• 如果then中的回调函数返回一个未定状态（pending）的Promise，那么then返回Promise的状态也是未定的，并且它的终态与那个Promise的终态相同；同时，它变为终态时调用的回调函数参数与那个Promise变为终态时的回调函数的参数是相同的。

5.Promise的异常处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
const fs = require('fs');
function myread(path){
    return new Promise(function(resolve,reject){
        fs.readFile(path,function(err,data){
            if(err){
                reject(err);
                return;
            }
            resolve(data.toString())
        })
    })
}

myread('./a.json')
.then(function(msg){
    console.log(msg);
    return myread('./b.json')
})
.then(function(msg){
    console.log(msg);
    return myread('./c.json')
})
.then(function(msg){
    return myread('./d.json')
})
.then(function(msg){
    console.log(msg,"aaa")
},function(err){
    console.log(err,"ddd");
    throw new Error(err);
})
.catch(function(err){
    console.log("处理了异常",err);
})

5.Promise.all和Promise.race

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var promise1 = new Promise(function(resolve,reject){
    setTimeout(function(){
        resolve("P1");
    },2000);
})

var promise2 = new Promise(function(resolve,reject){
    setTimeout(function(){
        resolve("P2");
    },3000);
})

//Promise.rece([p1,p2])  promise参数数组中的任何一个promise执行完毕之后立马执行then
//Promise.all([p1,p2]).then的函数的参数是最早执行的promise的结果
Promise.race([promise1,promise2])
.then(function(msg){
    console.log(msg);
})

//Promise.all([p1,p2]) 会等all参数数组中的所有promise都执行完毕之后再执行then
//Promise.all([p1,p2]).then的函数的参数是一个数组参数，会将所有promise执行的结果放到这个数组参数中

//Promise.race([p1,p2]) promise参数数组中的任何一个promise执行完毕之后立马执行then
//Promise.all([p1,p2]).then的函数的参数是最早执行的promise的结果