bmen-jekyll/_posts/2018-12-01-what-the-heck-is...

6.1 KiB
Raw Blame History

title tags style color description
What the heck is a Callback?
JavaScript
Nodejs
Web Development
fill danger Learn and understand the basics of callbacks in just 6 minutes with easy examples.

Source: Brandon Morelli

What is a Callback?

Simply put: A callback is a function that is to be executed after another function has finished executinghence the name call back.

More complexly put: In JavaScript, functions are objects. Because of this, functions can take functions as arguments, and can be returned by other functions. Functions that do this are called higher-order functions. Any function that is passed as an argument is called a callback function.

^ Thats a lot of words. Lets look at some examples to break this down a little more.

Why do we need Callbacks?

For one very important reasonJavaScript is an event driven language. This means that instead of waiting for a response before moving on, JavaScript will keep executing while listening for other events. Lets look at a basic example:

function first(){
  console.log(1);
}
function second(){
  console.log(2);
}
first();
second();

As you would expect, the function first is executed first, and the function second is executed secondlogging the following to the console:

// 1
// 2

All good so far.

But what if function first contains some sort of code that cant be executed immediately? For example, an API request where we have to send the request then wait for a response? To simulate this action, were going to use setTimeout which is a JavaScript function that calls a function after a set amount of time. Well delay our function for 500 milliseconds to simulate an API request. Our new code will look like this:

function first(){
  // Simulate a code delay
  setTimeout( function(){
    console.log(1);
  }, 500 );
}
function second(){
  console.log(2);
}
first();
second();

Its not important that you understand how setTimeout() works right now. All that matters is that you see weve moved our console.log(1); inside of our 500 millisecond delay. So what happens now when we invoke our functions?

first();
second();
// 2
// 1

Even though we invoked the first() function first, we logged out the result of that function after the second() function.

Its not that JavaScript didnt execute our functions in the order we wanted it to, its instead that JavaScript didnt wait for a response from first() before moving on to execute second().

So why show you this? Because you cant just call one function after another and hope they execute in the right order. {% include elements/highlight.html text="Callbacks are a way to make sure certain code doesnt execute until other code has already finished execution." %}

Create a Callback

Alright, enough talk, lets create a callback!

First, open up your Chrome Developer Console (Windows: Ctrl + Shift + J)(Mac: Cmd + Option + J) and type the following function declaration into your console:

function doHomework(subject) {
  alert(`Starting my ${subject} homework.`);
}

Above, weve created the function doHomework . Our function takes one variable, the subject that we are working on. Call your function by typing the following into your console:

doHomework('math');
// Alerts: Starting my math homework.

Now lets add in our callbackas our last parameter in the doHomework() function we can pass in callback. The callback function is then defined in the second argument of our call to doHomework().

function doHomework(subject, callback) {
  alert(`Starting my ${subject} homework.`);
  callback();
}

doHomework('math', function() {
  alert('Finished my homework');
});

As youll see, if you type the above code into your console you will get two alerts back to back: Your starting homework alert, followed by your finished homework alert.

But callback functions dont always have to be defined in our function call. They can be defined elsewhere in our code like this:

function doHomework(subject, callback) {
  alert(`Starting my ${subject} homework.`);
  callback();
}
function alertFinished(){
  alert('Finished my homework');
}
doHomework('math', alertFinished);

This result of this example is exactly the same as the previous example, but the setup is a little different. As you can see, weve passed the alertFinished function definition as an argument during our doHomework() function call!

A real world example

Last week I published an article on how to Create a Twitter Bot in 38 lines of code. The only reason the code in that article works is because of Twitters API. When you make requests to an API, you have to wait for the response before you can act on that response. This is a wonderful example of a real-world callback. Heres what the request looks like:

T.get('search/tweets', params, function(err, data, response) {
  if(!err){
    // This is where the magic will happen
  } else {
    console.log(err);
  }
})
  • T.get simply means we are making a get request to Twitter
  • There are three parameters in this request: search/tweets, which is the route of our request, params which are our search parameters, and then an anonymous function which is our callback.

A callback is important here because we need to wait for a response from the server before we can move forward in our code. We dont know if our API request is going to be successful or not so after sending our parameters to search/tweets via a get request, we wait. Once Twitter responds, our callback function is invoked. Twitter will either send an err (error) object or a response object back to us. In our callback function we can use an if() statement to determine if our request was successful or not, and then act upon the new data accordingly.