问题描述
Promise 和生成器允许您编写异步代码.我不明白为什么 ECMA 脚本 6 中引入了这两种机制.什么时候最好使用 promise，什么时候使用生成器?
Promises and generators allow you to write asynchronous code. I do not understand why both of these mechanisms are introduced in ECMA script 6. When is it best to use the promises, and when the generators?
推荐答案
这两种技术之间没有对立:它们共存在一起，相得益彰.
There is no opposition between these two techniques: they coexist together complementing each other nicely.
Promises 允许您获取异步操作的结果，而该操作还没有.
它解决了末日金字塔问题.所以，而不是:
Promises allows you to get the result of an asynchronous operation which is not available yet.
It solves the Pyramid of Doom problem. So instead of:
function ourImportantFunction(callback) {
//... some code 1
task1(function(val1) {
//... some code 2
task2(val1, function(val2) {
//... some code 3
task3(val2, callback);
});
});
}
你可以写:
function ourImportantFunction() {
return Promise.resolve()
.then(function() {
//... some code 1
return task1(val3)
})
.then(function(val2) {
//... some code 2
return task2(val2)
})
.then(function(val2) {
//... some code 3
return task3(val2);
});
}
ourImportantFunction().then(callback);
但即使有 Promise，您也必须以异步方式编写代码 - 您必须始终将回调传递给函数.
编写异步代码比同步代码困难得多.即使有promise，当代码量很大时，也很难看懂算法(这是非常主观的，但对于大多数程序员我认为是真的).
But even with promises you must write code in asynchronous fashion - you must always pass callbacks to the functions.
Writing asynchronous code is much harder than synchronous. Even with promises, when the code is huge, it becomes difficult to see the algorithm (it's very subjective, but for the majority of programmers I think it's true).
所以我们想以同步方式编写异步代码.这就是生成器来帮助我们的地方.
您可以编写以下代码来代替上面的代码:
So we want to write asynchronous code in synchronous fashion. That's where generators are coming to help us.
Instead of the code above you can write:
var ourImportantFunction = spawn(function*() {
//... some code 1
var val1 = yield task1();
//... some code 2
var val2 = yield task2(val1);
//... some code 3
var val3 = yield task3(val2);
return val3;
});
ourImportantFunction().then(callback);
最简单的 spawn 实现可以是这样的:
where the simplest possible spawn realization can be something like:
function spawn(generator) {
return function() {
var iter = generator.apply(this, arguments);
return Promise.resolve().then(function onValue(lastValue){
var result = iter.next(lastValue);
var done = result.done;
var value = result.value;
if (done) return value; // generator done, resolve promise
return Promise.resolve(value).then(onValue, iter.throw.bind(iter)); // repeat
});
};
}
如您所见，value(某些异步函数task{N} 的结果)必须是一个promise.你不能用回调来做到这一点.
As you can see value (result of some asynchronous function task{N}) must be a promise. You can't do this with callbacks.
剩下要做的是在语言本身中实现spawn 技术.因此，我们将 spawn 替换为 async 并将 yield 替换为 await 并且即将使用 ES7 async/await:
What remains to do is to implement the spawn technique into the language itself. So we are replacing spawn with async and yield with await and are coming to ES7 async/await:
var ourImportantFunction = async function() {
//... some code 1
var val1 = await task1();
//... some code 2
var val2 = await task2(val1);
//... some code 3
var val3 = await task3(val2);
return val3;
}
我建议您观看此视频以了解更多内容和其他即将推出的内容技术.
提示:如果对方对你说得太快，请放慢播放速度(右下角的设置"，或者直接按 [shift + <])
I recommend you to watch this video to understand more this and some other coming techniques.
Hint: If the guy speaks too fast for you, slow down the speed of playing ("settings" in right bottom corner, or just push [shift + <])
什么是最好的:只有回调、promise 或带有生成器的 promise - 这是一个非常主观的问题.
回调是目前最快的解决方案(现在原生 Promise 的性能非常糟糕).带有生成器的 Promise 使您有机会以同步方式编写异步代码.但就目前而言，它们比简单的回调慢得多.
What is the best: only callbacks, or promises, or promises with generators - this is a very subjective question.
Callbacks is the fastest solution possible at this time (performance of native promises are very bad now). Promises with generators give you opportunity to write asynchronous code in synchronous fashion. But for now they are much slower than simple callbacks.
这篇关于JavaScript 异步编程:promise 与生成器的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，WP2