Thursday, March 16, 2023
HomeWeb DevelopmentSaved from Callback Hell - SitePoint

Saved from Callback Hell – SitePoint

Callback hell is actual. Builders usually see callbacks as pure evil, even to the purpose of avoiding them. JavaScriptʼs flexibility doesn’t assist in any respect with this. But it surely’s not essential to keep away from callbacks. The excellent news is that there are easy steps to get saved from callback hell.

Devil standing over offce worker with receivers hanging everywhere

Eliminating callbacks in your code is like amputating leg. A callback perform is among the pillars of JavaScript and one in all its good elements. Whenever you exchange callbacks, you’re usually simply swapping issues.

Some say callbacks are ugly warts and are the rationale to review higher languages. Properly, are callbacks that ugly?

Wielding callbacks in JavaScript has its personal set of rewards. There’s no motive to keep away from JavaScript as a result of callbacks can flip into ugly warts.We are able to simply guarantee that doesn’t occur.

Letʼs dive into what sound programming has to supply with callbacks. Our desire is to stay to SOLID ideas and see the place this takes us.

What Is Callback Hell?

It’s possible you’ll be questioning what a callback is and why it is best to care. In JavaScript, a callback is a perform that acts as a delegate. The delegate executes at an arbitrary second sooner or later. In JavaScript, the delegation occurs when the receiving perform calls the callback. The receiving perform could achieve this at any arbitrary level in its execution.

In brief, a callback is a perform handed in as an argument to a different perform. There’s no fast execution, because the receiving perform decides when to name it. The next code pattern illustrates:

perform receiver(fn) {
  return fn();

perform callback() {
  return 'foobar';

var callbackResponse = receiver(callback); 

In case you’ve ever written an Ajax request, you’ve encountered callback capabilities. Asynchronous code makes use of this strategy, since there’s no assure when the callback will execute.

The issue with callbacks stems from having async code that is dependent upon one other callback. We are able to use setTimeout to simulate async calls with callback capabilities.

Be at liberty to observe alongside. The repo is out there on GitHub, and most code snippets will come from there so you may play alongside.

Behold, the pyramid of doom!

setTimeout(perform (title) {
  var catList = title + ',';

  setTimeout(perform (title) {
    catList += title + ',';

    setTimeout(perform (title) {
      catList += title + ',';

      setTimeout(perform (title) {
        catList += title + ',';

        setTimeout(perform (title) {
          catList += title;

        }, 1, 'Lion');
      }, 1, 'Snow Leopard');
    }, 1, 'Lynx');
  }, 1, 'Jaguar');
}, 1, 'Panther');

Trying on the code above, setTimeout will get a callback perform that executes after one millisecond. The final parameter simply feeds the callback with information. That is like an Ajax name, besides that the return title parameter would come from the server.

There’s a good overview of the setTimeout perform on SitePoint.

In our code, we’re gathering a listing of ferocious cats via asynchronous code. Every callback provides us a single cat title, and we append that to the record. What we’re making an attempt to realize sounds cheap. However given the flexibleness of JavaScript capabilities, it is a nightmare.

Nameless Features

Discover the usage of nameless capabilities in that earlier instance. Nameless capabilities are unnamed perform expressions that get assigned to a variable or handed as an argument to different capabilities.

Utilizing nameless capabilities in your code is just not really helpful by some programming requirements. It’s higher to call them, so use perform getCat(title){} as an alternative of perform (title){}. Placing names in capabilities provides readability to your applications. These nameless capabilities are simple to kind, however they ship you barreling down on a freeway to hell. When you end up taking place this winding highway of indentations, it’s finest to cease and rethink.

One naive strategy to breaking this mess of callbacks is for us to make use of perform declarations:

setTimeout(getPanther, 1, 'Panther');

var catList = '';

perform getPanther(title) {
  catList = title + ',';

  setTimeout(getJaguar, 1, 'Jaguar');

perform getJaguar(title) {
  catList += title + ',';

  setTimeout(getLynx, 1, 'Lynx');

perform getLynx(title) {
  catList += title + ',';

  setTimeout(getSnowLeopard, 1, 'Snow Leopard');

perform getSnowLeopard(title) {
  catList += title + ',';

  setTimeout(getLion, 1, 'Lion');

perform getLion(title) {
  catList += title;


You received’t discover this snippet within the repo, however the incremental enchancment may be discovered on this commit.

Every perform will get its personal declaration. One upside is that we now not get the ugly pyramid. Every perform will get remoted and laser centered by itself particular job. Every perform now has one motive to alter, so it’s a step in the correct course. Be aware that getPanther(), for instance, will get assigned to the parameter. JavaScript doesn’t care how we create callbacks. However what are the downsides?

For a full breakdown of the variations, see this SitePoint article on Operate Expressions vs Operate Declarations.

A draw back, although, is that every perform declaration now not will get scoped contained in the callback. As a substitute of utilizing callbacks as a closure, every perform now will get glued to the outer scope. Therefore why catList will get declared within the outer scope, as this grants the callbacks entry to the record. At instances, clobbering the worldwide scope isn’t a great answer. There’s additionally code duplication, because it appends a cat to the record and calls the subsequent callback.

These are code smells inherited from callback hell. Generally, striving to enter callback freedom wants perseverance and a spotlight to element. It could begin to really feel as if the illness is healthier than the remedy. Is there a solution to code this higher?

Dependency Inversion

The dependency inversion precept says we must always code to abstractions, to not implementation particulars. On the core, we take a big downside and break it into little dependencies. These dependencies turn into unbiased to the place implementation particulars are irrelevant.

This SOLID precept states:

When following this precept, the standard dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules unbiased of the low-level module implementation particulars.

So what does this blob of textual content imply? The excellent news is that, by assigning a callback to a parameter, we’re already doing this! A minimum of partially, to get decoupled, consider callbacks as dependencies. This dependency turns into a contract. From this level ahead, we’re doing SOLID programming.

One solution to achieve callback freedom is to create a contract:


This defines what we plan to do with the callback. It must hold observe of a single parameter — that’s, our record of ferocious cats.

This dependency can now get fed via a parameter:

perform buildFerociousCats(record, returnValue, fn) {
  setTimeout(perform asyncCall(information) {
    var catList = record === '' ? information : record + ',' + information;

  }, 1, returnValue);

Be aware that the perform expression asyncCall will get scoped to the closure buildFerociousCats. This system is highly effective when coupled with callbacks in async programming. The contract executes asynchronously and good points the information it wants, all with sound programming. The contract good points the liberty it wants because it will get decoupled from the implementation. Stunning code makes use of JavaScriptʼs flexibility to its personal benefit.

The remainder of what must occur turns into self-evident. We are able to do that:

buildFerociousCats('', 'Panther', getJaguar);

perform getJaguar(record) {
  buildFerociousCats(record, 'Jaguar', getLynx);

perform getLynx(record) {
  buildFerociousCats(record, 'Lynx', getSnowLeopard);

perform getSnowLeopard(record) {
  buildFerociousCats(record, 'Snow Leopard', getLion);

perform getLion(record) {
  buildFerociousCats(record, 'Lion', printList);

perform printList(record) {

There’s no code duplication right here. The callback now retains observe of its personal state with out international variables. A callback resembling getLion can get chained with something that follows the contract — that’s, any abstraction that takes a listing of ferocious cats as a parameter. This pattern code is out there on GitHub.

Polymorphic Callbacks

Okay, letʼs get a bit loopy. What if we wished to alter the habits from making a comma-separated record to a pipe-delimited one? One downside we are able to envisage is that buildFerociousCats has been glued to an implementation element. Be aware the usage of record + ',' + information to do that.

The easy reply is polymorphic habits with callbacks. The precept stays: deal with callbacks like a contract and make the implementation irrelevant. As soon as the callback elevates to an abstraction, the precise particulars can change at will.

Polymorphism opens up new methods of code reuse in JavaScript. Consider a polymorphic callback as a solution to outline a strict contract, whereas permitting sufficient freedom that implementation particulars now not matter. Be aware that we’re nonetheless speaking about dependency inversion. A polymorphic callback is only a fancy title that factors out one solution to take this concept additional.

Letʼs outline the contract. We are able to use the record and information parameters on this contract:

cat.delimiter(cat.record, information);

Then we are able to make a number of tweaks to buildFerociousCats:

perform buildFerociousCats(cat, returnValue, subsequent) {
  setTimeout(perform asyncCall(information) {
    var catList = cat.delimiter(cat.record, information);

    subsequent({ record: catList, delimiter: cat.delimiter });
  }, 1, returnValue);

The JavaScript object cat now encapsulates the record information and delimiter perform. The subsequent callback chains async callbacks — previously known as fn. Discover that there’s freedom to group parameters at will with a JavaScript object. The cat object expects two particular keys — record and delimiter. This JavaScript object is now a part of the contract. The remainder of the code stays the identical.

To fireplace this up, we are able to do that:

buildFerociousCats({ record: '', delimiter: commaDelimiter }, 'Panther', getJaguar);
buildFerociousCats({ record: '', delimiter: pipeDelimiter }, 'Panther', getJaguar);

The callbacks get swapped. So long as contracts get fulfilled, implementation particulars are irrelevant. We are able to change the habits with ease. The callback, which is now a dependency, will get inverted right into a high-level contract. This concept takes what we already find out about callbacks and raises it to a brand new degree. Decreasing callbacks into contracts lifts up abstractions and decouples software program modules.

What’s so radical right here is that unit exams naturally movement from unbiased modules. The delimiter contract is a pure perform. Because of this, given quite a few inputs, we get the identical output each single time. This degree of testability provides confidence that the answer will work. In spite of everything, modular independence grants the correct to self-assess.

An efficient unit take a look at across the pipe delimiter would possibly look one thing like this:

describe('A pipe delimiter', perform () {
  it('provides a pipe within the record', perform () Cat');

Iʼll allow you to think about what the implementation particulars seem like. Be at liberty to take a look at the commit on GitHub.


A promise is just a wrapper across the callback mechanism, and permits for a thenable to proceed the movement of execution. This makes the code extra reusable as a result of you may return a promise and chain the promise.

Let’s construct on prime of the polymorphic callback and wrap this round a promise. Tweak the buildFerociousCats perform and make it return a promise:

perform buildFerociousCats(cat, returnValue, subsequent) {
  return new Promise((resolve) => { 
    setTimeout(perform asyncCall(information) {
      var catList = cat.delimiter(cat.record, information);

      resolve(subsequent({ record: catList, delimiter: cat.delimiter }));
    }, 1, returnValue);

Be aware the usage of resolve: as an alternative of utilizing the callback instantly, that is what resolves the promise. The consuming code can apply a then to proceed the movement of execution.

As a result of we’re now returning a promise, the code should hold observe of the promise within the callback execution.

Let’s replace the callback capabilities to return the promise:

perform getJaguar(cat) {
  return buildFerociousCats(cat, 'Jaguar', getLynx); 

perform getLynx(cat) {
  return buildFerociousCats(cat, 'Lynx', getSnowLeopard);

perform getSnowLeopard(cat) {
  return buildFerociousCats(cat, 'Snow Leopard', getLion);

perform getLion(cat) {
  return buildFerociousCats(cat, 'Lion', printList);

perform printList(cat) {

The final callback doesn’t chain guarantees, as a result of it doesn’t have a promise to return. Retaining observe of the guarantees is vital for guaranteeing a continuation on the finish. By way of analogy, after we make a promise, one of the best ways to maintain the promise is by remembering that we as soon as made that promise.

Now let’s replace the principle name with a thenable perform name:

buildFerociousCats({ record: '', delimiter: commaDelimiter }, 'Panther', getJaguar)
  .then(() => console.log('DONE')); 

If we run the code, we’ll see that “DONE” prints on the finish. If we neglect to return a promise someplace within the movement, “DONE” will seem out of order, as a result of it loses observe of the unique promise made.

Be at liberty to take a look at the commit for guarantees on GitHub.


Lastly, we are able to consider async/await as syntactic sugar round a promise. To JavaScript, async/await is definitely a promise, however to the programmer it reads extra like synchronous code.

From the code now we have to date, let’s eliminate the then and wrap the decision round async/await:

async perform run() {
  await buildFerociousCats({ record: '', delimiter: pipeDelimiter }, 'Panther', getJaguar)
run().then(() => console.log('DONE DONE')); 

The output “DONE” executes proper after the await, as a result of it really works very similar to synchronous code. So long as the decision into buildFerociousCats returns a promise, we are able to await the decision. The async marks the perform as one returning a promise, so’t remains to be attainable to chain the decision into run with yet one more then. So long as what we name into returns a promise, we are able to chain guarantees indefinitely.

You may verify this out within the async/await commit on GitHub.

Needless to say all this asynchronous code runs within the context of a single thread. A JavaScript callback matches effectively inside this single-threaded paradigm, as a result of the callback will get queued in such a approach that it doesn’t block additional execution. This makes it simpler for the JavaScript engine to maintain observe of callbacks, and choose up the callback instantly with out having to take care of synchronizing a number of threads.


Mastering callbacks in JavaScript is knowing all of the trivialities. I hope you see the delicate variations in JavaScript capabilities. A callback perform turns into misunderstood after we lack the basics. As soon as JavaScript capabilities are clear, SOLID ideas quickly observe. It requires a powerful grasp of the basics to get a shot at SOLID programming. The inherent flexibility within the language locations the burden of duty on the programmer.

What I like probably the most is that JavaScript empowers good programming. A very good grasp of all of the trivialities and fundamentals will take us far in any language. This strategy to callback capabilities is tremendous vital in vanilla JavaScript. By necessity, all of the nooks and crannies will take our expertise to the subsequent degree.



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments