promise基本使用

创建

Promise 对象是由关键字 new 及其构造好函数创建的。该构造函数会接受一个函数（“处理器函数”）作为参数。这个处理器函数接受两个函数resolve和reject作为其参数。当异步任务顺利完成且返回结果值时，会调用resolve函数；当异步任务失败且返回失败原因时会调用reject函数。

const promise = new Promise(function(resolve, reject) {
	......
	if (...) {
		resolve(value);
	} else {
		reject(value);
 	}
})

Promise.prototype.then()

Promise实例具有then方法，它的作用是为Promise实例添加状态改变时的回调函数。接受两个参数，第一个是resolved状态的回调函数，第二个是rejected状态的回调函数，它们都是可选的。

const promise = new Promise(function(resolve, reject) {
  const num = Math.random()*100;
  if (num > 50) {
    resolve("大于50");
  } else {
    reject("小于或等于50");
  }
});
promise.then(val => {
  console.log(val);
}, err => {
  console.log(`err`, err);
});

Promise.prototype.catch()

catch 可以用于指定发生错误时的回调函数。如果是运行时发生的错误，也会被catch方法捕获。

const promise = new Promise(function(resolve, reject) {
  const num = Math.random()*100;
  if (num > 50) {
    resolve("大于50");
  } else {
    reject("小于或等于50");
  }
});
promise.then(val => {
  console.log(val);
}).catch(err => {
  console.log(err)
});

Promise.prototype.finally()

finally方法用于不管promise对象最后状态如何，都会执行的操作。

const promise = new Promise(function(resolve, reject) {
  const num = Math.random()*100;
  if (num > 50) {
    resolve("大于50");
  } else {
    reject("小于或等于50");
  }
});
promise.then(val => {
  console.log(val);
}).catch(err => {
  console.log(err)
}).finally(() => {
	console.log("finally");
});

Promise.all()

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

const p1 = new Promise((resolve, reject) => {
  resolve("p1");
});
const p2 = new Promise((resolve, reject) => {
  resolve("p2");
});
const p3 = new Promise((resolve, reject) => {
  resolve("p3");
});
const p = Promise.all([p1, p2, p3]);
p.then(val => {
  console.log(val)
}).catch(err => {
  console.log(err);
});
 // p的状态由p1、p2、p3决定，分成两种情况。
 //（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
 //（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

Promise.race()

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

const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p1");
  }, Math.random()*1000)
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    reject("p2");
  }, Math.random()*1000)
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p3");
  }, Math.random()*1000)
});
const p = Promise.race([p1, p2, p3]);
p.then(val => {
  console.log(val)
}).catch(err => {
  console.log(err);
});
 //  只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。

Promise.resolve()

Promise.resolve()方法可以将现有对象转为Promise对象。

const promise = Promise.resolve(xxx);
// 等价于
const promise = new Promise(resolve => resolve(xxx));
// 1: 不带参数，直接返回一个resolved状态的Promise对象。
// 2: 参数是一个Promise实例，Promise.resolve将不做任何修改、原封不动的返回这个实例。
// 3：参数是具有then方法的对象，Promise.resolve方法会将这个对象转为Promise对象，然后立即执行这个对象中的then方法。
let thenable = {
  then: (resolve, reject) => {
    resolve("thenable");
  }
};
let promise = Promise.resolve(thenable);
promise.then(value => {
  console.log(value);
});
// 4: 参数不是具有then方法的对象或者根本就不是对象，Promise.resolve方法返回一个新的Pormise对象，状态为resolved。

Promise.reject()

Promise.reject 方法返回一个状态为rejected的新的Promise实例

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

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