promise对象的基本用法:

promise:

1. 定义:

是一套异步操作处理机制， Promise A+ 是规范，jQuery、ES2015、q的promise都是对该规范的一种实现.

2.特点:

更容易控制异步操作的执行顺序
可以在一系列异步操作中，灵活地处理错误
支持链式调用，比较好写
能够消除回调金字塔，好看

3. 作用:

实现串行任务队列
实现串行任务管道
处理运行时才能确定执行顺序的串行任务

4.基本语法:

创建Promise对象:
```
var promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});
```
注意: resolve：在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；

reject：在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去；

Promise实例生成以后，可以用then方法、catch方法分别指定Resolved状态和Rejected状态的回调函数：

ew Promise(function(resolve,reject) {
    let num = Math.random() * 2;
    console.log("产生的随机数为：" + num);
    setTimeout(function () {
        if(num < 1) {
            console.log("即将执行成功");
            resolve("200 OK");
        } else {
            console.log("即将执行失败");
            reject("失败的原因是num为：" + num);
        }
    }, num * 1000);
}).then(function(r) {
    console.log("then：" + r);
}).catch(function(j) {
    console.log("catch：" + j);
});
复制代码

Promise.prototype.finally:

finally()方法返回一个Promise。在promise结束时，无论结果是fulfilled或者是rejected，都会执行指定的回调函数。这为在Promise是否成功完成后都需要执行的代码提供了一种方式。

这避免了同样的语句需要在then()和catch()中各写一次的情况。

语法:
```
p.finally(onFinally);

p.finally(function() {
   // 返回状态为(resolved 或 rejected)
});
```
参数:
- onFinally
  
  Promise 结束后调用的Function。
返回值:

返回一个设置了 finally 回调函数的Promise对象。
Promise.all() :

Promise.all(iterable)方法返回一个实例，此实例在 iterable参数内所有的promise都“完成（resolved）或参数中不包含 promise 时回调完成（resolve）；如果参数中 promise 有一个失败（rejected），此实例回调失败（reject），失败的原因是第一个失败 promise 的结果。
```
const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then((values) => {
  console.log(values);
});
// expected output: Array [3, 42, "foo"]
```

Promise.race():

方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

const promise1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, 'one');
});

const promise2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'two');
});

Promise.race([promise1, promise2]).then((value) => {
  console.log(value);
  // Both resolve, but promise2 is faster
});
// expected output: "two"

Promise.allSettled():

返回一个在所有给定的promise已被决议或被拒绝后决议的promise，并带有一个对象数组，每个对象表示对应的promise结果。

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];

Promise.allSettled(promises).
  then((results) => results.forEach((result) => console.log(result.status)));

// expected output:
// "fulfilled"
// "rejected"

Promise.any():

接收一个Promise可迭代对象，只要其中的一个 promise 完成，就返回那个已经有完成值的 promise 。如果可迭代对象中没有一个 promise 完成（即所有的 promises 都失败/拒绝），就返回一个拒绝的 promise，返回值还有待商榷：无非是拒绝原因数组或AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。本质上，这个方法和Promise.all()是相反的。

语法:
```
Promise.any(iterable);
```
参数:
- iterable
  
  一个可迭代的对象, 例如 Array。
返回值:
```
       1. 如果传入的参数是一个空的可迭代对象，则返回一个 已完成（already resolved）** 状态的 [Promise](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise)。
```
1. 如果传入的参数不包含任何 promise，则返回一个 异步完成 （asynchronously resolved）的 Promise。
2. 其他情况下都会返回一个处理中（pending） 的 Promise。只要传入的迭代对象中的任何一个 promise 变成完成（resolve）状态，或者其中的所有的 promises 都被拒绝，那么返回的 promise 就会 异步地（当调用栈为空时）变成完成/拒绝（resolved/reject）状态
Promise.resolve():

返回一个以给定值解析后的Promise 对象。如果这个值是一个 promise ，那么将返回这个 promise ；如果这个值是thenable（即带有"then"方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态；否则返回的promise将以此值完成。此函数将类promise对象的多层嵌套展平。
```
const promise1 = Promise.resolve(123);

promise1.then((value) => {
  console.log(value);
  // expected output: 123
});
```

Promise.reject():

返回一个带有拒绝原因的Promise对象。

function resolved(result) {
  console.log('Resolved');
}

function rejected(result) {
  console.error(result);
}

Promise.reject(new Error('fail')).then(resolved, rejected);
// expected output: Error: fail