ES6-21【async与await】

一.async与await

(1).生成函数中的return

function * get(){
    yield 1;
    yield 2;
    yield 3;
}
let g = get();
console.log(g.next());
console.log(g.return());
console.log(g.next());
{value: 1, done: false}
{value: undefined, done: true}
{value: undefined, done: true}

这里需要注意的是一旦return 就为undefined了没有产出值，因为return中的参数是空的，如果return中有参数则返回相应值得迭代器对象

(2).同步异常捕获

function * get(){
    try {
        yield 1;
    } catch (error) {
        console.log('生成器内部异常:'+e);
        
    }
    console.log(1);
}
let g = get();
console.log(g.next());
console.log(g.throw());
console.log(g.next());
{value: undefined, done: false}
生成器内部异常:undefined
1
{value: undefined, done: true}
{value: undefined, done: true}

只有当第一次next了之后，把捕获区间转移到yileld之后才可以完成异常的捕获，否则直接报错，无法捕获

 

同时也只能捕获一次

function * get(){
    try {
        yield 
    } catch (error) {
        console.log('生成器内部异常:'+error);
        
    }
    console.log(1);
}
let g = get();
console.log(g.next());
console.log(g.throw('a'));
console.log(g.throw('b'));
console.log(g.next());
{value: undefined, done: false}
生成器内部异常:a
1
{value: undefined, done: true}
Uncaught b

不会影响到其他yield执行

function * get(){
    yield 0;
    try {
        yield 1;
    } catch (error) {
        console.log('生成器内部异常:'+error);
        
    }
   yield 2;
}
let g = get();
console.log(g.next());
console.log(g.next());
console.log(g.throw('a'));
console.log(g.next());

{value: 0, done: false}
{value: 1, done: false}
生成器内部异常:a
{value: 2, done: false}
{value: undefined, done: true}

也就是说throw也相当于产出next,但前提是要捕获到，不然后面代码就没办法执行了如下就会报错，可以与上面代码对比

let g = get();
console.log(g.next());
console.log(g.throw('a'));
console.log(g.next());
{value: 0, done: false}
Uncaught a

(3).异步代码异常的捕获、

在生成器函数中try catch是可以捕获到异步异常的，普通函数中是不可以得

function * read(){
    try {
        let value1 = yield readFile('./name.tx','utf-8');
        let value2 = yield readFile(value1,'utf-8');
         let value3 = yield readFile(value2,'utf-8');
    } catch (error) {
        console.log('91'+error)
    }
   console.log('hello world');
   return value3
    
}

二.async await

(1).变更情况

函数async返回的都是co后的promise对象,

每一条await返回的是结果值

const fs = require('fs');
const util = require('util')
let readFile = promisify(fs.readFile)
async function  read(){
    try {
        let value1 = await readFile('./name.txt','utf-8');
        let value2 = await readFile(value1,'utf-8');
         let value3 = await readFile(value2,'utf-8');
          console.log('hello world');
           return value3
    } catch (error) {
        console.log('91'+error)
    }
  
    
}
let promise = read()
promise.then((val)=>{
    console.log(val);
    
})

(2).reject/catch捕获错误

reject不仅可以捕获函数内错误，也可捕获异步内错误，能捕捉到函数体对象是因为CO已经底层已经将函数Promise化了

下面这两处都能捕获

let readFile = promisify(fs.readFile)
async function  read(){

        let value1 = await readFile('./name.tx','utf-8'); //错误处
        console.log(a);//错误处
        
   return 1
    
}
let promise = read()
promise.then((val)=>{
    console.log(val);
    
},(e)=>{
    console.log(e);
    
})

1. catch也能捕获，不做代码演示了，包裹起来即可，且catch在捕获到之后响应，
2. 当catch和reject共同存在时，reject响应catch外的错误
3. catch响应完错误之后后面代码照常执行，reject之后后面代码不执行

(3).实现all()得错误忽略

用all方法来执行异步操作 如果有一个出错就没法执行后面的了，那么我们可以通过async和awaittrychatchset来配合实现这个功能,平常不会这么做

let fs = require('fs');
let util = require('util')
 let readFile = util.promisify(fs.readFile)
 async function  read(){
     let value1, value2, value3;
     let res = new Set();
      try{
       value1 = await readFile('name.txt','utf-8');           
      }catch(err){
        
      }
       try{     
         value2 = await readFile('number.tx','utf-8');
      }catch(err){
        
      }
       try{
          value3 = await readFile('score.txt','utf-8');
      }catch(err){
        
      }
    
      res.add(value1)
      res.add(value2)
      res.add(value3)
        
      return res;
    
 }

 read().then((val)=>{
     console.log(val);
    
 })

{ 'number.txt', undefined, '99' }

把catch块去掉是不可以的，会导致直接被捕获到。

因为async函数返回的是promise对象，和自己声明时的Promise不同。自己声明的Promise对象由于JS执行原理所以并不会影响到后续执行。而返回的promise是实例化后的Promise直接监听到就阻断了