async函数

首先看一下下列代码

var gen = function* (){
　var a = yield readFile();
　console.log(a);
　var b= yield readFile();
　console.log(b);
}

接下来用async形式来表示generator函数

var gen = async function(){
　var a = await readFIle();
　console.log(b);
　var b = await readFile();
　console.log(b);
}

从以上可以看出async函数就是在generator函数上改进的，就是把*改为async，然后把yield改为await，但是他在generator函数上有一些改进

哪些改进呢？

---

• 内置执行器
  在我的另一篇博客中说出generator函数执行，需要为他写自动执行器，例如基于thunk函数的自动执行器，还有基于promise的自动执行器，还有就是co模块，但是async函数只要调用它就自己执行
• 更好的语义
• 更广泛的使用
  co模块的yield语句后面必须是thunk函数或者是promise对象，但是await函数后面可以是原始类型的值
• 返回的是promise对象
  可以使用then等

使用方法

---

async function getStockByName(name){
　const symbol = await getStockSymbol(name);
　const stockPrice = await getStockPrice(symbol);
　return stockPrice;
}
getStockByName('sportShoe').then(function(result){
　console.log(result);
})

我们可以看出只要我们调用一次getStockByName()，就自动执行，所以最后的result就是stockPrice

语法

---

返回Promise对象

调用async函数会返回一个promise对象，所以才可以调用then方法，then方法中的函数的参数就是async函数返回的值

const aw = async function(age){
　var name = await search(age);
　return name;
}
aw(20).then(name => console.log(name));

promise对象的状态变化

只有内部的所有异步过程结束后，才会调用then方法，或者抛出错误，或者遇到return语句

错误处理

我建议大家把所有的await语句都放在try catch语句中

async function main() {
try {
　 const val1 = await firstStep();
　const val2 = await secondStep(val1);
　const val3 = await thirdStep(val1, val2);
　console.log('Final: ', val3);
}
catch (err) {
　console.error(err);
}
}

注意的内容

let foo = await getFoo();
let bar = await getBar();

以上函数是独立的过程，被写成继发关系，就是顺序进行，这样会导致很费时，怎样会写成同时进行
有一下俩种写法

// 写法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]);
// 写法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;

promise.all()方法就是将多个promise实例包装成一个
await命令必须写在async函数中写在别的函数中会出错

async函数的实现的原理

其实就是把generator函数写到一个具有自动执行代码的函数，然后在返回这个函数，和基于thunk函数的自动执行器基本一致，就不仔细分析async函数的源码了

顺序执行完一系列操作

promise的写法

function loginOrder(urls){
Const textPromises = urls.map(url => {
Return fetch(url).then(response => response.text());
})
TextPromise.reduce((chain, textPromise) => {
Return chain.then(() => textPromise)
.then(text => console.log(text));
}, Promise.resolve());
}

接下来看一下用async函数来表示上述操作

async function logInOrder(urls) {
for (const url of urls) {
const response = await fetch(url);
console.log(await response.text());
}
}

可以看出来用async表示非常简洁，但是这样会有一个问题所有提取网页都是继发，这样会很浪费时间，继发·就是提取网页是按照顺序进行的，所以我们现在要把它改成同时提取网页，代码如下

async function logInOrder(urls) {
// 并发读取远程URL
const textPromises = urls.map(async url => {
const response = await fetch(url);
return response.text();
});
// 按次序输出
for (const textPromise of textPromises) {
console.log(await textPromise);
}
}

因为在上述map函数中，匿名函数是async函数，所以await如果是在async函数中，那么这些await后面的操作都是同步进行的 ，这样就不会耗时了

异步遍历

我们都知道同步遍历器是部署在对象的Symbol.iterator的属性上的，但是异步遍历器是部署在对象的Symbol.asyncIterator属性上的
以下代码是一个异步遍历器的例子

const asyncIterable = createAsyncIterable(['a', 'b']);
const asyncIterator = asyncIterable.Symbol.asyncIterator();
asyncIterator
.next()
.then(iterResult1 => {
　 console.log(iterResult1); // { value: 'a', done: false }
　 return asyncIterator.next();
})
.then(iterResult2 => {
　console.log(iterResult2); // { value: 'b', done: false }
　return asyncIterator.next();
})
.then(iterResult3 => {
　 console.log(iterResult3); // { value: undefined, done: true }
});

从上面可以看出异步遍历器调用next方法返回一个promise，然后promise的状态变为resolve，然后调用then函数，执行then函数内的回调函数
由于调用next方法返回的是一个promise对象，所以说可以放在await命令后面，代码如下

async function f() {
　const asyncIterable = createAsyncIterable(['a', 'b']);
　const asyncIterator = asyncIterableSymbol.asyncIterator;
　console.log(await asyncIterator.next());
　 // { value: 'a', done: false }
　 console.log(await asyncIterator.next());
　// { value: 'b', done: false }
　console.log(await asyncIterator.next());
　// { value: undefined, done: true }
}

上面的代码接近于同步执行，但是我们想要所有的await基本上同时进行，可以有一下俩种表示

const asyncGenObj = createAsyncIterable(['a', 'b']);
const [{value: v1}, {value: v2}] = await Promise.all([
　asyncGenObj.next(), asyncGenObj.next()
]);
console.log(v1, v2); // a b
//第二种
async function runner() {
　 const writer = openFile('someFile.txt');
　writer.next('hello');
　writer.next('world');
　await writer.return();
}
runner();

for await of

我们都知道同步遍历器我们可以使用for of来遍历，但是异步的遍历器，我们使用for await of来遍历

async function f() {
for await (const x of createAsyncIterable(['a', 'b'])) {
　console.log(x);
　 }
}
// a
// b

异步generator函数

简单的说就是async与generator函数的结合，如下

async function* gen() {
　 yield 'hello';
}
const genObj = gen();
genObj.next().then(x => console.log(x));
// { value: 'hello', done: false }

首先genObj.next()返回的是一个promise，然后调用then，执行then里面的函数，再看一个我认为比较重要的例子

async function* readLines(path) {
let file = await fileOpen(path);
try {
　 while (!file.EOF) {
　 yield await file.readLine();
}
} finally {
　 await file.close();
}
}

我们可以看出异步generator函数，既有await也有yield，其中await命令用于将file.readLine()返回的结果输入到函数内，然后yield用于将输入到函数内的结果从函数输出

---

在异步generator函数中的yield* 语句后面还可以跟一个异步的generator函数