About callback functions

Node.js Succinctly is a basic node.js book. Learn about the asynchronous non-blocking nature for which Node.js is famous. So what is asynchronous non-blocking? First of all, we need to understand that JavaScript itself is an event-driven (observer mode) and single-threaded language, and its characteristics are relevant to the context in which JavaScript was born. JavaScript was originally designed to enrich Web interaction, namely DOM manipulation, simple form validation. Similarly, Node.js executes programs that are inherently single-threaded, because JavaScript is also used. (The decision to use JavaScript was made when Node.js was designed for its single-threaded nature.) If a single thread encounters time-consuming operations such as I/O operations, network access will block the execution process behind the thread. Therefore, in order not to block the only execution thread, asynchronous mode is used. The asynchronous approach is to allow time-consuming operations to be done in other threads, let’s call them worker threads. When some time-consuming operation is completed, the result of execution needs to be returned to the main thread. This step is done through the callback function, which is also event-driven. Therefore, we can say that the most direct expression of asynchronous programming is the callback, but the callback function is not directly related to asynchronous/synchronous. For example:

function heavyCompute(n, callback){ let count = 0, i, j; for (i = n; i > 0; --i){ for(j = n; j > 0; --j){ count += 1; } } callback(count); } heavyCompute(10000, function(count){ console.log(count); }); console.log('hello');Copy the code

The results are as follows:

100000000

hello

As you can see, the callback function of the above code still precedes the subsequent code, and you can also see that JavaScript functions are first-class citizens, as they can also be used as function arguments. This method is called synchronous callbacks, and asynchronous callbacks are similar to the action of clicking a button to trigger a popup when writing a page, as follows:

. let btn = document.getElementByID('myButton'); btn.addEventListen('click',function(ev){ console.log(ev.target); }); .Copy the code

Callback is a mechanism that provides more flexibility than simple function calls. In addition to the above application scenarios, the above callback mechanism can be implemented anytime, not just between applications and libraries. Therefore, we call the above library functions intermediate functions from here on out. How does the flexibility of the callback mechanism work? We can assume that an intermediate function is logically incomplete without passing in a callback function. In other words, a program can change the behavior of intermediate functions by passing in different callback functions at run time, which is much more flexible than a simple function call. Let’s look at an example written in Python:

even.py

Def double(x): return x * 2 def quadruple(x): return x * 4Copy the code

callback_demo.py

Return an odd number def getOddNumber(k, getEvenNumber): Return 1 + getEvenNumber(k) # def main(): Print (I) print(I) print(I) print(I) print(I) print(I) print(I) quadruple) print(i) if __name__ == "__main__": main()Copy the code

Run callback_demp.py and the output is as follows:

3

5

In the above code, getOddNumber behaves differently if you pass it a different callback, which is the advantage of the callback mechanism.

The intermediate function and the callback function are necessary parts of the callback mechanism, but the starting point of the callback mechanism is often overlooked. It is also the caller of the intermediate function, which in most cases can be identified with the main function of the program. Therefore, the callback mechanism is a tripartite linkage of the initial, intermediate, and callback functions. The initiator function and the callback function cannot be seen as one and the same. Because there are actually two types of callback: blocking and deferred. Blocking, the callback must be called before the initial function returns; Deferred, the callback may be called after the initial function has returned. Therefore, the initiator function and the callback function are not the same thing.

Back in JavaScript, why do we need callback functions? So we also said that JavaScript is an event-driven language. This means that the JavaScript executor will not wait for a response, but will continue executing while listening for other events.