JavaScript常常声称是_异步_。那是什么意思？它怎样影响生长？近年来这类要领有何变化？
请思索以下代码：
result1 = doSomething1();
result2 = doSomething2(result1);大多数言语都处置惩罚每一行同步。第一行运转并返回效果。第二行在第一行完成后运转不管须要多长时间。
单线程处置惩罚
JavaScript在单个处置惩罚线程上运转。在浏览器选项卡中实行时，其他一切内容都邑住手，由于在并行线程上不会发作对页面DOM的变动;将一个线程重定向到另一个URL而另一个线程尝试追加子节点是风险的。
这对用户来说是不言而喻。比方，JavaScript检测到按钮单击，运转盘算并更新DOM。完成后，浏览器能够自在处置惩罚行列中的下一个项目。
（旁注：其他言语如PHP也运用单个线程，但能够由多线程服务器（如Apache）治理。同时对同一个PHP运转时页面的两个要求能够启动两个运转断绝的实例的线程。）
运用回调举行异步
单线程引发了一个题目。当JavaScript挪用“慢”历程（比方浏览器中的Ajax要求或服务器上的数据库操纵）时会发作什么？这个操纵能够须要几秒钟 – 以至几分钟。浏览器在守候相应时会被锁定。在服务器上，Node.js应用程序将没法进一步处置惩罚用户要求。
解决计划是异步处置惩罚。而不是守候完成，一个历程被示知在效果准备好时挪用另一个函数。这称为callback，它作为参数通报给任何异步函数。比方：
doSomethingAsync(callback1);
console.log('finished');
// call when doSomethingAsync completes
function callback1(error) {
if (!error) console.log('doSomethingAsync complete');
}doSomethingAsync（）吸收一个回调函数作为参数（只通报对该函数的援用，因而几乎没有开支）。doSomethingAsync（）须要多长时间并不主要;我们所晓得的是callback1（）将在未来的某个时刻实行。控制台将显现：
finished
doSomethingAsync complete回调地狱
一般，回调只能由一个异步函数挪用。因而能够运用简约的匿名内联函数：
doSomethingAsync(error => {
if (!error) console.log('doSomethingAsync complete');
});经由过程嵌套回调函数，能够串行完成一系列两个或多个异步挪用。比方：
async1((err, res) => {
if (!err) async2(res, (err, res) => {
if (!err) async3(res, (err, res) => {
console.log('async1, async2, async3 complete.');
});
});
});不幸的是，这引入了回调地狱 – 一个名誉扫地的观点(http://callbackhell.com/) ！代码难以浏览，而且在增加毛病处置惩罚逻辑时会变得更糟。
回调地狱在客户端编码中相对较少。假如您正在举行Ajax挪用，更新DOM并守候动画完成，它能够深切两到三个级别，但它一般依然能够治理。
操纵系统或服务器历程的状况差别。Node.js API挪用能够吸收文件上载，更新多个数据库表，写入日记，并在发送相应之前举行进一步的API挪用。
Promises
ES2015（ES6）推出了Promises。回调依然能够运用，但Promises供应了更清楚的语法chains异步敕令，因而它们能够串行运转（更多相干内容）。
要启用基于Promise的实行，必需变动基于异步回调的函数，以便它们马上返回Promise对象。该promises对象在未来的某个时刻运转两个函数之一（作为参数通报）：
- resolve ：处置惩罚胜利完成时运转的回调函数
- reject ：发作毛病时运转的可选回调函数。
鄙人面的示例中，数据库API供应了一个吸收回调函数的connect（）要领。外部asyncDBconnect（）函数马上返回一个新的Promise，并在竖立衔接或失利后运转resolve（）或reject（）：
const db = require('database');
// connect to database
function asyncDBconnect(param) {
return new Promise((resolve, reject) => {
db.connect(param, (err, connection) => {
if (err) reject(err);
else resolve(connection);
});
});
}Node.js 8.0+供应了util.promisify（）实用程序，将基于回调的函数转换为基于Promise的替换要领。有几个前提：
- 将回调作为末了一个参数通报给异步函数
- 回调函数必需指向一个毛病，后跟一个值参数。
例子:
// Node.js: promisify fs.readFile
const
util = require('util'),
fs = require('fs'),
readFileAsync = util.promisify(fs.readFile);
readFileAsync('file.txt');种种客户端库也供应promisify选项，但您能够自身建立几个：
// promisify a callback function passed as the last parameter
// the callback function must accept (err, data) parameters
function promisify(fn) {
return function() {
return new Promise(
(resolve, reject) => fn(
...Array.from(arguments),
(err, data) => err ? reject(err) : resolve(data)
)
);
}
}
// example
function wait(time, callback) {
setTimeout(() => { callback(null, 'done'); }, time);
}
const asyncWait = promisify(wait);
ayscWait(1000);异步链
任何返回Promise的东西都能够启动.then（）要领中定义的一系列异步函数挪用。每一个都通报了上一个解决计划的效果：
asyncDBconnect('http://localhost:1234')
.then(asyncGetSession) // passed result of asyncDBconnect
.then(asyncGetUser) // passed result of asyncGetSession
.then(asyncLogAccess) // passed result of asyncGetUser
.then(result => { // non-asynchronous function
console.log('complete'); // (passed result of asyncLogAccess)
return result; // (result passed to next .then())
})
.catch(err => { // called on any reject
console.log('error', err);
});同步函数也能够在.then（）块中实行。返回的值将通报给下一个.then（）（假如有）。
.catch（）要领定义了在触发任何先前谢绝时挪用的函数。此时，不会再运转.then（）要领。您能够在全部链中运用多个.catch（）要领来捕捉差别的毛病。
ES2018引入了一个.finally（）要领，不管效果怎样都运转任何终究逻辑 – 比方，清算，封闭数据库衔接等。现在仅支撑Chrome和Firefox，但手艺委员会39已宣布了 .finally() polyfill.
function doSomething() {
doSomething1()
.then(doSomething2)
.then(doSomething3)
.catch(err => {
console.log(err);
})
.finally(() => {
// tidy-up here!
});
}运用Promise.all（）举行多个异步挪用
Promise .then（）要领一个接一个地运转异步函数。假如递次可有可无 – 比方，初始化不相干的组件 – 同时启动一切异步函数并在末了（最慢）函数运转剖析时完毕更快。
这能够经由过程Promise.all（）来完成。它吸收一组函数并返回另一个Promise。比方：
Promise.all([ async1, async2, async3 ])
.then(values => { // array of resolved values
console.log(values); // (in same order as function array)
return values;
})
.catch(err => { // called on any reject
console.log('error', err);
});假如任何一个异步函数挪用失利，则Promise.all（）马上停止。
运用Promise.race的多个异步挪用（）
Promise.race（）与Promise.all（）相似，只是它会在first Promise剖析或谢绝后马上剖析或谢绝。只要最快的基于Promise的异步函数才完成：
Promise.race([ async1, async2, async3 ])
.then(value => { // single value
console.log(value);
return value;
})
.catch(err => { // called on any reject
console.log('error', err);
});然则有什么别的题目吗？
Promises 减少了回调地狱但引入了别的题目。
教程常常没有提到_全部Promise链是异步的。运用一系列promise的任何函数都应返回自身的Promise或在终究的.then（）,. catch（）或.finally（）要领中运转回调函数。
进修基础知识至关主要。
更多的关于Promises的资本：
Async/Await
Promises 能够令人生畏，因而ES2017引入了async and await。 虽然它能够只是语法糖，它使Promise更圆满，你能够完全防止.then（）链。 斟酌下面的基于Promise的示例：
function connect() {
return new Promise((resolve, reject) => {
asyncDBconnect('http://localhost:1234')
.then(asyncGetSession)
.then(asyncGetUser)
.then(asyncLogAccess)
.then(result => resolve(result))
.catch(err => reject(err))
});
}
// run connect (self-executing function)
(() => {
connect();
.then(result => console.log(result))
.catch(err => console.log(err))
})();用这个重写一下async/await:
- 外部函数必需以async语句开首
- 对异步的基于Promise的函数的挪用必需在await之前，以确保鄙人一个敕令实行之前完成处置惩罚。
async function connect() {
try {
const
connection = await asyncDBconnect('http://localhost:1234'),
session = await asyncGetSession(connection),
user = await asyncGetUser(session),
log = await asyncLogAccess(user);
return log;
}
catch (e) {
console.log('error', err);
return null;
}
}
// run connect (self-executing async function)
(async () => { await connect(); })();await有用地使每一个挪用看起来好像是同步的，而不是阻挠JavaScript的单个处置惩罚线程。 另外，异步函数老是返回一个Promise，因而它们能够被其他异步函数挪用。
async/await 代码能够不会更短，但有相当大的优点:
1、语法更清楚。括号更少，毛病更少。
2、调试更轻易。能够在任何await语句上设置断点。
3、毛病处置惩罚更好。try / catch块能够与同步代码一样运用。
4、支撑很好。它在一切浏览器（IE和Opera Mini除外）和Node 7.6+中都得到了支撑。
然则并不是一切都是圆满的……
切勿滥用async/await
async / await依然依赖于Promises，它终究依赖于回调。你须要相识Promises是怎样事情的，而且没有Promise.all（）和Promise.race（）的直接等价物。而且不要遗忘Promise.all（），它比运用一系列不相干的await敕令更有用。
同步轮回中的异步守候
在某些时刻，您将尝试挪用异步函数中的同步轮回。比方：
async function process(array) {
for (let i of array) {
await doSomething(i);
}
}它不会起作用。这也不会：
async function process(array) {
array.forEach(async i => {
await doSomething(i);
});
}轮回自身坚持同步，而且老是在它们的内部异步操纵之前完成。
ES2018引入了异步迭代器，它与通例迭代器一样，但next（）要领返回Promise。因而，await关键字能够与for轮回一同用于串行运转异步操纵。比方：
async function process(array) {
for await (let i of array) {
doSomething(i);
}
}然则，在完成异步迭代器之前，最好将数组项映照到异步函数并运用Promise.all（）运转它们。比方：
const
todo = ['a', 'b', 'c'],
alltodo = todo.map(async (v, i) => {
console.log('iteration', i);
await processSomething(v);
});
await Promise.all(alltodo);这具有并行运转使命的优点，然则不能够将一次迭代的效果通报给另一次迭代，而且映照大型数组能够在机能斲丧上是很高贵。
try/catch 有哪些题目了？
假如省略任何await失利的try / catch，async函数将以寂静体式格局退出。假如您有一组很长的异步await敕令，则能够须要多个try / catch块。
一种替换计划是高阶函数，它捕捉毛病，因而try / catch块变得不必要(thanks to @wesbos for the suggestion):
async function connect() {
const
connection = await asyncDBconnect('http://localhost:1234'),
session = await asyncGetSession(connection),
user = await asyncGetUser(session),
log = await asyncLogAccess(user);
return true;
}
// higher-order function to catch errors
function catchErrors(fn) {
return function (...args) {
return fn(...args).catch(err => {
console.log('ERROR', err);
});
}
}
(async () => {
await catchErrors(connect)();
})();然则，在应用程序必需以与其他毛病差别的体式格局对某些毛病做出回响反映的状况下，此选项能够不实用。
只管有一些圈套，async / await是JavaScript的一个文雅补充。更多资本：
JavaScript 路程
异步编程是一项在JavaScript中没法防止的应战。回调在大多数应用程序中都是必不可少的，但它很轻易堕入深层嵌套的函数中。
Promises 笼统回调，但有很多语法圈套。 转换现有函数多是一件苦差事，而.then（）链依然看起来很杂沓。
荣幸的是，async / await供应了清楚度。代码看起来是同步的，但它不能独有单个处置惩罚线程。它将转变你编写JavaScript的体式格局！
(译者注：Craig Buckler解说JavaScript的文章都还不错，基本是用一些比较浅显的言语和代码事例解说了JavaScript的一些特征和一些语法能够涌现的题目。感兴趣的朋侪能够看一下（https://www.sitepoint.com/aut…）)
