The consumer of a callback-based API writes a function that is passed into the API. The provider of the API (called the caller ) takes the function and calls back (or executes) the function at some point inside the caller's body. The caller is responsible for passing the right parameters into the callback function. The caller may also expect a particular return value from the callback function, which is used to instruct further behavior of the caller.

There are two ways in which the callback may be called: synchronous and asynchronous . Synchronous callbacks are called immediately after the invocation of the outer function, with no intervening asynchronous tasks, while asynchronous callbacks are called at some point later, after an asynchronous operation has completed.

Understanding whether the callback is synchronously or asynchronously called is particularly important when analyzing side effects. Consider the following example:

                                    
                                        let
                                        value =
                                        1
                                        ;
                                        doSomething
                                        (
                                        (
                                        )
                                        =>
                                        {
                                        value =
                                        2
                                        ;
                                        }
                                        )
                                        ;
                                        console.
                                        log
                                        (
                                        value)
                                        ;
                                    
                                

If doSomething calls the callback synchronously, then the last statement would log 2 because value = 2 is synchronously executed; otherwise, if the callback is asynchronous, the last statement would log 1 because value = 2 is only executed after the console.log statement.

Examples of synchronous callbacks include the callbacks passed to Array.prototype.map() , Array.prototype.forEach() , etc. Examples of asynchronous callbacks include the callbacks passed to setTimeout() and Promise.prototype.then() .

The Using promises guide has more information on the timing of asynchronous callbacks.