Promise对象与async函数Promise 是异步编程的一种解决方案，是一个容器，保存着某个未来才会结束的事件（

Promise 对象与 async 函数

Promise对象

Promise 是异步编程的一种解决方案，是一个容器，保存着某个未来才会结束的事件（通常是一个异步操作）的结果。

Promise的两个特点：

（1）对象的状态不受外界影响

Promise对象代表一个异步操作，有三种状态：pending(进行中)、fufilled(已成功)、rejected(已失败)。确定之后异步操作的结果可以决定当前的状态，其余操作不可更改。

（2）一旦状态改变，就不会再变化，并且任何时候都可以得到这个结果

Promise对象状态变化只能从pending变为fulfilled和从pending变为rejected，一旦更改，状态就凝固，不会再变化，这个时候可以称作resolved(已定型)，为Promise对象添加回调函数可以获得结果，与Event事件不同，过了就难以再次监听得到结果，

一些弊端：

一旦新建了它就立即执行，无法中途取消Promise，并且不设置回调函数，Promise内部会抛出错误，不会反应到外部。

基本用法：

const promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve、reject（由JS引擎提供，不需要自己部署）

resolve函数：将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去

reject函数：将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去

创建实例之后，用then方法来指定 resolved状态和rejected状态的回调函数

promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中，第二个函数是可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数

一个实例：

let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve();
});

promise.then(function() {
  console.log('resolved.');
});

console.log('Hi!');

// Promise
// Hi!
// resolved

Promise.prototype.then()

作用为 Promise 实例添加状态改变时的回调函数，第一个参数是resolved状态的回调函数，第二个参数（可选）是rejected状态的回调函数；then方法返回的是一个新的Promise实例（不是原来的那个Promise实例）

Promise.prototype.catch()

是 .then(null, rejection)或.then(undefined, rejection)的别名，用于指定发生错误时的回调函数

Promise.prototype.finally()

该方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。

Promise.all()

用于将多个 Promise 实例，包装成一个新的 Promise 实例 , 接受一个数组作为参数

Promise.race()

将多个 Promise 实例，包装成一个新的 Promise 实例，接受一个数组作为参数；如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve()方法，将参数转为 Promise 实例，再进一步处理

Promise.allSettled()

接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例; 等到所有这些参数实例都返回结果，不管是fulfilled还是rejected，包装实例才会结束

Promise.any()

接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例

Promise.resolve()

将现有对象转为 Promise 对象

参数分为四种情况：

参数是一个 Promise 实例

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

thenable对象指的是具有then方法的对象
参数不是具有then方法的对象，或根本就不是对象

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

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

Promise.reject()

返回一个新的 Promise 实例，该实例的状态为rejected

async函数

async函数是 Generator 的语法糖，async函数其实就是将 Generator 函数的星号（*）替换成async，将yield替换成await。

const fs = require('fs');

const readFile = function (fileName) {
  return new Promise(function (resolve, reject) {
    fs.readFile(fileName, function(error, data) {
      if (error) return reject(error);
      resolve(data);
    });
  });
};

const gen = function* () {
  const f1 = yield readFile('/etc/fstab');
  const f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

const asyncReadFile = async function () {
  const f1 = await readFile('/etc/fstab');
  const f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

拥有更好的语义：async表示函数有异步操作，await表示紧跟后面的表达式需要等待结果。

返回值是Promise对象，async函数可以看作多个异步操作，包装成的一个 Promise 对象，而await命令就是内部then命令的语法糖。

Promise 对象的状态变化：

async函数返回的 Promise 对象，必须等到内部所有await命令后面的 Promise 对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数

await命令：

命令后面是一个 Promise 对象，返回该对象的结果。如果不是 Promise 对象，就直接返回对应的值

错误处理：

await后面的异步操作出错，等同于async函数返回的 Promise 对象被reject