This article mainly introduces Promise, Generator, and async/await about JS asynchronous programming. It has certain reference value. Now I share it with you. Friends in need can refer to it.

JS Asynchronous Programming ( 2) - Promise, Generator, async/await

In the last article, we talked about the relevant knowledge of JS asynchronous programming, such as what is asynchronous, why to use asynchronous programming and how to use JS in the browser Implemented asynchronously.
Finally, we talked about several JS asynchronous programming modes (callback, event and publish/subscribe mode). In this article, we will continue to take a closer look at other asynchronous programming modes.

Promise

Promise is an asynchronous programming solution introduced by ES6. In fact, before ES6, many asynchronous tool libraries had already implemented various similar solutions, and ES6 wrote them into the language standard and unified their usage. Promise solves the problem of nested solutions such as callbacks and makes the code more readable, giving a sense of deja vu when writing synchronous methods.

Let’s first briefly understand the usage of Promise in ES6

var p = new Promise(function async(resolve, reject){    // 这里是你的异步操作
    setTimeout(function(){        if(true){
            resolve(val);
        }else{
            reject(error);
        }
    }, 1000)
})

p.then(function(val){    console.log(&#39;resolve&#39;);
}, function(){    console.log(&#39;reject&#39;);
})

Copy after login

First of all, ES6 stipulates that Promise is a constructor, which accepts a function as a parameter such as async## in the above code. #Function, this function has two parameters, resolve and reject respectively corresponding to the two states of success and failure. We can choose to execute resolve or reject at different times to trigger the next action and execute the function in the then method.

We can simply compare the difference between the way of writing callback and the way of writing promise

For traditional callback writing, it is usually written like this
asyncFn1(function () {
  asyncFn2(function() {
    asyncFn3(function() {        // xxxxx
    });
  });
});
Copy after login

Or we can separate each callback function and write it independently to reduce coupling, like this:

function asyncFn1(callback) {    return function() {        console.log(&#39;asyncFn1 run&#39;);
        setTimeout(function(){
            callback();
        }, 1000);
    }
}function asyncFn2(callback) {    return function(){        console.log(&#39;asyncFn2 run&#39;);
        setTimeout(function(){
            callback();
        }, 1000);
    }
}function normalFn3() {    console.log(&#39;normalFn3 run&#39;);
}

asyncFn1(asyncFn2(normalFn3))()

Copy after login

Finally, let’s take a look at how to write Promise

function asyncFn1() {    
console.log(&#39;asyncFn1 run&#39;);    
return new Promise(function(resolve, reject) {
        setTimeout(function(){
            resolve();
        }, 1000)
    })
}function asyncFn2() {    
console.log(&#39;asyncFn2 run&#39;);    
return new Promise(function(resolve, reject) {
        setTimeout(function(){
            resolve();
        }, 1000)
    })
}function normalFn3() {    console.log(&#39;normalFn3 run&#39;);
}

asyncFn1().then(asyncFn2).then(normalFn3);

Copy after login

Looking at it this way, whether it is the first or the second way of writing, it will make people feel that it is not very intuitive, and the way of writing Promise is more intuitive and semantic.

Generator

The Generator function is also a special function provided by ES6, and its grammatical behavior is completely different from traditional functions.

Let’s first look at the actual usage of Generator

function* oneGenerator() {  
yield &#39;Learn&#39;;  
yield &#39;In&#39;;  
return &#39;Pro&#39;;
}var g = oneGenerator();

g.next();   // {value: "Learn", done: false}g.next();   // {value: "In", done: false}g.next();   // {value: "Pro", done: true}

Copy after login

The Generator function is a special function. It has several characteristics:

You need to add
* after function when declaring, and use it with the yield keyword in the function.
在执行Generator函数的时候，其会返回一个Iterator遍历器对象，通过其next方法，将Generator函数体内的代码以yield为界分步执行
具体来说当执行Generator函数时，函数并不会执行，而是需要调用Iterator遍历器对象的next方法，这时程序才会执行从头或者上一个yield之后 到 到下一个yield或者return或者函数体尾部之间的代码，并且将yield后面的值，包装成json对象返回。就像上面的例子中的{value: xxx, done: xxx}。
value取的yield或者return后面的值，否则就是undefined，done的值如果碰到return或者执行完成则返回true，否则返回false。

我们知道了简单的Generator函数的用法以后，我们来看下如何使用Generator函数进行异步编程。

首先我们先来看下使用Generator函数能达到怎样的效果。

// 使用Generator函数进行异步编程function* oneGenerator() {  yield asyncFn1();  yield asyncFn2();  yield normalFn3();
}// 我们来对比一下PromiseasyncFn1().then(asyncFn2).then(normalFn3);

Copy after login

我们可以看出使用Generator函数进行异步编程更像是在写同步任务，对比Promise少了很多次then方法的调用。

好，那么接下来我们就来看下如何实际使用Generator函数进行异步编程。

这里我要特别说明一下，事实上Generator函数不像Promise一样是专门用来解决异步处理而产生的，人们只是使用其特性来产出了一套异步的解决方案，所以使用Generator并不像使用Promise一样有一种开箱即用的感觉。其更像是在Promise或者回调这类的解决方案之上又封装了一层，让你可以像上面例子里一样去那么写。

我们还是具体来看下上面的例子，我们知道单写一个Generator是不能运行的对吧，我们需要执行他并且使用next方法来让他分步执行，那么什么时候去调用next呢？答案就是我们需要在异步完成时去调用next。我们来按照这个思路补全上面的例子。

var g;function asyncFn() {
    setTimeout(function(){
        g.next();
    }, 1000)
}function normalFn() {    console.log(&#39;normalFn run&#39;);
}function* oneGenerator() {  yield asyncFn();  return normalFn();
}

g = oneGenerator();

g.next();// 这里在我调用next方法的时候执行了asyncFn函数// 然后我们的希望是在异步完成时自动去再调用g.next()来进行下面的操作，所以我们必须在上面asyncFn函数体内的写上g.next(); 这样才能正常运行。// 但其实这样是比较奇怪的，因为当我定义asyncFn的时候其实是不知道oneGenerator执行后叫什么名儿的，即使我们提前约定叫g，但这样asyncFn就太过于耦合了，不仅写法很奇怪而且耦合太大不利于扩展和重用。反正总而言之这种写法很不好。

Copy after login

那么怎么解决呢，我们需要自己写个方法，能自动运行Generator函数，这种方法很简单在社区里有很多，最著名的就是大神TJ写的co模块，有兴趣的同学可以看下其源码实现。这里我们简单造个轮子：

// 如果我们想要去在异步执行完成时自动调用next就需要有一个钩子，回调函数的callback或者Promise的then。function autoGenerator(generator){  var g = generator();  function next(){    var res = g.next();  // {value: xxx, done: xxx}

    if (res.done) {        return res.value;
    }    if(typeof res.value === &#39;function&#39;){    // 认为是回调
        res.value(next);
    }else if(typeof res.value === &#39;object&#39; && typeof res.value.then === &#39;function&#39;){     // 认为是promise
        res.value.then(function(){
            next();
        })
    }else{
        next();
    }
  }

  next();
}// ----function asyncFn1(){    console.log(&#39;asyncFn1&#39;);    return new Promise(function(resolve){
        setTimeout(function(){
            resolve();
        }, 1000)
    })
}function asyncFn2() {    console.log(&#39;asyncFn2&#39;);    return function(callback){
        setTimeout(function(){
            callback();
        }, 1000);
    }
}function normalFn() {    console.log(&#39;normalFn&#39;);
}function* oneGenerator() {  yield asyncFn1();  yield asyncFn2();  yield normalFn();
}

autoGenerator(oneGenerator);

Copy after login

这个方法我们简单实现了最核心的部分，有些判断可能并不严谨，但大家理解这个思路就可以了。有了这个方法，我们才可以方便的使用Generator函数进行异步编程。

Async/Await

如果你学会了Generator函数，对于Async函数就会很容易上手。你可以简单把Async函数理解成就是Generator函数+执行器。我们就直接上实例好了

function asyncFn1(){    console.log(&#39;asyncFn1&#39;);    return new Promise(function(resolve){
        setTimeout(function(){
            resolve(&#39;123&#39;);
        }, 2000)
    })
}function asyncFn2() {    console.log(&#39;asyncFn2&#39;);    return new Promise(function(resolve){
        setTimeout(function(){
            resolve(&#39;456&#39;);
        }, 2000)
    })
}

async function asyncFn () {    var a = await asyncFn1();    var b = await asyncFn2();    console.log(a,b)
}

asyncFn();// asyncFn1// asyncFn2// 123，456

Copy after login

当然async里实现的执行器肯定是跟咱们上面简单实现的有所不同，所以在用法上也会有些注意的点

首先async函数的返回值是一个Promise对象，不像是generator函数返回的是Iterator遍历器对象，所以async函数执行后可以继续使用then等方法来继续进行下面的逻辑

await is usually followed by a Promise object. When the async function is executed, after encountering await, it waits for the status of the subsequent Promise object to change from pending to resolved, then returns the resolve parameters and automatically goes down. Execute until the next await or end

await can also be nested with an async function.

Regarding asynchronous, there are still many knowledge points that we have not covered, such as exception handling, multi-asynchronous parallel execution, etc. This and the previous article mainly focus on I hope everyone has an intuitive understanding of asynchronous programming and knows the differences, pros and cons between various solutions. Due to limited space and energy, for other knowledge points that we have not covered, if you are interested and have the opportunity, I will write another article to explain in depth.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

Introduction to JS asynchronous programming

##Basic introduction to React-Reflux

The above is the detailed content of JS asynchronous programming Promise, Generator, async/await. For more information, please follow other related articles on the PHP Chinese website!