初探Promise

摘自:阮一峰 http://es6.ruanyifeng.com/#docs/promise

一、首先,我们要弄明白,什么是Promise:

Promise是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理,更强大。它由社区最早提出和实现,ES6将其写进了语言标准,统一了方法,原生提供了Promise对象。

所谓Promise,简单说就是一个容器,里边保存着一个未来才会结束的事件(通常是一个异步操作)的结果。从语法上说,Promise是一个对象,从它可以获取异步操作的消息。Promise提供统一的API,各种异步操作都可以用同样的方法进行处理。

Promise对象有以下两个特点:
  1. 对象的状态不受外界影响。Promise对象代表一个异步操作,有三种状态:pending(进行中)、fulfilled(已成功)、和 rejected(已失败)。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。这也是Promise这个名字的由来,它的英文意思就是承诺,表示其他手段无法改变。
  2. 一旦状态改变,就不会再变,任何时候,都可以得到这个结果。Promise对象的状态改变,只有两种可能:从pending变为fulfilled和从pending变为 rejected。只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果,这时就成为resolVed(已定型)。如果改变已经发生了,你再对Promise对象添加回调函数,也会立即得到这个结果。这与事件(Event)完全不同,事件的特定是,如果你错过了它,再去监听,是得不到结果的。

注意:为了行文方便,本章后边的resolved统一只指 fulfilled状态,不包含 rejected状态。

有了Promise对象就可以把异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。此外,Promise对象提供统一的接口,使得控制异步操作更加容易。

Promise也有一些缺点。首先,无法取消Promise,一旦新建它就会立即执行无法中途取消。其次,如果不设置回调函数,Promise内部抛出的错误,不会反应到外部。三、当处于pending状态时,无法得知目前进展到哪一个阶段(刚刚开始,还是即将完成)。

如果某些事件,不断的反复发生,一般来说,部署stream模式,是比部署Promise更好的选择。


二、基本用法

ES6规定,Promise对象是一个构造函数,用来生成Promise实例。

下面代码,创造了一个Promise实例:

const promise = new Promise(function(resolve,reject){
    if(/*异步操作成功*/){
        resolve(value);
    }else{
        reject(error);
    }
})

Promise构造函数接受一个函数作为参数,该函数的两个参数,分别是resolvereject。它们是两个函数,由JavaScript引擎提供,不用自己部署。

resolve函数的作用是,将Promise对象的状态从’未完成‘变为’成功‘,(即从pending变为resolved),在异步操作成功时调用,并将异步操作的结果作为参数传递出去; rejected函数的作用是,将Promise对象的状态从’未完成‘变为‘失败’(即从pending变为rejected) ,在异步操作失败时调用,并将异步操作报出的错误,作为参数,传递出去。

Promise实例生成后,可以用then方法分别指定resolved状态和rejected状态的回调函数。

promise.then(function(value){
    //success
},function(error){
    //error
})

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

下面是一个Promise对象的简单例子:

function timeOut(ms){
    return new Promise((resolve,reject)=>{
      setTimeout(resolve,ms,'done');
  });
}

timeOut(100).then((value)=>{
    console.log(value);
})

上面代码中,timeOut方法返回一个Promise实例,表示一段时间以后才会发生的结果。过了指定的时间(参数ms)以后,Promise实例的状态变为resolved,就会触发then方法绑定的回调函数。

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创建后立即执行,所以首先输出是Promise,然后then方法执行的回调函数,将会在当前脚本所有同步任务执行完才会执行,所以resolved最后输出。

下面是异步加载图片的例子:

function loadImageAsync(url){
    return new Promise(function(resolve,reject){
    const image = new Image();

    image.onload = function(){
        resolve(image);
    };

    image.onerror = function(){
        reject(new Error('Could not load image at'+url));
    };

    image.src = url;
})
}

上边代码中,使用了 Promise包装了一个图片加载的异步操作,如果图片加载成功就调用resolve方法,否则就调用reject方法。

下面是使用Promise对象实现Ajax操作的例子。

const getJSON = function(url){
    const promise = new Promise(function(resolve,reject){
    const handler = function(){
        if(this.readyState !==4){
            return ;
       }if(this.tatus === 200){
            resolve(this.response);
       }else{
            reject(new Error(this.statusText));
       }
      };
      const client = new XMLHttpRequest();
      client.open('GET',url);
      client.onreadystatechange = handler;
      client.responseType = 'json';
      client.setRequestHeader('Accept','application/json');
      client.send();
  })
      return promise;
}

getJSON('posts.json').then(function(json){
    console.log('Contents'+json);
},function(error){
    console.error('出错了',error);
})

上面代码中,getJSON是对 XMLHttpRequest 对象的封装,用于发出一个针对 JSON 数据的 HTTP 请求,并且返回一个Promise对象。需要注意的是,在getJSON内部,resolve函数和reject函数调用时,都带有参数。

如果调用resolve函数和reject函数时带有参数,那么他们的参数会被传递给回调函数。reject函数的参数,通常是Error对象的实例,表示抛出错误;reject函数的参数除了正常的值以外,还可能是另外一个Promise实例。比如像下面这样:

const p1 = new Promise(function(resolve,reject){
    //...
})
const p2 = new Promise(function(resolve,reject){
    //...
    resolve(p1);
})

上面代码中,p1和p2都是 Promise 的实例,但是p2的resolve方法将p1作为参数,即一个异步操作的结果是返回另一个异步操作。

注意,这时p1的状态就会传递给p2,也就是说,p1的状态决定了p2的状态。如果p1的状态是pending,那么p2的回调函数就会等待p1的状态改变;如果p1的状态已经是resolved或者rejected,那么p2的回调函数将会立刻执行。

const p1 = new Promise(function(resolve,reject){
    setTimeout(() => reject(new Error('fail...')),3000) ;
})

const p2 = new Promise(function(resolve,reject){
    setTimeout(() => resolve(p1),1000);
})

p2
  .then(result => console.log(result))
  .catch(error => console.log(error))
//Error: fail...

上面代码中,p1是一个Promise,3秒钟后变为rejected.p2的状态在1秒钟后改变,resolve方法返回的是p1,由于p2返回的是另外一个Promise,导致p2自己的状态无效了,由p1的状态,决定p2的状态。所以,后面的then语句都变成针对后者(p1),又过了 2 秒,p1变为rejected,导致触发catch方法指定的回调函数

注意,调用resolvereject并不会终结Promise的参数函数的执行。

new Promise((resolve,reject) => {
    resolve(1);
    console.log(2)
}).then(r => {
  console.log(r);
})

上面代码中,调用resolve(1)以后,后面的console.log(2)还是会执行,并且会首先打印出来.这是因为立即 resolved 的 Promise 是在本轮事件循环的末尾执行,总是晚于本轮循环的同步任务。

一般来说,调用resolvereject以后,Promise 的使命就完成了,后继操作应该放到then方法里面,而不应该直接写在resolvereject的后面。所以,最好在它们前面加上return语句,这样就不会有意外。

new Promise((resolve,reject) => {
    return resolve(1);
    //后边的语句不会执行
    console.log(2);
})

三、Promise.prototype.then

Promise实例具有then方法,也就是说,then方法是定义在原型对象Promise.prototype上的。它的作用是为Promise实例添加状态改变时的回调函数。前边说过,then方法的第一个参数是resolved状态的回调函数,第二个参数(可选)是rejected状态的回调函数。

then方法返回的是一个新的 Promise实例(注意,不是原来那个Promise实例),因此可以采用链式写法,即then方法后面再调用另外一个then方法。

getJSON('/posts.json').then(function(json){
    return json.post;
}).then(function(post){
    //...
})

上面的代码使用then方法,依次指定了两个回调函数,第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数。
采用链式的then,可以指定一组按照次序调用的回调函数。这时前一个回调函数,有可能返回的还是一个Promise对象(既有异步操作),这时后一个回调函数就会等待该Promise对象的状态发生变化,才会被调用。

getJSON('/post/1.json').then(function(post){
    return getJSON(post.commentURL);
}).then(function A(comments){
    console.log('resolved:',comments);
},function B(err){
    console.log('rejected:',err);
})

上面代码中,第一个then方法指定的回调函数,返回的是另外一个Promise对象,这时第二个then方法指定的回调函数,就会等待这个心的Promise对象状态发生变化,如果变为resolved就调用funcA,如果变为rejected就调用funcB.

如果采用箭头函数,上边的代码可以写的更简洁:

getJSON('/post/1.json').then(
    post => getJSON(post.commentURL)
).then(
    comments => console.log('resolved:',comments),
    err => console.log('rejected:',err)
)

四、Promise.prototype.catch

Promise.prototype.catch方法,是.then(null,rejection)方法的别名,用于指定发生错误时的回调函数。

getJSON('/posts.json').then(function(posts){
    //...
}).catch(function(error){
    console.log('发生错误:',error)
})

上面代码中,getJSON方法返回一个 Promise 对象,若该对象状态变为resolved,则会调用then方法指定的回调函数。如果异步操作抛出错误,状态就会变为rejected,则会调用catch方法指定的回调函数,处理这个错误。另外then方法指定的回调函数,如果运行中抛出错误,也会被catch方法捕获。

p.then((val) => console.log('fulfilled:',val))
  .catch((error) => console.log('rejected:',error));

//等同于
p.then((val) => console.log('fulfilled:',val))
  .then(null,(error) =>  console.log('rejected:',error))

下面是一个例子:

const promise = new Promise(function(resolve, reject) {
  throw new Error('test');
});
promise.catch(function(error) {
  console.log(error);
});
//Error:test

上面代码中,promise抛出一个错误,就被catch方法指定的回调函数捕获。注意,上面的写法与下面两种写法是等价的。

//写法1
const promise = new Promise(function(resolve,reject){
    try{
        throw new Error('test')
    }catch(e){
        reject(e)
    }
});
promise.catch(function(error) {
  console.log(error);
});

//写法2
const promise = new Promise(function(resolve,reject){
  reject(new Error('test'));
});
promise.catch(function(error) {
  console.log(error);
});

比较上面两种写法,可以发现reject方法的作用,等同于抛出错误。

如果Promise状态已经变成了 resolved,再抛出错误是无效的。

const promise = new Promise(function(resolve,reject){
      resolve('ok');
      throw new Error('test');
});
promise
  .then(function(value){ console.log(value)})
  .catch(function(err){console.log(err)})

上面代码中,Promiseresolve语句后面,再抛出错误,不会被捕获,等于没有抛出。因为 Promise 的状态一旦改变,就永久保持该状态,不会再变了。

Promise 对象的错误,具有冒泡性质,会一直向后传递,知道被捕获为止,也就是说,错误总是会被下一个catch语句捕获。

getJSON('/post/1.json').then(function(post){
    return getJSON(post.commentURL)
}).then(function(comments){
    //some code
}).catch(function(error){
    //处理前面三个`Promise`产生的错误
})

上面代码中,一共有三个 Promise 对象:一个由getJSON产生,两个由then方法产生,它们之中,任何一个抛出错误,都会被最后一个catch捕获。

一般来说,不要在then方法里定义rejected状态的回调函数,即then的第二个参数,总是使用catch方法。

//bad
promise
  .then(function(value){
    //success
    console.log(value)
},function(error){
    //error
    console.log(error)
})

//good
promise
  .then(function(value){
  //success
  console.log(value)
}).catch(function(error){
  //error
  console.log(error)  
})

上面代码中,第二种写法要好于第一种写法,理由是第二种写法可以捕获前面then方法执行中的错误,也更接近同步的写法(try/catch),因此建议总是使用catch方法,而不使用then方法的第二个参数。

与传统的try/catch代码块不同的是,如果没有使用catch方法指定错误处理的回调函数,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)

上面代码中,someAsyncThing函数产生的 Promise 对象,内部有语法错误。浏览器运行到这一行,会打印出错误提示ReferenceError: x is not defined,但是不会退出进程、终止脚本执行,2 秒之后还是会输出123。

这就是说,Promise 内部的错误不会影响到 Promise 外部的代码,通俗的说法就是Promise 会吃掉错误。

这个脚本放在服务器执行,退出码就是0(即表示执行成功)。不过,Node 有一个unhandledRejection事件,专门监听未捕获的reject错误,上面的脚本会触发这个事件的监听函数,可以在监听函数里面抛出错误。

process.on('unhandledRejection',function(err,p){
    throw err;
})

上面代码中,unhandledRejection事件的监听函数有两个参数,第一个是错误对象,第二个是报错的 Promise 实例,它可以用来了解发生错误的环境信息。

注意,Node 有计划在未来废除unhandledRejection事件。如果 Promise 内部有未捕获的错误,会直接终止进程,并且进程的退出码不为 0。

再看下面的例子:

const promise = new Promise(function(resolve,reject){
    resolve('ok');
    setTimeout(function(){throw new Error('test')},0);
 })

promise.then(function(value){console.log(value)});
// ok
// Uncaught Error: test

上面代码中,Promise指定下一轮事件循环再抛出错误。到了那个时候,Promise的运行已经结束了,所以这个错误是在函数体外抛出的,会冒泡到最外层,成为未捕获的错误。

一般总是建议,Promise对象后面要跟catch方法,这样可以处理Promise内部发生的错误,catch方法返回的 还是一个Promise对象,因次后面还可以接着调用then方法。

const someAsyncThing = function(){
  return new Promise(function(resolve,reject){
    //下面一行会报错,因为没有声明x
    resolve(x+2);
 })
}

someAsyncThing().catch(function(error){
    console.log('oh no:',error);
}).then(function(){
    console.log('carry on')
})
//oh no: ReferenceError: x is not defined
//carry on

上面代码运行完catch方法指定的回调函数,会接着运行后面那个then方法指定的回调函数。如果没有报错,则会跳过catch方法。

 Promise.resolve()
.catch(function(error){
    console.log('oh no:',error)
})
.then(function(){
    console.log('carry on')
})
//carry on

上面代码因为没有报错,所以会跳过catch方法,直接执行后面的then方法。此时要是then方法里边报错,就与前面的catch方法无关了。

catch方法之中,还能再抛出错误。

const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错,因为x没有声明
    resolve(x + 2);
  });
};
someAsyncThing().then(function(){
    return someAsyncThing();
}).catch(function(error){
    console.log('oh no:',error);
    // 下面一行会报错,因为 y 没有声明
    y+2
}).then(function(){
    console.log('carry on');
})
// oh no [ReferenceError: x is not defined]

上面代码中,catch方法抛出一个错误,因为后面没有别的catch方法了,导致这个错误不会被捕获,也不会传递到外层。如果改写一下,结果就不一样了。

someAsyncThing().then(function() {
  return someOtherAsyncThing();
}).catch(function(error) {
  console.log('oh no', error);
  // 下面一行会报错,因为y没有声明
  y + 2;
}).catch(function(error) {
  console.log('carry on', error);
});
// oh no [ReferenceError: x is not defined]
// carry on [ReferenceError: y is not defined]

上面代码中,第二个catch方法用来捕获前一个catch方法抛出的错误。


5.Promise.prototype.finally()

finally方法用来指定,不管Promise对象最后状态如何,都会执行的操作。该方法时ES2018引入标准的。

promise
.then((value) => {...})
.catch((error) => {...])
.finally(() => {...});

上面代码中,不管promise最后的状态,在执行完thencatch指定的回调函数以后,都会执行finally方法指定的回调函数。

下面是一个例子,服务器使用Promise处理请求,然后使用finally方法关掉服务器。

server.listen(port)
  .then(function(){
    //...
  })
  .finally(server.stop);

finally方法的回调函数不接受任何的参数,这意味着没有办法知道,前面的Promise状态,到底是fulfilled还是rejected。这表明,finally方法里面的操作,应该是与状态无关的,不依赖与Promise的执行结果。

finally方法本质上是then方法的特例:

promise
.finally(function(){
    //语句
})

//等同于
promise
  .then(
    result =>{
    //语句
    return result
  },
    error =>{
    //语句
    throw error;
  }
)

上面代码中,如果不使用finally方法,同样的语句需要为成功和失败两种情况各写一次。有了finally方法,则只需要写一次。
它的表现也很简单

Promise.prototype.finally = function(callback){
    let p = this.constructor;
    return this.then(
    value => p.resolve(callback().then(() =>value));
    reason => P.resolve(callback()).then(() => { throw reason })
)
}

上面代码中,不管前面的 Promise 是fulfilled还是rejected,都会执行回调函数callback

从上面的实现还可以看到,finally方法总是会返回原来的值。

// resolve 的值是 undefined
Promise.resolve(2).then(() => {},() => {})

// resolve 的值是 2
Promise.resolve(2).finally(() => {})

// reject 的值是 undefined
Promise.reject(3).then(() => {}, () => {})

// reject 的值是 3
Promise.reject(3).finally(() => {})

六、Promise.all()

Promise.all方法,用于将多个Promise实例,包装成一个新的Promise实例

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

上面代码中,Promise.all方法接受一个数组作为参数,p1,p2,p3都是Promise实例,如果不是就会调用下面讲到的Promise.resolve()方法,将参数转为Promise实例,再进一步处理。(Promise.all方法的参数,可以不是数组,但必须具有Iterator接口,且返回的每个成员都是Promise实例)。

p的状态,由p1,p2,p3决定,分成两种情况:
(1)只有p1,p2,p3的状态,都是fulfilled,p的状态才会变成fulfilled,此时p1,p2,p3的返回值组成一个数组,返回给p的回调函数。

(2)只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时,第一个被rejected的实例的返回值,会传递给p的回调函数。

下面是一个具体的例子:

const promises =  [2, 3, 5, 7, 11, 13].map(function(id){
        return getJSON('post'+id+'.json');
  })

Promise.all(promises).then(function(posts){
  //...
}).catch(function(reason){
  //...
})

上面代码中,promises是包含 6 个 Promise实例的数组,只有这 6 个实例的状态都变成fulfilled,或者其中有一个变为rejected,才会调用Promise.all方法后面的回调函数。

下面是另外一个例子:

const databasePromise = connectDatabase(); 

const booksPromise = databasePromise
  .then(findAllBooks);

const userPromise = databasePromise
  .then(getCurrentUser);

Promise.all([
  booksPromise,
  userPromise
])
.then(([books,user]) => pickTopRecommentations(books,user));

上面代码中,booksPromiseuserPromise是两个异步操作,只有等到它们的结果都返回了,才会触发pickTopRecommentations这个回调函数。

注意,如果作为参数的Promise 实例,自己定义了catch方法,那么它一旦被rejected,并不会触发Promise.all()catch方法。

const p1 = new Promise((resolve,reject) => {
    resolve('hello');
})
.then(result => result)
.catch(e => e);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result)
.catch(e => e);

Promise.all([p1,p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// ["hello", Error: 报错了]

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

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

const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result);

Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// Error: 报错了

七、Promise.race()

Promise.race方法同样是将多个 Promise 实例,包装成一个新的 Promise 实例。

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

上面代码中,只要p1,p2,p3之中,有一个实例率先改变状态,p的状态就会跟着改变,那个率先改变的Promise 实例的放回值,就会传递给p的回调函数。

Promise.race方法的参数与Promise.all方法一样,如果不是 Promise实例,就会先调用下面讲到的Promise.resolve方法,将参数转为 Promise 实例,再进一步处理。

下面是一个例子,如果指定时间内没有获得结果,就将 Promise的状态变为reject,否则变为resolve

const p = Promise.race([
  fetch('/resource-that-may-take-a-while'),
  new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('request timeout')), 5000)
  })
])
p
.then(console.log)
.catch(console.error)

上面代码中,如果 5 秒之内fetch方法无法返回结果,变量p的状态就会变为rejected,从而触发catch方法指定的回调函数。


八、Promise.resolve()

有时需要将现有对象转为 Promise 对象,Promise.resolve方法就起到这个作用。

const jsPromise = Promise.resolve($.ajax('/whatever.json'));

上面代码将 jQuery 生成的deferred对象,转为一个新的 Promise 对象。

Promise.resolve等价于下面的写法。

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

Promise.resolve方法的参数分成四种情况。
(1)参数是一个Promise实例:

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

(2)参数是一个thenable对象:
thenable对象指的是具有then方法的对象,比如下面这个对象。

let thenable = {
    then:function(resolve,reject){
    resolve(32);
}
}

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

let thenable = {
    then:function(resolve,reject){
    resolve(32);
}
}
const p = Promise.resolve(thenable)
.then(function(value){
    console.log(value)  //32
})

上面代码中,thenable对象的then方法执行后,对象p1的状态就变为resolved,从而立即执行最后那个then方法指定的回调函数,输出32

(3)参数不是具有then方法的对象,或根本就不是对象:
如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的 Promise 对象,状态为resolved。

const p = Promise.resolve('hello');
p.then(function(s){
    console.log(s);
})
//hello

上面代码生成一个新的 Promise 对象的实例p。由于字符串Hello不属于异步操作(判断方法是字符串对象不具有 then 方法),返回 Promise 实例的状态从一生成就是resolved,所以回调函数会立即执行。Promise.resolve方法的参数,会同时传给回调函数。

(4)不带有任何参数:
Promise.resolve方法允许调用时不带参数,直接返回一个resolved状态的 Promise 对象。

所以,如果希望得到一个 Promise 对象,比较方便的方法就是直接调用Promise.resolve方法。

const p = Promise.resolve();
p.then(function(){
    console.log('hello')
})

上面代码的变量p就是一个 Promise对象。

需要注意的是,立即resolve的 Promise 对象,是在本轮“事件循环”(event loop)的结束时,而不是在下一轮“事件循环”的开始时。

setTimeout(function(){
    console.log('three');
},0)

Promise.resolve().then(function(){
    console.log('two');
})

console.log('one');

//one
//two
//three

上面代码中,setTimeout(fn, 0)在下一轮“事件循环”开始时执行。
Promise.resolve()在本轮“事件循环”结束时执行,console.log('one')则是立即执行,因此最先输出。


九、Promise.reject()

Promise.reject(reason)方法,也会返回一个新的Promise实例,该实例的状态为rejected

const p = Promise.reject('出错了');
//等同于
const p = new Promise((resolve,reject) => reject('出错了'))
p.then(null,function(s){
    console.log(s);
})
//出错了

上面代码生成一个 Promise 对象的实例p,状态为rejected,回调函数会立即执行。

注意,Promise.reject()方法的参数,会原封不动地作为reject的理由,变成后续方法的参数。这一点与Promise.resolve方法不一致。

const thenable = {
    then(resolve,reject){
    reject('出错了')
}
}

Promise.reject(thenable)
.catch( e =>{
  console.log(e === thenable);
})

上面代码中,Promise.reject的参数是一个thenable对象,执行以后,后面catch方法的参数不是reject抛出的“出错了”这个字符串,而是thenable对象。


十、应用:
加载图片

我们可以将图片的加载写成一个Promise,一旦加载完成,Promise的状态就发生变化。

const preloadImage = function(path){
    return new Promise(function(resolve,reject){
    const image = new Image();
    image.onload = resolve;
    image.onerror = reject;
    image.src = path;
});
};

Generator函数与Promise的结合
使用 Generator 函数管理流程,遇到异步操作的时候,通常返回一个Promise对象。

function getFoo () {
  return new Promise(function (resolve, reject){
    resolve('foo');
  });
}

const g = function* () {
  try {
    const foo = yield getFoo();
    console.log(foo);
  } catch (e) {
    console.log(e);
  }
};

function run (generator) {
  const it = generator();

  function go(result) {
    if (result.done) return result.value;

    return result.value.then(function (value) {
      return go(it.next(value));
    }, function (error) {
      return go(it.throw(error));
    });
  }

  go(it.next());
}

run(g);

上面代码的 Generator 函数g之中,有一个异步操作getFoo,它返回的就是一个Promise对象。函数run用来处理这个Promise对象,并调用下一个next方法。


十一、Promise.try()

实际开发中,经常遇到一种情况:不知道或者不想区分,函数f是同步函数还是异步操作,但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作,都用then方法指定下一步流程,用catch方法处理f抛出的错误。一般就会采用下面的写法。

Promise.resolve.then(f)

上面的写法有一个缺点,就是如果f同步函数,那么它会在本轮事件循环的末尾执行。

const f = () => console.log('now');
Promise.resolve().then(f)
console.log('next');
//next
//now

上面代码中,函数f是同步的,但是用 Promise 包装了以后,就变成异步执行了。

那么有没有一种方法,让同步函数同步执行,异步函数异步执行,并且让它们具有统一的 API 呢?回答是可以的,并且还有两种写法。第一种写法是用async函数来写。

const f = () => console.log('now');
(async() => f())();
console.log('next');
//now
//next

上面代码中,第二行是一个立即执行的匿名函数,会立即执行里面的async函数,因此如果f是同步的,就会得到同步的结果;如果f是异步的,就可以用then指定下一步,就像下面的写法。

(async() => f())()
.then(...)

需要注意的是,async () => f()会吃掉f()抛出的错误。所以,如果想捕获错误,要使用promise.catch方法。

(async() => f())()
.then(...)
.actch(...)

第二种写法是使用 new Promise()

const f = () => console.log('now');
(
  () => new Promise(
    resolve => resolve(f())
  )
)();
console.log('next');
//now
//next

上面代码也是使用立即执行的匿名函数,执行new Promise()。这种情况下,同步函数也是同步执行的。

鉴于这是一个很常见的需求,所以现在有一个提案,提供Promise.try方法替代上面的写法。

const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next

事实上,Promise.try存在已久,Promise 库BluebirdQwhen,早就提供了这个方法。

由于Promise.try为所有操作提供了统一的处理机制,所以如果想用then方法管理流程,最好都用Promise.try包装一下。这样有许多好处,其中一点就是可以更好地管理异常。

function getUsername(userId){
    return database.user.
}
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,688评论 1 330
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,559评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,749评论 0 226
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,581评论 0 191
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,741评论 3 271
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,684评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,122评论 2 292
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,847评论 0 182
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,441评论 0 228
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,939评论 2 232
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,333评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,783评论 2 236
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,275评论 3 220
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,830评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,444评论 0 180
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,553评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,618评论 2 249

推荐阅读更多精彩内容