es6 Promise

Promise 是异步编程的一种方案,简单说就是一个容器,里面保存着某个未来才会结束的事件的
结果,Promise 是一个对象,从它,可以获取异步操作的消息。

Promise 对象有以下两个特点。
  (1)对象的状态不受外界影响。Promise 对象代表一个异步操作,有是三种状态。pendding
    (进行中),fulfilled(已成功)和rejected(已失败)。
  (2)一旦状态改变,就不会在变,任何时候都可以得到这个结果,Promise 对象的状态改变
  只有两种可能: 从pending 变为fulfilled 和pending 变为rejected.如果改变已经发生 了,你在
  对Promise对象添加回调函数,也会立即得到这个结果。
  Promise 有一些缺点,首先无法取消Promise ,一旦新建它就会立即执行,中途无法取消。
  如果不设置回调函数,Promise内部抛出的错误,不会立即反应到外部。当处于pending
  状态时,无法得子目前进展到哪一个阶段。
用法
  Promise 对象是一个构造函数,用来生成Promise实例。
  构造函数接受一个函数作为参数,该函数的两个参数分别是resolve 和reject。
    resolve 函数的作用是,将Promise 对象的状态从“未完成”变为“成功”,在异步操作成功
    的时候调用,并将异步操作的结果,作为参数参数传递。
    reject 函数的作用是,将Promise对象的状态从“未完成”变为“失败”,在异步操作失败
    的时候调用,并将异步操作报出错误,作为参数传递出去。
 
Promise 实例陈仓以后,可以使用then 方法分别指定resolved状态和rejected状态回调函数。
    例如:
      promise.then(function(value){
          // success
       },function(error){
          // failure
      });
      第一个回调函数是状态变为resolved时调用,
      第二个回调函数是Promise对象的状态变为rejected时调用。
    Promise对象的简单例子。
     funcion timeout(ms){
        return new Promise((resolve,reject)=>{
          setTimeout(resolve,ms,'done');
        });
      }
      timeout(100).then((value)=>{
        console.log(value);
      })
    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 实例具有then 方法,也就是说,then方式定义在原型对象Promise.prototype上的。
    then 方法返回的是一个新的Promise实例。 第一个参数是resolved状态的回调函数,
    第二个参数是rejected状态的回调函数。
  Promise.prototype.catch()
    Promise.prototype.catch 方法是.then(null,rejection)的别名,用于指定发生错误时的回调函数。
    写法一:
    const promise = new Promise(function(resolve,reject){
        try {
          throw new Error('test');
        }catch(e){
            reject(e);
          }
        });
      promise.catch(function(error){
        console.log(error);
      })
    // 写法二
 const promise = new Promise(function(resolve,reject){
      reject(new Error('test'));
    });
    promise.catch(function(error){
      console.log(error);
    })
  Promise.all()
    Promise.all 方法用于将多个Promise 实例,包装成一个新的Promise实例。
      const p = Promise.all([p1,p2,p3]);
    Promise.all 方法接受一个数组作为参数,p1,p2,p3都是Promise实例,如果不是,就会
      调用下面讲到的Promise.resolve方法,将参数转为Promise实例。
  Promise.race()
    Promise.race 方法同样是将多个Promise实例,包装成一个新的Promise实例。
    const p = Promise.race([p1,p2,p3]);
    上面例子中,只要p1,p2,p3之中有一个实例率先改变状态,p的状态就跟着改变。
      那么率先改变的Promise实例的返回值,就传给p的回调函数。
      const p = Promise.race([
        fatch('/resource-that-may-take-a-while'),
        new Promise(function(resolve,reject){
          setTimeout(()=> reject(new Error('request timeout')),5000)
        })
      ]);
      p.then(response => console.log(response));
      p.catch(error => console.log(error));
    上面代码中,如果5秒内fetch 方法无法返回结果,变量p的状态就会变为rejected,从而
    触发catch 方法指定的回调函数。
 
    Promise.resolve()
    将现有对象转为Promise对象。
      Promise.resolve('foo') 等价于
      new Promise(resolve =>resolve('foo'))
      Promise.resolve 方法的参数非常四种情况
        1.参数一个Promise实例,将不做任何修改,原封不动地返回这个实例。
        2.参数一个thenable 对象。
        3.参数不是具有then方法的对象,或根本就不是对象。
        4. 不带任何参数。
      
    Promise.reject();
      Promise.reject(reason) 方法会返回一个新的Promise实例,该实例的状态为rejected
 
    done()
      Promise对象的回调链,不管以then方法或是catch 方法结尾,要是最后一个方法抛出
      错误,都有可能无法捕捉到。提供一个done方法,总是处于回调链的尾端,保证抛出
      任何有可能出现的错误。
        Promise.prototype.done = function (onFulfilled,onRejected){
          this.then(onFulfilled,onRejected).catch(function(reason){
            // 抛出一个全局错误
            setTimeout(()=>{throw reason},0)
          });
        }
      应用加载图片
      const preloadImge = function(path){
          return new Promise(function(resolve,reject){
            const image = new Image();
            image.onload = resolve;
            image.onerror = regect;
            image.src = path;
          })
        };

 

posted @ 2018-01-08 15:36  柠檬先生  阅读(266)  评论(0编辑  收藏  举报