Async and await

1、async and Generator The relationship between

async yes Generator Grammatical sugar of function （ Grammatical sugar ： A grammar added to a computer language , This grammar has no effect on the function of language , But it's easier for programmers to use . Generally speaking, the use of syntactic sugar can increase the readability of programs , So as to reduce the chance of program code error .）.

Case a ： Read two files

var fs = require('fs');
var readFile = function(fileName)
{
    return new Promise(function(resolve,reject){
    fs.readFile(fileName,function(error,data){
        if(error) 
        {
            return reject(error);
        }
        resolve(data);
    });
    });
}
var gen = function*(){
    var f1= yield readFile('./hello.txt');
    var f2= yield readFile('./world.txt');
}
var hw = gen();
hw.next().value.then((data)=>{console.log("22 success:"+data)},(error)=>{console.log("failed:"+error)});
hw.next().value.then((data)=>{console.log("22 success:"+data)},(error)=>{console.log("failed:"+error)});
console.log("333"+hw.next().value);

take Generator The function is changed to async Form of function ：

var gen2 = async function (){
    var f1= await readFile('./hello.txt');
    var f2= await readFile('./world.txt');
}

async The function will be Generator Asterisk of function (*) Replace with async, take yield Replace with await, That's it .

2、async Function pair Generator Function improvements

（1） Built in actuator

async The execution of function is exactly the same as that of ordinary function , Just one line .

gen2();

The code above calls gen2() function , Then it will automatically execute , Output the final result . It's not like it at all Generator Function needs to call next Method or use co Module can execute and get the final result .

（2） Better semantics

async and await Compared to asterisks and yield, The meaning is clearer .async Indicates that there is an asynchronous operation in the function ,await Indicates that the following expression needs to wait for the result .

（3） Wider applicability

co Module conventions ,yield The order can only be followed by Thunk Function or Promise object , and async Functional await Command behind , It can be Promise Value of object and original type （ The number , String and Boolean , But this is equivalent to synchronous operation ）.

（4） The return value is Promise

async The return value of the function is Promise object , This is more than Generator The return value of the function is Iterator Objects are much more convenient . It can be used then Method to specify the next action .

summary ：async Function can be regarded as one wrapped by multiple asynchronous operations Promise object , and await Command is internal then Grammar sugar of command .

3、 usage

（1）async Back to Promise object

var fs = require('fs');
var readFile = function(fileName)
{
    return new Promise(function(resolve,reject){
    fs.readFile(fileName,function(error,data){
        if(error) 
        {
            return reject(error);
        }
        resolve(data);
    });
    });
}

var gen2 = async function (){
    var f1= await readFile('./hello.txt');
    var f2= await readFile('./world.txt');
    console.log(f1.toString());
    console.log("f2:"+f2);
    return "run end";//async The return value will become then Method callback function parameters 
}
var hw = gen2();
hw.then((data)=>{console.log("22 success:"+data)},(error)=>{console.log("failed:"+error)});

Running results ：

async Internal function return The value returned by the statement , It's going to be then Method callback function parameters .

（2） False capture

var gen2 = async function (){
    var f1= await readFile('./hello.txt');
    var f2= await readFile('./world.txt');
    console.log(f1.toString());
    console.log("f2:"+f2);
    throw new Error("Error!!!");
}
var hw = gen2();
hw.then((data)=>{console.log("22 success:"+data)},(error)=>{console.log("failed:"+error)});

Running results ：

async An error thrown inside a function results in a return Promise The object becomes reject state . The error object thrown will be catch Method callback received . 

4、Promise The state of the object changes

async Function return Promise The object has to wait until it's internally owned await After the order Promise After the object is executed, the state will change , Unless you meet return Statement or throw error . namely ： Only async The asynchronous operation inside the function is finished , Will execute then Callback function specified by method .

5、await command

Under normal circumstances ,await The command is followed by a Promise object . If not , Will be turned into an immediate resolve Of Promise object .

await After the order Promise If the object becomes reject state , be reject The parameters of will be catch Method's callback function received .

async function f(){
    await Promise.reject('There is an error!!!');
}
f()
.then(v=>console.log(v))
.catch(e=>console.log(e));

Running results ：

In the above code ,await There is no return, however reject The parameters of the method are still passed in catch Callback function for method .

As long as a await After statement Promise Turn into reject, So the whole async Functions are interrupted .

  Sometimes , We hope that even if the previous asynchronous operation fails , Do not interrupt the subsequent asynchronous operation , At this time, you can put the first await Put it in try...catch Inside the structure , So whether or not the asynchronous operation succeeds , the second await It will be carried out .

async function f(){
    try{
        await Promise.reject("EEEE ERROR");
    }catch(e){
        console.log(e);
    }
    return await Promise.resolve('run end');
}
f()
.then(v=>console.log(v));

Running results ：