JS ES6 asynchronous solution

Initially using the callback function

​ Because there was no clear official specification for js at the beginning, there was no clear specification for the parameters in the callback functions passed in the asynchronous functions encapsulated in various third-party libraries, and the meaning of each parameter was not clear, which made it inconvenient to use.

But there are clear specifications in node

Callback mode in node:

1. All callback functions must have two parameters, the first parameter indicates the error, and the second parameter indicates the result

2. All callback functions must be the last parameter of the function

3. All callback functions cannot appear as attributes

es6 asynchronous processing model

After the emergence of Es6, the official proposed specifications for asynchronous processing and a processing model suitable for all asynchronous scenarios. The model has:

• Two stages: unsettled and settled.
• Three states: pending, resolved, rejected
• Always push from the unresolved stage to the resolved stage, and the status of the resolved stage will not change

After the task is in the resolved state, subsequent processing may be required.

• We call the subsequent processing of resolved thenable
• We call the subsequent processing of rejected catchable

API tailored for this asynchronous model: promise

How to use promises

Copy

const task = new Promise((resolve, reject) => {     
    // Code for pending task stage // Execute immediately console.log("Start 100-meter long-distance running");  
    setTimeout(() => {  
       if (Math.random() > 0.5) {  
           // Success: Finished // Push to success resolve("finished");  
       } else {  
           // Failure: Broken leg // Push to failure reject("Broken leg");  
       }  
    }, 1000)
});
task.then((result) => {
  console.log(result);
}).catch((error) => {
  console.log(error);
})

After 1 second, the task is pushed to resolved, and subsequent processing is handled in then or catch.

Notice

pending status = > rejected status:

Copy

1. Call reject

2. Code execution error

3. Throwing errors manually

Subsequent processing functions must be asynchronous and will be placed in the micro queue.

After the js execution stack is cleared, the tasks in the micro queue will be executed first. After the tasks in the micro queue are cleared, the tasks in the macro queue will be executed.

• Macro task queues include: setTimeout, setInterval, setImmediately, I/O, UI render
• Microtask queues include: promise, process.nexttick, Object.observe (no longer used), Mutation.observe

Async await is the syntactic sugar of promise added in es7. You can also learn about it. This article only gives an overview of promise. There are many other details to master.

The above is the details of JS ES6 asynchronous solution. For more information about ES6 asynchronous solution, please pay attention to other related articles on 123WORDPRESS.COM!