此文参考学习于 阮一峰老师《ES6入门》,更多特性以及方法可以点击查看
1.Promise 对象 是什么?
Promise 是异步编程的一种解决方案,相比传统的解决方案——回调函数和事件——更合理和更强大。
ES6将其写进了语言标准,统一了用法,原生提供了Promise对象。
Promise
,简单说就是一个容器。里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。- 从语法上说,
Promise
是一个对象,从它可以获取异步操作的消息。 Promise
提供统一的API
,各种异步操作都可以用同样的方法进行处理。
Promise对象有以下两个特点:
- 对象的状态不受外界影响。
Promise
对象代表一个异步操作,有三种状态:pending
(进行中)、fulfilled
(已成功)和rejected
(已失败)。
只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。
- 一旦状态改变,就不会再变,任何时候都可以得到这个结果。
Promise
对象的状态改变,只有两种可能: 从 pending
变为 fulfilled
或者从 pending
变为 rejected
。
只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果,这时就称为 resolved
(已定型)
如果改变已经发生了,你再对 Promise
对象添加回调函数,也会立即得到这个结果。
(这与事件(Event)完全不同,事件的特点是,如果你错过了它,再去监听,是得不到结果的。)
- 有了
Promise
对象,就可以将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。 - 此外,
Promise
对象提供统一的接口,使得控制异步操作更加容易。
Promise
也有一些缺点。
- 首先,无法取消
Promise
,一旦新建它就会立即执行,无法中途取消。 - 其次,如果不设置回调函数,
Promise
内部抛出的错误,不会反应到外部。 - 当处于
pending
状态时,无法得知目前进展到哪一个阶段,开始或是完成。
如果某些事件不断地反复发生,一般来说,使用
Stream
模式是比部署Promise
更好的选择。
2.基本用法
ES6 规定,Promise对象是一个构造函数,用来生成Promise实例。
Promise构造函数接受一个函数作为参数,该函数有两个参数resolve
和reject
。它们是两个函数,由 JavaScript 引擎提供,不用自己部署。
-
resolve
:此函数将Promise
对象的状态从“未完成”变为“成功”(即从pending
变为resolved
),在异步操作成功时调用,并将异步操作的结果,作为参数传递出去 -
reject
:此函数将Promise
对象的状态从“未完成”变为“失败”(即从pending
变为rejected
),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。
const promise = new Promise( function (resolve,reject){
resolve('success1') //操作成功时,将参数带入回调函数
})
promise.then(function (value){//操作成功时所执行的回调 函数
console.log(value) //打印 success1
})
Promise
实例生成以后,可以用then
方法分别指定resolved
状态和rejected
状态的回调函数。
promise.then(function(value) {
// success
}, function(error) {
// failure
});
then
方法可以接受两个回调函数作为参数。
第一个回调函数是 Promise 对象的状态变为resolved时调用
第二个回调函数是 Promise 对象的状态变为rejected时调用(此回调函数可选)
这两个函数都接受 Promise 对象传出的值作为参数。
上面的例子说明了,调用resolve函数和reject函数时如果带有参数,那么它们的参数会被传递给回调函数。
reject
函数的参数通常是Error
对象的实例,表示抛出的错误;
resolve
函数的参数除了正常的值以外,还可能是另一个 Promise
实例,比如像下面这样。
const p1 = new Promise(function (resolve, reject) {
// ...
});
const p2 = new Promise(function (resolve, reject) {
// ...
resolve(p1);
})
注意:这时 p1 的状态就会传递给 p2 ,也就是说, p1 的状态决定了 p2 的状态。如果 p1 的状态是 pending
,那么 p2 的回调函数就会等待 p1 的状态改变;如果 p1 的状态已经是 resolved
或者 rejected
,那么 p2 的回调函数将会立刻执行。
下面是一个 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最后输出。
下面看一个 Promise 嵌套的例子
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
在 3 秒后改变状态为 rejected
。p2
的状态在 1 秒后改变。但是由于 p2 中 resolve
的参数为一个 Promise,导致 p2
执行完后,自身状态无效,then
方法不会对 p2
执行。这时,p2
等 p1
改变状态后,由 p1
来决定 p2
的状态。 后面的 then
方法都变成针对 p1
。又过了 2 秒,p1变为rejected
,导致触发catch
方法指定的回调函数
值得注意的是:简便的 Promise 链式编程最好保持扁平化,不要嵌套 Promise。
注意:调用resolve
或reject
并不会终结 Promise 的参数函数的执行。若 Promise 抛出错误,则不会往下执行
new Promise((resolve, reject) => {
resolve(1);
console.log(2);
}).then(r => {
console.log(r);
});
// 2
// 1
var promise = new Promise(
(resolve,reject) => {
new Error('出错了');
console.log('11') //不会执行,无输出
})
promise.catch(
(e) => {
console.log('asdas',e);
console.log('1')//继续执行,输出1
})
resolved
是在本轮事件循环的末尾执行,总是晚于本轮循环的同步任务。
一般来说,调用
resolve
或reject
以后,Promise 的使命就完成了,后继操作应该放到then
方法里面。 如果要避免
Promise 调用函数后在执行其他操作,最好在它们前面加上return
语句,这样就不会有意外。
3.方法
3.1Promise.prototype.then()
Promise 实例具有then
方法
也就是说,then
方法是定义在原型对象 Promise.prototype上的。
作用:为 Promise 实例添加状态改变时的回调函数。
参数:第一个参数是resolved
状态的回调函数,第二个参数(可选)是rejected
状态的回调函数。
then
方法返回的是一个新的 Promise 实例(注意,不是原来那个Promise实例)。因此可以采用链式写法,即then
方法后面再调用另一个then
方法或者其他方法。
采用链式的then
,可以指定一组按照次序调用的回调函数。这时,前一个回调函数,有可能返回的还是一个 Promise对象(即有异步操作),这时后一个回调函数,就会等待该 Promise 对象的状态发生变化,才会被调用。
getJSON("/post/1.json").then(function(post) {
return getJSON(post.commentURL);
}).then(function (comments) {
console.log("resolved: ", comments);
}, function (err){
console.log("rejected: ", err);
});
上面代码中,第一个`then`方法指定的回调函数,返回的是另一个`Promise`对象。这时,第二个`then`方法指定的回调函数,就会等待这个新的`Promise`对象状态发生变化。如果变为`resolved`,就调用第一个回调函数,如果状态变为`rejected`,就调用第二个回调函数。
3.2.Promise.prototype.catch()
Promise.prototype.catch
方法是.then(null, rejection)
或.then(undefined, rejection)
的别名,用于指定发生错误时的回调函数。
getJSON('/posts.json').then(function(posts) {
// ...
}).catch(function(error) {
// 处理 getJSON 和 前一个回调函数运行时发生的错误
console.log('发生错误!', error);
});
上面代码中,getJSON方法返回一个 Promise
对象,如果该对象状态变为resolved
,则会调用then
方法指定的回调函数;如果异步操作抛出错误,状态就会变为rejected
,就会调用catch
方法指定的回调函数,处理这个错误。另外,then
方法指定的回调函数,如果运行中抛出错误,也会被catch
方法捕获。
const promise = new Promise(function(resolve, reject) {
throw new Error('test');
});
promise.catch(function(error) {
console.log(error);
});
// Error: test
上面代码中,promise抛出一个错误,就被catch方法指定的回调函数捕获。注意,上面的写法与下面两种写法是等价的。
注:如果 Promise 状态已经变成resolved
,再抛出错误是无效的。
const promise = new Promise(function(resolve, reject) {
resolve('ok');
throw new Error('test');
});
promise
.then(function(value) { console.log(value) })
.catch(function(error) { console.log(error) });
// ok
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 状态的回调函数。但是最好可以使用catch
方法
const promise = function() {
return new Promise(function(resolve, reject) {
resolve(x + 2); //此行会报错,因为x没有声明
});
};
promise().then(function() {
console.log('everything is great');
});
setTimeout(() => { console.log(123) }, 2000);
// Uncaught (in promise) ReferenceError: x is not defined
// 123
当 promise
执行时,会打印出错误提示 ReferenceError: x is not defined
,但是并不会终止脚本执行,还是会按正常状态执行下去。
这就是说,Promise
内部的错误不会影响到 Promise
外部的代码,通俗的说法就是“Promise
会吃掉错误”。
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 中设置了 setTimeout,指定在下一轮“事件循环”再抛出错误。到了那个时候,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
方法。
如果then
方法中有报错情况,那也跟前面的catch
无关了。
catch
方法之中,还能再抛出错误。
const someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错,因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
return someOtherAsyncThing();
}).catch(function(error) {
console.log('oh no', error);
y + 2; // 这一行会抛出错误,因为 y 没有声明
}).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
方法抛出的错误。
3.3.Promise.prototype.finally()
finally
方法跟字面意思一样(完成时调用),用于指定不管 Promise 对象最后状态如何,都会执行的操作。该方法是 ES2018
引入标准的。
promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});
上面代码中,不管 promise 最后的状态,在执行完then
或catch
指定的回调函数以后,都会执行finally
方法指定的回调函数。
finally
方法的回调函数不接受任何参数,没有办法知道,前面的 Promise 状态到底是fulfilled
还是rejected
。
这表明,finally
方法里面的操作,应该是 与状态无关 的,不依赖于 Promise 的执行结果。
finally
本质上是then
方法的特例。
promise
.finally(() => {
«statements»
});
//等价于
promise
.then(
result => {
«statements»
return result;
},
error => {
«statements»
throw error;
}
);
来看看 finally
方法的实现
Promise.prototype.finally = function (callback) {
let P = this.constructor; // 记录 Promise 对象
return this.then(
value => P.resolve(callback()).then(() => value),// 若是 promise 状态为 resolved 调用此处的函数
reason => P.resolve(callback()).then(() => { throw reason }) // 若是 promise 状态为 reject 调用此处的函数
);
};
上面代码中,不管前面的 Promise 是fulfilled
还是rejected
,都会执行回调函数callback
。
从上面的实现还可以看到,因为 resolve()
中的参数为 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(() => {})
注意:finally
方法本身无异常抛出的情况下,总是会返回原来的 Promise 对象值;若抛出异常,则返回异常的 Promise 对象。
3.4.Promise.all()
Promise.all()
方法用于将多个 Promise 实例,包装成一个新的 Promise 实例。然后根据参数的(Promise的实例)状态来决定Promise.all()
的执行
const p = Promise.all([p1, p2, p3]);
上面代码中,Promise.all()
方法接受一个数组作为参数,p1、p2、p3 都必须是 Promise 实例
Promise.all()
方法接受一个数组作为参数- 参数必须是 Promise 的实例,如果不是就会先调用
Promise.resolve
方法,将参数转为 Promise 实例,再进一步处理。 Promise.all()
方法的参数可以不是数组,但必须具有 Iterator 接口。
p (用了 all 方法的实例)的状态由传入的参数(Promise)决定,分成两种情况。
- 只有参数的状态都变成
fulfilled
,p 的状态才会变成fulfilled
,此时参数的返回值组成一个数组,传递给p的回调函数。 - 只要参数之中有一个状态变成
rejected
,p 的状态就变成rejected
,此时第一个被reject
的实例的返回值,会传递给p的回调函数。
下面是一个具体的例子。
// 生成一个Promise对象的数组
const promises = [2, 3, 5, 7, 11, 13].map(function () {
//...(返回数组的操作)
});
Promise.all(promises).then(function (posts) {
// ...
}).catch(function(reason){
// ...
});
上面代码中,promises
是一个数组,它包含 6 个 Promise 的实例。
只有两种情况可以触发Promise.all
方法后面的回调函数。
- 6 个实例的状态都变成
fulfilled
或 其中有一个实例的状态变为rejected
注意:如果作为参数的 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: 报错了]
上面代码中,p1 会resolved
,p2 会rejected
,但是 p2 有自己的catch
方法,抛出的错误会先被自己的 catch
捕获, p2 指向的实际上是这个实例。执行完catch
返回实例后,该实例的状态也会变成resolved
,导致Promise.all()
方法参数里面的两个实例都会resolved
,因此会调用then
方法指定的回调函数,而不会调用catch
方法指定的回调函数。
- 从上面的例子可以看出,只有当 Promise 实例的状态确定时,
Promise.all()
方法才会启用 - 如果p2没有自己的
catch
方法,就会调用Promise.all()
的catch
方法。
3.5.Promise.race()
Promise.race()
方法同样是将多个 Promise 实例,包装成一个新的 Promise 实例。然后根据参数的(Promise的实例)状态来决定Promise.all()
的执行
const p = Promise.race([p1, p2, p3]);
上面代码中,只要p1、p2、p3之中有一个实例率先改变状态,p 的状态就跟着改变。那个率先改变的 Promise 实例的返回值(或 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);
上面的代码,如果 fetch
方法 5 秒内获取到了数据,Promise 状态改变为 resolve。若是没有获取到,则race
方法的第二个参数执行,抛出一个错误,状态为reject
3.6Promise.allSettled()
Promise.allSettled()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。
只有等到所有这些参数实例都返回结果(不管是fulfilled
还是rejected
),包装实例才会(执行操作)结束。该方法由 ES2020 引入。
const promises = [
fetch('/api-1'),
fetch('/api-2'),
fetch('/api-3'),
];
await Promise.allSettled(promises);
removeLoadingIndicator();//移除加载函数
上面代码对服务器发出三个请求,等到三个请求都结束,不管请求成功还是失败,加载的滚动图标就会消失。
await
操作符用于等待一个Promise 对象。它只能在异步函数 async function 中使用。
返回值: 返回 Promise 对象的处理结果。如果等待的不是 Promise 对象,则返回该值本身。
const p1 = Promise.resolve(42)
const p2 = Promise.reject(1)
const p = Promise.allSettled([p1,p2])
p.then((e) => console.log(e))
// [
// { status: 'fulfilled', value: 42 },
// { status: 'rejected', reason: 1 }
// ]
上面的代码中,Promise.allSettled() 方法的返回值,状态只可能变成 fulfilled。allSettled 方法的参数成员(对象),对应的传入Promise.allSettled()方法中。
每一个实例都有自己的属性:
status
属性,该属性的值只可能是字符串fulfilled
或字符串rejected
。- 当
status
属性的值为fulfilled
时,对象有value
属性 - 当
status
属性的值为rejected
时有reason
属性
有时候,我们不关心异步操作的结果,只关心这些操作有没有结束。这时,
Promise.allSettled()
方法就很有用。如果没有这个方法,想要确保所有操作都结束,就很麻烦。Promise.all()
方法无法做到这一点。
下面是返回值用法的例子。
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
// [
// { status: ..., value/reason: ... },
// { status: ..., value/reason: ... }
// ]
// 过滤出成功的请求
const successfulPromises = results.filter(p => p.status === 'fulfilled');
// 过滤出失败的请求,并输出原因
const errors = results
.filter(p => p.status === 'rejected')
.map(p => p.reason);
3.7.Promise.any()
Promise.any()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。
与 Promise.all() 相反。只要参数实例有一个变成fulfilled
状态,包装实例就会变成fulfilled
状态;如果所有参数实例都变成rejected
状态,包装实例就会变成rejected
状态。该方法目前是一个第三阶段的提案 。
警告!该Promise.any()方法是实验性的,并非所有浏览器都完全支持。
Promise.any()
方法抛出的错误,不是一个一般的错误,而是一个 AggregateError 实例。
它相当于一个数组,每个成员对应一个被rejected
的操作所抛出的错误。
下面是一个例子。
var resolved = Promise.resolve(42);
var rejected = Promise.reject(-1);
var alsoRejected = Promise.reject(Infinity);
Promise.any([resolved, rejected, alsoRejected]).then(function (result) {
console.log(result); // 42 ;参数中的 resolved实例为 resolve,导致只对它进行操作
});
Promise.any([rejected, alsoRejected]).catch(function (results) {
console.log(results); // [-1, Infinity] ;参数中的实例都是 reject 状态,所以输出一个数组。
});
3.8.Promise.resolve()
Promise.resolve()
方法可以将现有对象转为 Promise 对象并使用 resolve() 方法。返回一个新 Promise的实例
const jsPromise = Promise.resolve($.ajax('/whatever.json'));
上面代码将 jQuery 生成的deferred对象,转为一个新的 Promise 对象。
Promise.resolve()
等价于下面的写法。
Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))
Promise.resolve
方法的参数分成四种情况。
- 是一个 Promise 实例:此时
Promise.resolve()
将不做任何修改、原封不动地返回这个实例。 - 是一个 thenable 对象:
Promise.resolve
会将这个对象转为 Promise 对象,然后就立即执行thenable
对象的then
方法。
thenable
对象指的是具有then
方法的对象,比如下面这个对象。
let thenable = {
then(resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
p1.then(function(value) {
console.log(value); // 42
});
-
不是具有then方法的对象,或根本就不是对象:则
Promise.resolve
方法返回一个新的 Promise 对象,状态为resolved
。 -
不带有任何参数:
Promise.resolve()
方法允许调用时不带参数,直接返回一个resolved
状态的 Promise 对象。
所以,如果希望得到一个状态为resolve
的 Promise 对象,比较方便的方法就是直接调用Promise.resolve()
方法。
注意:立即resolve()
的 Promise 对象,是在本轮“事件循环”(event loop)的结束时执行,而不是在下一轮“事件循环”的开始时。
setTimeout(function () {
console.log('three');
}, 0);
Promise.resolve().then(function () {
console.log('two');
});
console.log('one');
// one
// two
// three
3.9.Promise.reject()
Promise.reject(reason)
方法也会返回一个新的 Promise 实例,与Promise.resolve()
相反,该实例的状态为rejected。
与 Promise.resolve(),但值得注意的是,Promise.reject()
方法的参数,会原封不动地作为 reject 的理由(带入后续操作中),变成后续方法的参数。这一点与Promise.resolve
方法不一致。
const thenable = {
then(resolve, reject) {
reject('出错了');
}
};
Promise.reject(thenable)
.catch(e => {
console.log(e === thenable)
})
// true
上面代码中,Promise.reject
方法的参数是一个thenable
对象,执行以后,后面catch方法的参数不是reject
抛出的“出错了”这个字符串,而是thenable
对象。
4.应用
加载图片
我们可以将图片的加载写成一个Promise,一旦加载完成,Promise的状态就发生变化。
const preloadImage = function (path) {
return new Promise(function (resolve, reject) {
const image = new Image(); // 建立图像对象
image.onload = resolve; // image的onload事件触发时改变状态
image.onerror = reject; // image的onerror事件触发时改变状态
image.src = path; // src 属性一定要写到 onload 事件的后面,否则程序在 IE 中会出错。
});
};
Image()
构造函数创建一个新的 HTMLImageElement 实例。在功能上等效document.createElement('img')
。
简单来说就是用 JS 来创造一个 img 标签,并规定它的属性
var img = new Image(width,height)两个参数,宽度和高度,不用 带单位
Generator 函数与 Promise 的结合
使用 Generator 函数管理流程,遇到异步操作的时候,通常返回一个 Promise 对象。
function getFoo () { // 定义函数 执行时返回 Promise 对象状态为 resolve
return new Promise(function (resolve, reject){
resolve('foo');
});
}
const g = function* () { //定义Generator函数
try {
const foo = yield getFoo();
console.log(foo);
} catch (e) {
console.log(e);
}
};
function run (generator) {
const it = generator(); //返回此函数的遍历器对象
function go(result) { // 传入 Promise 对象
if (result.done) return result.value; //done 为 false ,不执行;否则返回一个Promise对象,状态为 resolve
//对返回的Promise对象进行操作
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
方法。
5.Promise.try()
有时候,不知道(或者不想区分),函数是同步函数还是异步操作,但是想用 Promise
来处理它。因为这样就可以不管函数是否包含异步操作,都用then
方法指定下一步流程,用catch
方法处理函数抛出的错误。一般就会采用下面的写法。
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())()
.then(...)
例一中,第三行是一个立即执行的匿名函数,会立即执行里面的async
函数,因此如果f
是同步的,就会得到同步的结果;如果f
是异步的,就可以用then
指定下一步,就像例二的写法。
需要注意的是,async () => f()
会吃掉f()
抛出的错误。所以,如果想捕获错误,要使用promise.catch
方法。
(async () => f())()
.then(...)
.catch(...)
- 第二种:使用
new Promise()
。
事实上,
Promise.try
就是模拟try
代码块,就像promise.catch
模拟的是catch
代码块。
const f = () => console.log('now');
(
() => new Promise(
resolve => resolve(f())
)
)();
console.log('next');
// now
// next
上面代码也是使用立即执行的匿名函数,执行new Promise()
。这种情况下,同步函数f()
也是同步执行的。
鉴于这是一个很常见的需求,所以现在有一个提案,提供 Promise.try 方法替代上面的写法。
const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next
Promise.try
为所有操作提供了统一的处理机制- 如果想用
then
方法管理流程,最好都用Promise.try
包装一下。这样有许多好处,其中一点就是可以更好地管理异常。
6.总结
Promise 对象的内容很多,下面来概括梳理一下
Promise对象的两个特点 :
- 对象的状态不受外界影响
- 一旦状态改变,就不会再变,任何时候都可以得到这个结果。
优缺点
优点:
- 简单来说 Promise 本质上其实就是用同步的方法表达异步操作,有了 Promise 对象,就可以实现更加清晰的异步操作,避免了回调地狱的出现。
- 原生提供的
API
,更加方便操作。
缺点:
- 无法取消Promise,一旦新建它就会立即执行,无法中途取消。
- 如果不设置回调函数,
Promise
内部抛出的错误,不会反应到外部。 - 当处于
pending
状态时,无法得知目前进展到哪一个阶段,开始或是完成。
方法归纳
Promise.prototype.then()
:Promise状态改变时触发回调的操作Promise.prototype.catch()
:Promise(状态为 reject)抛出错误时触发回调Promise.prototype.finally()
:Promise完成时,执行回调Promise.resolve()
:将对象转为 Promise 对象 ,并立即执行并 resolve() 方法(then),返回一个新的 Promise 实例(状态为resolved)Promise.reject()
:将对象转为 Promise 对象 ,并立即执行并 reject 方法,返回一个新的 Promise 实例
包装实例方法
这些方法都是 包装多个 Promise 的实例,返回一个新的 Promise 实例,根据多个 参数的状态来决定自身的状态
Promise.all()
:
当参数的状态都变成fulfilled
,自己的状态才会变成fulfilled
参数之中有一个状态变成rejected
,自己的状态就变成rejected
Promise.race()
:只要参数之一的状态改变,那么就自身的状态就改变,自己状态跟第一个改变的参数的状态一样Promise.allSettled()
:只有参数的状态完全改变,自身的状态才会改变,返回各个参数成员的状态和属性。此方法主要用来判断 Promise 实例有没有结束以及返回的状态和一些结果操作Promise.any()
:此处的状态改变与Promise.all()
方法完全相反