ES6学习-Promise

Promise

简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。

语法上: Promise 是一个对象,从它可以获取异步操作的消息。

特点

  1. 对象的状态不受外界影响。Promise 对象戴白哦一个异步操作,由三种状态:pending(进行中),fulfilled(已成功), rejected(以失败)。只有异步操作的结果可以决定当前是哪一种状态。其他操作无法改变这个状态。
  2. 一旦状态改变,就不会再变,一直保存这个结果(resolved-已定型)任何时候都可以得到这个结果:两种可能-从pending变为fulfilled 和从 pending变为rejected。如果改变发生后,再对promise对象添加回调函数,也会立即得到这个结果

缺点

  1. 一旦新建Promise就会立即执行,无法中途取消
  2. 如果不设置回调函数,Promise内部抛出的错误不会反应到外部。
  3. 当处于pending状态时,无法得知母亲进行到那个阶段(刚开始还是将完成)

Promise.resolve()

resolve函数的作用是,将Promise对象的状态从“未完成”变为“成功”,在异步操作成功时调用,并将异步操作的结果,作为参数传递出去;

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

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

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

  2. thenable对象指的是具有then方法的对象,Promise.resolve方法会将这个对象转为 Promise 对象,然后就立即执行thenable对象的then方法。

    1. let thenable = {
        then: function(resolve, reject) {
          resolve(42);
        }
      };
      let p1 = Promise.resolve(thenable);
      p1.then(function(value) {
        console.log(value);  // 42
      });
      
  3. 如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的 Promise 对象,状态为resolved

    1. const p = Promise.resolve('Hello');
      p.then(function (s){
        console.log(s)
      });
      // Hello
      
  4. Promise.resolve()方法允许调用时不带参数,直接返回一个resolved状态的 Promise 对象。

Promise.reject()

基本用法

  1. resolve函数的作用是,将Promise对象的状态从“未完成”变为“成功”,在异步操作成功时调用,并将异步操作的结果,作为参数传递出去;

  2. reject函数的作用是,将Promise对象的状态从“未完成”变为“失败”(即从 pending 变为 rejected),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。

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

  4. Promise实例的状态变为resolved,就会触发then方法绑定的回调函数。

  5. Promise 新建后就会立即执行。

Promise.prototype.then()

  1. then方法是定义在原型对象,作用是为 Promise 实例添加状态改变时的回调函数。

  2. then方法返回的是一个新的Promise实例,可以采用链式写法

  3. 第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数。

  4. 采用链式的then,可以指定一组按照次序调用的回调函数。这时,前一个回调函数,有可能返回的还是一个Promise对象(即有异步操作),这时后一个回调函数,就会等待该Promise对象的状态发生变化,才会被调用。

Promise.prototype.catch()

指定发生错误时的回调函数。

  1. 如果 Promise 状态已经变成resolved,再抛出错误是无效的。因为 Promise 的状态一旦改变,就永久保持该状态,不会再变了。
  2. Promise 对象的错误具有“冒泡”性质,会一直向后传递,直到被捕获为止。也就是说,错误总是会被下一个catch语句捕获。
  3. 般来说,不要在then()方法里面定义 Reject 状态的回调函数,建议总是使用catch()方法,而不使用then()方法的第二个参数。理由是第二种写法可以捕获前面then方法执行中的错误,
  4. 如果没有使用catch()方法指定错误处理的回调函数,Promise 对象抛出的错误不会传递到外层代码,即不会有任何反应。
  5. 如果没有使用catch()方法指定错误处理的回调函数,Promise 对象抛出的错误不会传递到外层代码,即不会有任何反应。但是不会退出进程、终止脚本执行,,2 秒之后还是会输出123。这就是说,Promise 内部的错误不会影响到 Promise 外部的代码,通俗的说法就是“Promise 会吃掉错误”。
const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错,因为x没有声明
    resolve(x + 2);
  });
};
someAsyncThing().then(function() {
  console.log('everything is great');
});
setTimeout(() => { console.log(123) }, 2000);
// Uncaught (in promise) ReferenceError: x is not defined
// 123
  1. Node.js 有一个unhandledRejection事件,专门监听未捕获的reject错误,上面的脚本会触发这个事件的监听函数,可以在监听函数里面抛出错误。Node.js 有一个unhandledRejection事件,专门监听未捕获的reject错误,上面的脚本会触发这个事件的监听函数,可以在监听函数里面抛出错误。
process.on('unhandledRejection', function (err, p) {
  throw err;
});

Promise.prototype.finally()

不管 Promise 对象最后状态如何,都会执行的操作。

finally方法的回调函数不接受任何参数

Promise.all()

  1. Promise.all()方法用于将多个 Promise 实例,包装成一个新的 Promise 实例,
const p = Promise.all([p1, p2, p3]);
  1. 接受一个Promise对象数组作为参数,如果不是,就会先调用下面讲到的Promise.resolve方法,将参数转为 Promise 实例,再进一步处理。

  2. Promise.all()方法的参数可以不是数组,但必须具有 Iterator 接口,且返回的每个成员都是 Promise 实例。

p的状态由p1p2p3`决定,分成两种情况。

  1. 只有p1p2p3的状态都变成fulfilledp的状态才会变成fulfilled,此时p1p2p3的返回值组成一个数组,传递给p的回调函数。
  2. 只要p1p2p3之中有一个被rejectedp的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。
  • 如果作为参数的 Promise 实例,自己定义了catch方法,那么它一旦被rejected,并不会触发Promise.all()catch方法。

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

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

Promise.race()

将多个 Promise 实例,包装成一个新的 Promise 实例。

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

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

Promise.race([11,2,3])
    .then((a,b,c) => {
      console.log(a,b,c)//1,undefined,undefined
    })
    .then((a,b,c) => {
      console.log(a,b,c,'res---')
    })

Promise.allSettled()

Promise.allSettled()方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果,不管是fulfilled还是rejected,包装实例才会结束。

该方法返回的新的 Promise 实例,一旦结束,状态总是fulfilled,不会变成rejected。状态变成fulfilled后,Promise 的监听函数接收到的参数是一个数组,每个成员对应一个传入Promise.allSettled()的 Promise 实例。

const resolved = Promise.resolve(42);
const rejected = Promise.reject(-1);
const allSettledPromise = Promise.allSettled([resolved, rejected]);
allSettledPromise.then(function (results) {
  console.log(results);
});
// [
//    { status: 'fulfilled', value: 42 },
//    { status: 'rejected', reason: -1 }
// ]

Promise.any()

只要参数实例有一个变成fulfilled状态,包装实例就会变成fulfilled状态;如果所有参数实例都变成rejected状态,包装实例就会变成rejected状态。

Promise.any()Promise.race()方法很像,只有一点不同,就是不会因为某个 Promise 变成rejected状态而结束。

你可能感兴趣的:(ES6,学习,前端,es6)