ES7의 async/await 사용 예시에 대한 자세한 설명

이 글은 주로 ES7의 async/await 사용법에 대한 심층적인 이해를 소개하는 글입니다. 편집자는 꽤 좋다고 생각해서 지금 공유하고 참고용으로 올려드리겠습니다. 에디터를 따라가서 살펴볼까요

ES6 Promise에 대해 처음 알게 되었을 때 "JS 코드의 비동기 프로세스를 해결하기 위한 제너레이터 함수와 Promise 및 Co의 비교"라는 글을 쓴 적이 있습니다. Promise와 Co의 사용을 비교한 글입니다. co 모듈은 제너레이터 함수와 결합되어 js 비동기식의 유사점과 차이점을 해결합니다.

기사 말미에 ES7의 async와 Wait가 언급됐으나 당시에는 간략하게만 언급됐을 뿐 깊이 있는 논의는 이뤄지지 않았다.

두 달 전에 출시된 Nodejs V7에는 async 및 Wait에 대한 지원이 추가되었습니다. 오늘은 이에 대해 심층적으로 살펴보겠습니다. 보다 우아한 방식으로 비동기 코드를 작성하세요.

async/await가 무엇인가요?

async/await는 공동 모듈 및 생성기 기능의 구문 설탕이라고 할 수 있습니다. 보다 명확한 의미론으로 js 비동기 코드를 해결합니다.

co 모듈에 익숙한 학생들은 co 모듈이 비동기 프로세스를 해결하기 위해 생성기 기능을 사용하는 Master TJ가 작성한 모듈이라는 것을 알아야 합니다. 생성기 기능의 실행자라고 볼 수 있습니다. Async/await는 co 모듈의 업그레이드입니다. 여기에는 생성기 함수 실행기가 내장되어 있으며 더 이상 co 모듈에 의존하지 않습니다. 동시에 async는 Promise를 반환합니다.

위의 관점에서 볼 때, co 모듈이든 async/await이든 Promise는 가장 기본적인 단위로 사용됩니다. Promise에 대해 잘 모르는 학생들은 먼저 Promise에 대해 자세히 알아볼 수 있습니다.

Promise, co, async/await 비교

간단한 예를 사용하여 세 가지 방법 간의 유사점, 차이점 및 장단점을 비교해 보겠습니다.

mongodb의 nodejs 드라이버를 사용하여 mongodb 데이터베이스를 쿼리하는 이유는 mongodb의 js 드라이버가 기본적으로 Promise 반환을 구현했기 때문에 Promise를 별도로 래핑할 필요가 없기 때문입니다.

Promise 체인 사용

MongoClient.connect(url + db_name).then(db=> {
  return db.collection('blogs');
}).then(coll=> {
  return coll.find().toArray();
}).then(blogs=> {
  console.log(blogs.length);
}).catch(err=> {
  console.log(err);
})

Promise의 then() 메서드는 다른 Promise 또는 동기화된 값을 반환할 수 있으며, 동기화된 값이 반환되면 Promise로 패키징됩니다.

위의 예에서 db.collection()은 동기화된 값, 즉 컬렉션 객체를 반환하지만 Promise로 래핑되어 다음 then() 메서드에 투명하게 전달됩니다.

위의 예에서는 Promise 체인을 사용합니다.

먼저 데이터베이스 MongoClient.connect()에 연결하여 Promise를 반환한 다음 then() 메서드에서 데이터베이스 개체 db를 얻은 다음 coll 개체를 가져와 반환합니다. 다음 then() 메서드에서 coll 객체를 얻은 후 쿼리를 수행하고 쿼리 결과를 반환한 다음 계층별로 then() 메서드를 호출하여 Promise 체인을 형성합니다.

이 Promise 체인에서는 링크에서 예외가 발생하면 최종 catch()에 의해 포착됩니다.

프로미스 체인을 사용하여 작성된 이 코드는 콜백 함수를 계층별로 호출하는 것보다 더 우아하고 프로세스가 더 명확하다고 말할 수 있습니다. 먼저 데이터베이스 개체를 가져온 다음 컬렉션 개체를 가져온 다음 마지막으로 데이터를 쿼리합니다.

그러나 여기에는 별로 "우아하지 않은" 문제가 있습니다. 즉, 각 then() 메서드에서 얻은 개체가 이전 then() 메서드에서 반환된 데이터라는 것입니다. 여러 레이어에 걸쳐 액세스할 수 없습니다.

무슨 뜻인가요? 세 번째 then(blogs => {})에서는 쿼리 결과 블로그만 가져올 수 있고 위의 db 개체와 coll 개체는 사용할 수 없다는 의미입니다. 이때, 블로그 목록을 출력한 후 데이터베이스 db.close()를 닫고 싶다면 어떻게 해야 할까요?

이때 해결책은 두 가지가 있습니다.

첫 번째는 then() 중첩을 사용하는 것입니다. 콜백 함수를 사용하는 것처럼 Promise 체인을 끊고 중첩되게 만듭니다.

MongoClient.connect(url + db_name).then(db=> {
  let coll = db.collection('blogs');
  coll.find().toArray().then(blogs=> {
    console.log(blogs.length);
    db.close();
  }).catch(err=> {
    console.log(err);
  });
}).catch(err=> {
  console.log(err);
})

여기서 마지막 쿼리 작업에서 외부 DB를 개체라고 부를 수 있도록 두 개의 Promise를 중첩합니다. 그러나 이 방법은 권장되지 않습니다. 이유는 간단합니다. 한 종류의 콜백 함수 지옥에서 다른 종류의 Promise 콜백 지옥으로 이동했기 때문입니다.

또한 Promise는 체인을 형성하지 않기 때문에 각 Promise의 예외를 잡아야 합니다.

각 then() 메소드에 db를 전달하는 또 다른 방법이 있습니다.

MongoClient.connect(url + db_name).then(db=> {
  return {db:db,coll:db.collection('blogs')};
}).then(result=> {
  return {db:result.db,blogs:result.coll.find().toArray()};
}).then(result=> {
  return result.blogs.then(blogs=> {  //注意这里，result.coll.find().toArray()返回的是一个Promise，因此这里需要再解析一层
    return {db:result.db,blogs:blogs}
  })
}).then(result=> {
  console.log(result.blogs.length);
  result.db.close();
}).catch(err=> {
  console.log(err);
});

각 then() 메소드를 반환할 때마다 db와 다른 결과를 전달합니다. 물체. 각 결과가 동기화된 값이면 괜찮지만 Promise 값인 경우 각 Promise에는 추가 분석 계층이 필요합니다.

예를 들어 위의 예에서 두 번째 then() 메소드에 의해 반환된 {db:result.db,blogs:result.coll.find().toArray()} 객체에서 blogs는 Promise이고 다음 then() ) 메서드에서는 블로그 목록 배열 값을 직접 참조할 수 없으므로 then() 메서드를 호출하여 먼저 한 레이어를 구문 분석한 다음 두 개의 동기화된 값 db 및 blogs를 반환해야 합니다.

여기에는 Promise의 중첩이 포함되지만 Promise는 then()의 한 수준만 중첩됩니다.

이 메서드도 매우 고통스러운 메서드입니다. then() 메서드가 동기화된 값이 아닌 Promise를 반환하는 경우 훨씬 더 많은 작업을 수행해야 하기 때문입니다. 게다가 매번 "추가" db 개체를 투명하게 전송하는 것도 논리상 약간 중복됩니다.

但除此之外，对于Promise链的使用，如果遇到上面的问题，好像也没其他更好的方法解决了。我们只能根据场景去选择一种“最优”的方案，如果要使用Promise链的话。

鉴于Promise上面蛋疼的问题，TJ大神将ES6中的生成器函数，用co模块包装了一下，以更优雅的方式来解决上面的问题。

co搭配生成器函数

如果使用co模块搭配生成器函数，那么上面的例子可以改写如下：

const co = require('co');
co(function* (){
  let db = yield MongoClient.connect(url + db_name);
  let coll = db.collection('blogs');
  let blogs = yield coll.find().toArray();
  console.log(blogs.length);
  db.close();
}).catch(err=> {
  console.log(err);
});

co是一个函数，将接受一个生成器函数作为参数，去执行这个生成器函数。生成器函数中使用 yield 关键字来“同步”获取每个异步操作的值。

上面代码在代码形式上，比上面使用Promise链要优雅，我们消灭了回调函数，代码看起来都是同步的。除了使用co和yield有点怪之外。

使用co模块，我们要将所有的操作包装成一个生成器函数，然后使用co()去调用这个生成器函数。看上去也还可以接受，但是ES的进化是不满足于此的，于是async/await被提到了ES7的提案。

async/await

我们先看一下使用async/await改写上面的代码：

(async function(){
  let db = await MongoClient.connect(url + db_name);
  let coll = db.collection('blogs');
  let blogs = await coll.find().toArray();
  console.log(blogs.length);
  db.close();
})().catch(err=> {
  console.log(err);
});

我们对比代码可以看出，async/await和co两种方式代码极为相似。

co换成了async，yield换成了await。同时生成器函数变成了普通函数。

这种方式在语义上更加清晰明了，async表明这个函数是异步的，同时await表示要“等待”异步操作返回值。

async函数返回一个Promise，上面的代码其实是这样：

let getBlogs = async function(){
  let db = await MongoClient.connect(url + db_name);
  let coll = db.collection('blogs');
  let blogs = await coll.find().toArray();
  db.close();
  return blogs;
};

getBlogs().then(result=> {
  console.log(result.length);
}).catch(err=> {
  console.log(err);
})

我们定义getBlogs为一个async函数，最后返回得到的博客列表最终会被包装成一个Promise返回，如上，我们直接调用getBlogs().then()方法可获取async函数返回值。

好了，上面我们简单对比了一下三种解决异步方案，下面我们来深入了解一下async/await。

深入async/await

async返回值

async用于定义一个异步函数，该函数返回一个Promise。

如果async函数返回的是一个同步的值，这个值将被包装成一个理解resolve的Promise，等同于return Promise.resolve(value) 。

await用于一个异步操作之前，表示要“等待”这个异步操作的返回值。await也可以用于一个同步的值。

//返回一个Promise
let timer = async functiontimer(){
  return new Promise((resolve,reject) => {
    setTimeout(()=> {
      resolve('500');
    },500);
  });
}

timer().then(result=> {
 console.log(result); //500
}).catch(err=> {
  console.log(err.message);
});

//返回一个同步的值
let sayHi = async functionsayHi(){
 let hi = await 'hello world';  
 return hi; //等同于return Promise.resolve(hi);
}

sayHi().then(result=> {
 console.log(result);
});

上面这个例子返回是一个同步的值，字符串'hello world'，sayHi()是一个async函数，返回值被包装成一个Promise，可以调用then()方法获取返回值。

对于一个同步的值，可以使用await，也可以不使用await。效果效果是一样的。具体用不用，看情况。

比如上面使用mongodb查询博客那个例子， let coll = db.collection('blogs'); ，这里我们就没有用await，因为这是一个同步的值。当然，也可以使用await，这样会显得代码统一。虽然效果是一样的。

async函数的异常

let sayHi = async functionsayHi(){
  throw new Error('出错了');
}
sayHi().then(result=> {
 console.log(result);
}).catch(err=> {
  console.log(err.message);  //出错了
});

我们直接在async函数中抛出一个异常，由于返回的是一个Promise，因此，这个异常可以调用返回Promise的catch()方法捕捉到。

和Promise链的对比：

我们的async函数中可以包含多个异步操作，其异常和Promise链有相同之处，如果有一个Promise被reject()那么后面的将不会再进行。

let count = ()=>{
  return new Promise((resolve,reject) => {
    setTimeout(()=>{
      reject('故意抛出错误');
    },500);
  });
}

let list = ()=>{
  return new Promise((resolve,reject)=>{
    setTimeout(()=>{
      resolve([1,2,3]);
    },500);
  });
}

let getList = async ()=>{
  let c = await count();
  let l = await list();
  return {count:c,list:l};
}
console.time('begin');
getList().then(result=> {
  console.log(result);
}).catch(err=> {
  console.timeEnd('begin');
  console.log(err);
});
//begin: 507.490ms
//故意抛出错误

如上面的代码，定义两个异步操作，count和list，使用setTimeout延时500毫秒，count故意直接抛出异常，从输出结果来看，count()抛出异常后，直接由catch()捕捉到了，list()并没有继续执行。

并行

使用async后，我们上面的例子都是串行的。比如上个list()和count()的例子，我们可以将这个例子用作分页查询数据的场景。

先查询出数据库中总共有多少条记录，然后再根据分页条件查询分页数据，最后返回分页数据以及分页信息。

我们上面的例子count()和list()有个“先后顺序”，即我们先查的总数，然后又查的列表。其实，这两个操作并无先后关联性，我们可以异步的同时进行查询，然后等到所有结果都返回时再拼装数据即可。

let count = ()=>{
  return new Promise((resolve,reject) => {
    setTimeout(()=>{
      resolve(100);
    },500);
  });
}

let list = ()=>{
  return new Promise((resolve,reject)=>{
    setTimeout(()=>{
      resolve([1,2,3]);
    },500);
  });
}

let getList = async ()=>{
  let result = await Promise.all([count(),list()]);
  return result;
}
console.time('begin');
getList().then(result=> {
  console.timeEnd('begin'); //begin: 505.557ms
  console.log(result);    //[ 100, [ 1, 2, 3 ] ]
}).catch(err=> {
  console.timeEnd('begin');
  console.log(err);
});

我们将count()和list()使用Promise.all()“同时”执行，这里count()和list()可以看作是“并行”执行的，所耗时间将是两个异步操作中耗时最长的耗时。

最后得到的结果是两个操作的结果组成的数组。我们只需要按照顺序取出数组中的值即可。

JavaScript 中最蛋疼的事情莫过于回调函数嵌套问题。以往在浏览器中，因为与服务器通讯是一种比较昂贵的操作，因此比较复杂的业务逻辑往往都放在服务器端，前端 JavaScript 只需要少数几次 AJAX 请求就可拿到全部数据。

但是到了 webapp 风行的时代，前端业务逻辑越来越复杂，往往几个 AJAX 请求之间互有依赖，有些请求依赖前面请求的数据，有些请求需要并行进行。还有在类似 Node.js 的后端 JavaScript 环境中，因为需要进行大量 IO 操作，问题更加明显。这个时候使用回调函数来组织代码往往会导致代码难以阅读。

现在比较流行的解决这个问题的方法是使用 Promise，可以将嵌套的回调函数展平。但是写代码和阅读依然有额外的负担。

另外一个方案是使用 ES6 中新增的 generator，因为 generator 的本质是可以将一个函数执行暂停，并保存上下文，再次调用时恢复当时的状态。co 模块是个不错的封装。但是这样略微有些滥用 generator 特性的感觉。

ES7 中有了更加标准的解决方案，新增了 async/await 两个关键词。async 可以声明一个异步函数，此函数需要返回一个 Promise 对象。await可以等待一个 Promise 对象 resolve，并拿到结果。

比如下面的例子，以往我们无法在 JavaScript 中使用常见的 sleep 函数，只能使用 setTimeout 来注册一个回调函数，在指定的时间之后再执行。有了 async/await 之后，我们就可以这样实现了：

async function sleep(timeout) {
 return new Promise((resolve, reject) => {
  setTimeout(function() {
   resolve();
  }, timeout);
 });
}

(async function() {
 console.log('Do some thing, ' + new Date());
 await sleep(3000);
 console.log('Do other things, ' + new Date());
})();

执行此段代码，可以在终端中看到结果：

Do some thing, Mon Feb 23 2015 21:52:11 GMT+0800 (CST)
Do other things, Mon Feb 23 2015 21:52:14 GMT+0800 (CST)

另外 async 函数可以正常的返回结果和抛出异常。await 函数调用即可拿到结果，在外面包上 try/catch 就可以捕获异常。下面是一个从豆瓣 API 获取数据的例子：

var fetchDoubanApi = function() {
 return new Promise((resolve, reject) => {
  var xhr = new XMLHttpRequest();
  xhr.onreadystatechange = function() {
   if (xhr.readyState === 4) {
    if (xhr.status >= 200 && xhr.status < 300) {
     var response;
     try {
      response = JSON.parse(xhr.responseText);
     } catch (e) {
      reject(e);
     }
     if (response) {
      resolve(response, xhr.status, xhr);
     }
    } else {
     reject(xhr);
    }
   }
  };
  xhr.open(&#39;GET&#39;, &#39;https://api.douban.com/v2/user/aisk&#39;, true);
  xhr.setRequestHeader("Content-Type", "text/plain");
  xhr.send(data);
 });
};

(async function() {
 try {
  let result = await fetchDoubanApi();
  console.log(result);
 } catch (e) {
  console.log(e);
 }
})();

async 函数的用法

同 Generator 函数一样，async 函数返回一个 Promise 对象，可以使用 then 方法添加回调函数。当函数执行的时候，一旦遇到 await 就会先返回，等到触发的异步操作完成，再接着执行函数体内后面的语句。
下面是一个例子。

async function getStockPriceByName(name) {
 var symbol = await getStockSymbol(name);
 var stockPrice = await getStockPrice(symbol);
 return stockPrice;
}

getStockPriceByName('goog').then(function (result){
 console.log(result);
});

阅读本文前，期待您对promise和ES6(ECMA2015)有所了解，会更容易理解。本文以体验为主，不会深入说明，结尾有详细的文章引用。

第一个例子

Async/Await应该是目前最简单的异步方案了，首先来看个例子。这里我们要实现一个暂停功能，输入N毫秒，则停顿N毫秒后才继续往下执行。

var sleep = function (time) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve();
    }, time);
  })
};

var start = async function () {
  // 在这里使用起来就像同步代码那样直观
  console.log('start');
  await sleep(3000);
  console.log('end');
};

start();

控制台先输出start，稍等3秒后，输出了end。

基本规则

async 表示这是一个async函数，await只能用在这个函数里面。await表示在这里等待promise返回结果了，再继续执行。await 后面跟着的应该是一个promise对象（当然，其他返回值也没关系，只是会立即执行，不过那样就没有意义了…）

获得返回值

await等待的虽然是promise对象，但不必写.then(..)，直接可以得到返回值。

var sleep = function (time) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      // 返回 ‘ok'
      resolve('ok');
    }, time);
  })
};

var start = async function () {
  let result = await sleep(3000);
  console.log(result); // 收到 ‘ok'
};

捕捉错误

既然.then(..)不用写了，那么.catch(..)也不用写，可以直接用标准的try catch语法捕捉错误。

var sleep = function (time) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      // 模拟出错了，返回 ‘error'
      reject('error');
    }, time);
  })
};

var start = async function () {
  try {
    console.log('start');
    await sleep(3000); // 这里得到了一个返回错误
    
    // 所以以下代码不会被执行了
    console.log('end');
  } catch (err) {
    console.log(err); // 这里捕捉到错误 `error`
  }
};

循环多个await

await看起来就像是同步代码，所以可以理所当然的写在for循环里，不必担心以往需要闭包才能解决的问题。

..省略以上代码
var start = async function () {
  for (var i = 1; i <= 10; i++) {
    console.log(`当前是第${i}次等待..`);
    await sleep(1000);
  }
};

值得注意的是，await必须在async函数的上下文中的。

..省略以上代码

let one2ten = [1,2,3,4,5,6,7,8,9,10];

// 错误示范
one2ten.forEach(function (v) {
  console.log(`当前是第${v}次等待..`);
  await sleep(1000); // 错误!! await只能在async函数中运行
});

// 正确示范
for(var v of one2ten) {
  console.log(`当前是第${v}次等待..`);
  await sleep(1000); // 正确, for循环的上下文还在async函数中
}

위 내용은 ES7의 async/await 사용 예시에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!