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)。
  

  2. 如果传入的参数不包含任何 promise，则返回一个 异步完成 （asynchronously resolved）的 Promise。

  3. 其他情况下都会返回一个处理中（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