在测试中,我发现JavaScript承诺始终是异步的,无论它们的链中是否包含任何异步函数。
这是一些代码,显示了控制台中的操作顺序。如果您运行它,您将看到即使每个函数都是同步的,输出也会显示两个aPromise()
并行运行的调用,并且"surprisingly this happens after run 2 finishes"
不会在运行2完成之前发生。
function aPromise() {
return new Promise(function(resolve, reject) {
console.log("making promise A")
resolve(bPromise());
console.log("promise A resolved")
});
}
function bPromise() {
return new Promise(function(resolve, reject) {
console.log("making and resolving promise B")
resolve();
});
}
aPromise().then(function() {
console.log("finish run 1");
}).then(function() {
console.log("surprisingly this happens after run 2 finishes");
});
aPromise().then(function() {
console.log("finish run 2");
})
输出到控制台:
making promise A
making and resolving promise B
promise A resolved
making promise A
making and resolving promise B
promise A resolved
finish run 1
finish run 2
surprisingly this happens after run 2 finishes
那么,为什么JavaScript仅在调用同步函数时承诺异步?导致这种行为的幕后发生了什么?
PS为了更好地理解这一点,我实现了自己的Promise系统,发现使同步功能按预期顺序执行很容易,但是使它们并行执行是我只能通过将setTimeout()设置为几毫秒来实现的功能每一个解决方案(我的猜测是香草诺言并没有发生这种情况,它们实际上是多线程的)。
对于我的一个程序来说,这是一个小问题,我正在遍历一棵树,将一个函数数组应用于每个节点,如果该节点已在运行异步函数,则将这些函数放入队列中。大多数功能都是同步的,因此很少使用队列,但是在从回调(地狱)切换到Promises时,我一直遇到一个问题,即由于Promises从未同步运行,因此几乎总是使用队列。这不是一个很大的问题,但有点像调试的噩梦。
1年后编辑
我最终写了一些代码来解决这个问题。这不是很彻底,但是我已经成功地使用它来解决我遇到的问题。
var SyncPromise = function(fn) {
var syncable = this;
syncable.state = "pending";
syncable.value;
var wrappedFn = function(resolve, reject) {
var fakeResolve = function(val) {
syncable.value = val;
syncable.state = "fulfilled";
resolve(val);
}
fn(fakeResolve, reject);
}
var out = new Promise(wrappedFn);
out.syncable = syncable;
return out;
}
SyncPromise.resolved = function(result) {
return new SyncPromise(function(resolve) { resolve(result); });
}
SyncPromise.all = function(promises) {
for(var i = 0; i < promises.length; i++) {
if(promises[i].syncable && promises[i].syncable.state == "fulfilled") {
promises.splice(i, 1);
i--;
}
// else console.log("syncable not fulfilled" + promises[i].syncable.state)
}
if(promises.length == 0)
return SyncPromise.resolved();
else
return new SyncPromise(function(resolve) { Promise.all(promises).then(resolve); });
}
Promise.prototype.syncThen = function (nextFn) {
if(this.syncable && this.syncable.state == "fulfilled") {
//
if(nextFn instanceof Promise) {
return nextFn;
}
else if(typeof nextFn == "function") {
var val = this.syncable.value;
var out = nextFn(val);
return new SyncPromise(function(resolve) { resolve(out); });
}
else {
PINE.err("nextFn is not a function or promise", nextFn);
}
}
else {
// console.log("default promise");
return this.then(nextFn);
}
}
传递给Promise构造函数的回调总是被同步调用,但是传递给回调的回调then
总是被异步调用(您可以在userland实现中setTimeout
延迟使用0
来实现)。
简化您的示例(并提供匿名函数的名称,以便我可以引用它们):
Promise.resolve().then(function callbackA () {
console.log("finish run 1");
}).then(function callbackB () {
console.log("surprisingly this happens after run 2 finishes");
});
Promise.resolve().then(function callbackC () {
console.log("finish run 2");
})
仍然以相同的顺序给出输出:
finish run 1
finish run 2
surprisingly this happens after run 2 finishes
事件按以下顺序发生:
解决该问题的最简单方法是使用具有Promise.prototype.isFulfilled函数的库,该函数可用于决定是否同步调用第二个回调。例如:
var Promise = require( 'bluebird' );
Promise.prototype._SEPH_syncThen = function ( callback ) {
return (
this.isPending()
? this.then( callback )
: Promise.resolve( callback( this.value() ) )
);
}
Promise.resolve()._SEPH_syncThen(function callbackA () {
console.log("finish run 1");
})._SEPH_syncThen(function callbackB () {
console.log("surprisingly this happens after run 2 finishes");
});
Promise.resolve()._SEPH_syncThen(function callbackC () {
console.log("finish run 2");
})
输出:
finish run 1
surprisingly this happens after run 2 finishes
finish run 2
本文收集自互联网,转载请注明来源。
如有侵权,请联系[email protected] 删除。
我来说两句