Promise的其他属性

1. promise的其他属性

1.1 promise.all

Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。

const p = Promise.all([p1, p2, p3]);

参数要求:
上面代码中，Promise.all()方法接受一个数组作为参数，p1、p2、p3都是 Promise 实例，如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。

p的状态由p1、p2、p3决定，分成两种情况。

（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。

（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

var p2=new Promise(function(resolve,reject){
        setTimeout(()=>{
            resolve("做饭");
        },1000)
    })

    var p3=new Promise(function(resolve,reject){
        setTimeout(()=>{
            //reject("看电影！！")
            resolve("看电影！！");
        },3000)
    })
    var p1=new Promise(function(resolve,reject){
        setTimeout(()=>{
            resolve("洗衣")
        },500)
    })


     Promise.all([p1,p3,p2]).then(res=>{
        console.log(res)
    }).catch(err=>{
        console.log(err);
    })

p1会resolved，p2首先会rejected，但是p2有自己的catch方法，该方法返回的是一个新的 Promise 实例，p2指向的实际上是这个实例。该实例执行完catch方法后，也会变成resolved，导致Promise.all()方法参数里面的两个实例都会resolved，因此会调用then方法指定的回调函数，而不会调用catch方法指定的回调函数。

const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result)
.catch(e => e);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result)
.catch(e => e);

Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// ["hello", Error: 报错了]

如果p2没有自己的catch方法，就会调用Promise.all()的catch方法。

const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result);

Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// Error: 报错了

1.2 Promise.race

Promise.race()方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

const p = Promise.race([p1, p2, p3]);

只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。

 Promise.race([p1,p2,p3]).then(res=>{
         console.log(res);
     }).catch(err=>{
         console.log(err);
     })

1.3 Promise.resolve()

有时需要将现有对象转为 Promise 对象，Promise.resolve()方法就起到这个作用。

Promise.resolve()等价于下面的写法。

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

Promise.resolve()方法的参数分成四种情况。

1）参数是一个 Promise 实例

如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。

2）参数是一个thenable对象

thenable对象指的是具有then方法的对象，比如下面这个对象。

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

Promise.resolve()方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then()方法。

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

let p1 = Promise.resolve(thenable);
p1.then(function (value) {
  console.log(value);  // 42
});

上面代码中，thenable对象的then()方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then()方法指定的回调函数，输出42。

3）参数不是具有then()方法的对象，或根本就不是对象

如果参数是一个原始值，或者是一个不具有then()方法的对象，则Promise.resolve()方法返回一个新的 Promise 对象，状态为resolved。

const p = Promise.resolve('Hello');

p.then(function (s) {
  console.log(s)
});
// Hello

上面代码生成一个新的 Promise 对象的实例p。由于字符串Hello不属于异步操作（判断方法是字符串对象不具有 then 方法），返回 Promise 实例的状态从一生成就是resolved，所以回调函数会立即执行。Promise.resolve()方法的参数，会同时传给回调函数。

4）不带有任何参数

Promise.resolve()方法允许调用时不带参数，直接返回一个resolved状态的 Promise 对象。

所以，如果希望得到一个 Promise 对象，比较方便的方法就是直接调用Promise.resolve()方法。

const p = Promise.resolve();

p.then(function () {
  // ...
});

上面代码的变量p就是一个 Promise 对象。

需要注意的是，立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时。

setTimeout(function () {
  console.log('three');
}, 0);

Promise.resolve().then(function () {
  console.log('two');
});

console.log('one');

// one
// two
// three

上面代码中，setTimeout(fn, 0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行，因此最先输出。

1.4 Promise.reject()

Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected。

const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'))

p.then(null, function (s) {
  console.log(s)
});
// 出错了

上面代码生成一个 Promise 对象的实例p，状态为rejected，回调函数会立即执行。

注意:Promise里throw new Error 能不能被后面的reject回调或者catch捕获的问题

1、把throw new Error语句放延时函数里，只会报错，不执行reject函数或者catch函数

 var promise = new Promise((resolve, reject) => {
    setTimeout(() => {
           throw new Error('nono') //这里主动抛出错误
       }, 500);
    })
   .then(()=>{},(err)=>{
       console.log(1) //这里是reject时应该调用的函数，但是这里并没有执行，只会在控制台报错
       console.log(err) //根本不执行这里
   })
   .catch((err)=>{
       console.log(2) //这里catch都不执行
       console.log(err)
   })

2、而不把throw new Error语句放延时函数里，就能在reject函数里执行

var promise = new Promise((resolve, reject) => {
    throw new Error('nono') //这里直接抛出错误，就能被后面的reject函数执行到
})
.then(()=>{},(err)=>{
      console.log(1) //这里就执行了
      console.log(err)
})
.catch((err)=>{
      console.log(2)
      console.log(err)
})

3、另外，不用throw new Error，而是直接reject()，不论是否放在延时函数里都能正常被捕获

var promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        reject('hehe')
    }, 500);
})
    .then(()=>{},(err)=>{
        console.log(1) //可以捕获
        console.log(err)
    })
    .catch((err)=>{
        console.log(2)
        console.log(err)
    })

setTimout中传入的回调方法应该是被js引擎直接调用的，而引擎直接发出的报错，这可能就是捕获不到throw的原因。