ES6新特性之Promise

基本概念

从字面意思上来看,Promise是承诺。它表示一个异步操作的最终状态(完成或失败),以及该异步操作的结果值。根据Pormise的执行结果可以拿到一个最终状态。

    new Promise({
        function(resolve,reject){
            /* executor */
        }
    });

一般来讲,有三种状态:

  • pending,进行中
  • fulfilled,已成功
  • rejected,已失败

关于三种状态,实际上分为两种情况:一种是从pending到fulfilled,也就是执行然后成功;另一种pending到rejected是执行,然后失败。Promise 的状态一旦确定就不再改变。只能够从pending到fulfill或者是从pending到rejected,确定之后的状态称之为resolved。resolved之后添加回调会立即执行得到结果,resolved一般指的是fulfilled状态。

一旦新建会立即执行,无法中途取消。Promise构造函数执行时立即调用executor函数。

基本用法

  • Promise接收一个函数作为参数,该函数的参数分别是resolved和reject

        let promise = new Promise(function(resolve,reject){
            console.log('new promise');
            setTimeout(function(){
                console.log('promise resolved');
                return resolved('success');
            },1000);
        });
    
    
  • Promise实例生成后在then方法中指定resolved状态和rejected(可选)状态的回调函数

        promise.then(function(value){
            console.log('resolved callback',value);
        });
    
    
  • Promise传递

        const promise1 = new Promise(function (resolve,reject)){
            /* .... */
        }
    
    

属性和方法

  • Promise.prototype.then,是Promise状态改变时的回调函数,也就是定义了一个承诺,那么得到的结果是什么。它返回一个新的Promise,新的Promise意味着可以链式调用,也就是.then之后还可以.then 。

        // 顺次调用
        let promise1 = new Promise(function(resolve, reject) {
            console.log('new promise1');
    
            setTimeout(function() {
                console.log('promise1 resolved');
                return resolve("promise1 success");
            }, 2000);
        });
    
        let promise2 = new Promise(function(resolve, reject) {
            console.log('new promise2');
    
            setTimeout(function() {
                console.log('promise2 resolved');
                return resolve("promise2 success");
            }, 4000);
        });
    
        promise1
          .then(function(value) {
            console.log('then1 callback', value);
            return value;
          })
          .then(function(value) {
            console.log('then2 callback', value);
            return promise2;
          })
          .then(function(value) {
            console.log('then3 callback', value);
            return '';
          })
    
    
  • Promise.prototype.catch(错误捕获)
    错误发生时的回调函数,相当于.then(null/undefined,reject)的一个别名,它捕获reject以及then回调运行时的错误。

        // 顺次调用
        let promise = new Promise(function(resolve, reject) {
          throw new Error('Error');
        });
        promise.catch(function(error) {
          console.log(error);
        });
    
        // Error: Error 
    
    
  • Promise.prototype.finally(最后)
    不管成功或失败,这个方法无论状态如何都会执行。它不接受任何参数,与状态无关,不依赖Promise执行结果。

  • Promise.all(所有)
    把所有的Promise放在一起,然后当所有的Promise全部resolved,这个Promise.all才会真正的resolved。也就是所有的成功了它才成功,可以理解成一个包装器,它包装多个Promise为一个新的Promise,那么Promise.all实际上接收的是一个数组,fulfilled条件是所有包装的Promise全部fulfilled。

        const promise1 = new Promise((resolve, reject) => {
          resolve({
            code: 200,
            data: [],
          });
        })
          .then(result => result)
          .catch(err => ({
            code: 200,
            data: [],
          }));
    
           const promise2 = new Promise((resolve, reject) => {
            throw new Error('Error');
          })
            .then(result => result)
            .catch(err => ({
              code: 200,
              data: [],
            }));
    
          Promise.all([promise1, promise2])
            .then(result => console.log(result))
            .catch(e => console.log(e));
          ```  
        使用Promise.all,我们需要给每一个Promise都加一个catch,返回一个备用的结果,这个月整个的Promise.all才会得到一个resolved结果。
    
    
  • Promise.race(谁先返回就先执行谁)

    包含多个Promise为一个新的Promise,返回第一个fulfilled。
        const promise = Promise.race([
            fetch('/url'),
            new Promise(function (resolve, reject) {
              setTimeout(() => {
                return reject(new Error('request timeout'));
              }, 5000);
            })
          ]);
    
          p
            .then(console.log)
            .catch(console.error);
    
    
  • Promise.resolve(状态)
    将现有对象转为Promise对象,状态为fulfilled。

        const promise = Promise.resolve('hello');
        promise.then(res => alert(res));
    
    
  • Promise.reject
    将现有对象转为Promise对象,状态为rejected。

        const promise = Promise.reject('word');
        promise.then(res => alert(res)).catch(err => alert(err));
    

转载于:https://my.oschina.net/u/4144971/blog/3096601

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值