HomeBlogWeb DevelopmentAsynchronous Node.js: Concept, Tutorials, Callbacks

Asynchronous Node.js: Concept, Tutorials, Callbacks

Published
05th Sep, 2023
Views
view count loader
Read it in
9 Mins
In this article
    Asynchronous Node.js: Concept, Tutorials, Callbacks

    If your program must wait until a long-running process is complete before responding to new input, you may use asynchronous programming to handle new input while the long-running operation is still running. Your program will be shown the results after the work has been done. 

    There are a number of browser features that may take some time to perform and are consequently async function Node.js. For instance: 

    • using fetch to send HTTP requests () 
    • getUserMedia allows you to access the user's camera or microphone () 
    • utilizing showOpenFilePicker to ask the user to pick files for you to access () 

    Even if you don't have to write your own asynchronous functions on a regular basis, you'll still need to know how to utilize them properly. Starting with the issue of long-running synchronous functions, we'll look at the requirement of asynchronous programming. To know more you can enroll at Node.js certification course.

    What is Asynchronous Node.js?

    Other operations might continue while the transmission is still in progress thanks to asynchronous input/output (I/O). 

    To demonstrate the benefits of not blocking your apps, I'll walk you through an example of a basic file reading process in Node.js async. Both of these are done synchronously and asynchronously. 

    Starting with a basic example, let's see how Node.js may be used to read a file: 

    must be replaced with const fs let the substance speak for itself  

    """""readFileSync("file.md")"""utf-8"" the catch phrase is: "console.log(ex)" console.log(content) 

    This is what happens when we attempt to read data using the synchronous interface for the fs module. The content variable will contain the content of file.md, just as intended. In this case, Node.js async will stay idle while the file is being read, which means it will not be able to perform anything else. 

    Is there anything we can do about it? 

    Asynchronous programming in JavaScript can only be performed if functions are first-class citizens of the language: they may be passed around to other functions like any other variables. In programming jargon, "higher-order functions'' refer to functions that may accept other functions as inputs. A full stack web developer bootcamp is the best choice to know more.

    To demonstrate higher-order functions, consider the following simple example. 

    Numbers in brackets are constants. num > 2 is returned by the isBiggerThanTwo function. filter(isBiggerThanTwo) 

    The filter function accepts a function as an argument, as seen in the example above. In this manner, the logic of filtering may be defined. 

    You may use this technique to create callbacks: If you give one to another method, you can use it as a parameter and call it after you are done with your work. Only call another function with the values, no need to return anything. 

    It's in the core of async await in node js, as well as most of the third-party modules available via Node Package Manager (NPM). 

    For example, while reading a file, the function readFile("file.md," "utf-8," "err," "content") returns if (err) then console.log(err) returns console.log(content). 

    Things to notice: 

    • Instead of using a try-catch block, you must check for problems in the callback function. 
    • without a response: The values given to the callbacks by async functions are not returned. 

    Let's make a few changes to this file to see how it really works: 

    It must be replaced with const fs log('start reading a file...') on the console. This is how you can read a file in utf-8: (err, content) It's safe to assume that (err) console.log("an error occurred while reading the file") would provide the expected result: The end of the file will be logged to the console. 

    • This script's result will be to begin reading a file 
    • file closes at this point 
    • A reading error has occurred 

    Once we began reading our file, the program proceeded to run and displayed the file's conclusion as you can see. A single call to our callback occurred only once the file read was complete. There must be a way. This is your first encounter with an event loop. 

    How to Write Asynchronous Code?

    In many JavaScript applications, the code is performed one line at a time. Node.js async execution refers to the fact that the lines are executed in the sequence in which they were written, one after the other. While some of your commands to the computer are urgent, some are not. It is necessary to wait for the data to be returned before working on a network request, for example. While waiting for the network request to finish, time would be lost if another code was not executed. Asynchronous programming, in which lines of code are executed in a different sequence than the one in which they were created, is used to tackle this issue. Asynchronous programming, on the other hand, allows us to focus on other tasks while we wait for lengthy operations, such as network requests, to complete.

    One thread in a computer process executes JavaScript code. One instruction at a time is executed in a synchronous manner on this thread. This means that if we try to run a long task on this thread, the rest of the code will be blocked until the job is finished. We can circumvent this difficulty by using JavaScript's asynchronous programming tools to delegate long-running activities to a separate thread. The code required to handle the task data is returned to the main single thread after the job is complete. 

    The Event Loop, a Node.js async await construct that completes a new job while waiting for another, will be explained in detail in this article. Create an asynchronous software to get a list of Studio Ghibli movies and save the data to a CSV file using a Studio Ghibli API. Callbacks, promises, and the async/await keywords will all be used to write asynchronous programs. 

    Callbacks

    To use a callback function, an input must be supplied to the other function, which then executes the callback. Because of this, we employ callbacks to guarantee that asynchronous operations are finished before any code can be run. 

    While callbacks were formerly widely used for asynchronous programming, they have now become essentially obsolete due to the fact that they may make code difficult to understand. For the sake of comparing the enhanced efficiency of various solutions, you'll use an example of an asynchronous program that makes use of callbacks in this phase. 

    Callback functions may be used in a variety of ways. As a rule, they follow this format. 

    function asynchronousFunction([ Function Arguments ], [ Callback Function ]) { 
    [ Action ] 
    } 

    To make callbacks easy to recognize, JavaScript and Node.js async do not require that callback functions be the final arguments of the outer function. The usage of an anonymous function as a callback is also widespread among JavaScript developers. Anonymous functions are ones that are not given a name. When a function is defined near the end of the parameter list, it is easier to understand. 

    Let's develop a Node.js module that publishes a list of Studio Ghibli movies to a file in order to show callbacks. To begin, create a folder to house our JavaScript code and the results it produces: 

    mkdir ghibliMovies 
    cd ghibliMovies 

    We'll begin by sending a request to the Studio Ghibli API, and then recording the response in our callback method. This will be accomplished by installing a library that enables callback access to the data included in an HTTP response. 

    So that we have a reference for our packages later on, let's initialize npm in your terminal. 

    const request = require('request'); 
    request('https://ghibliapi.herokuapp.com/films', (error, response, body) => { 
    if (error) { 
    console.error(`Could not send request to API: ${error.message}`); 
    return; 
    } 
    if (response.statusCode != 200) { 
    console.error(`Expected status code 200 but received ${response.statusCode}.`); 
    return; 
    } 
    console.log('Processing our list of movies'); 
    movies = JSON.parse(body); 
    movies.forEach(movie => { 
    console.log(`${movie['title']}, ${movie['release_date']}`); 
    }); 
    }); 

    The request module was installed through npm in the first line. It produces a method for making HTTP requests, which we keep in the constant request. 

    The request() method is then used to send an HTTP request. Now that we've included the modifications noted in red, let's display the data from the HTTP request to the console: 

    const request = require('request'); 
    const fs = require('fs'); 
    request('https://ghibliapi.herokuapp.com/films', (error, response, body) => { 
    if (error) { 
    console.error(`Could not send request to API: ${error.message}`); 
    return; 
    } 
    if (response.statusCode != 200) { 
    console.error(`Expected status code 200 but received ${response.statusCode}.`); 
    return; 
    } 
    console.log('Processing our list of movies'); 
    movies = JSON.parse(body); 
    let movieList = ''; 
    movies.forEach(movie => { 
    movieList += `${movie['title']}, ${movie['release_date']}\n`; 
    }); 
    fs.writeFile('callbackMovies.csv', movieList, (error) => { 
    if (error) { 
    console.error(`Could not save the Ghibli movies to a file: ${error}`); 
    return; 
    } 
    console.log('Saved our list of movies to callbackMovies.csv');; 
    }); 
    }); 
    Two arguments are sent to the request() method when it is called: 
    doSomething1(() => { 
    doSomething2(() => { 
    doSomething3(() => { 
    doSomething4(() => { 
    doSomething5(() => { 
    // final action 
    }); 
    }); 
    }); 
    }); 
    }); 

    The following output you will get: 

    Output 

    Castle in the Sky, 1986 
    Grave of the Fireflies, 1988 
    My Neighbor Totoro, 1988 
    Kiki's Delivery Service, 1989 
    Only Yesterday, 1991 
    Porco Rosso, 1992 
    Pom Poko, 1994 
    Whisper of the Heart, 1995 
    Princess Mononoke, 1997 
    My Neighbors the Yamadas, 1999 
    Spirited Away, 2001 
    The Cat Returns, 2002 
    Howl's Moving Castle, 2004 
    Tales from Earthsea, 2006 
    Ponyo, 2008 
    Arrietty, 2010 
    From Up on Poppy Hill, 2011 
    The Wind Rises, 2013 
    The Tale of the Princess Kaguya, 2013 
    When Marnie Was There, 2014 

    The website's address that we're attempting to get 

    After a request is completed, a callback function is called to handle any problems or successful answers. 

    Error, response, and body make up our three inputs to the callback function. A null response and body would be returned if the request was unable to be sent. The HTTP response is saved if the request was successful. Our HTTP response contains data (in this case, JSON) if it delivers a data-encrypted response. 

    Callback functions initially verify whether an error has occurred before continuing. Error checking is a recommended practice to ensure that the callback doesn't proceed with missing data. Error and function execution are both recorded in this situation. As a last step, we examine the response's status code. In the event our server is unavailable or APIs change, previously correct requests may no longer be valid. We may have faith in our answer if the status code is 200, which indicates that the request was successful. 

    Logging each movie name and release date is done by parsing the response body into an Array. 

    Once the file has been saved and closed, execute this script with: 

    Asynchronous: Event Emitters

    JavaScript function execution is the first topic we'll cover. Having a better understanding of how this works can help you develop more intentional asynchronous code, as well as assist you debug code. 

    Node.js async await call stack grows with each function called by the interpreter as the code is executed. In a list-like data structure, items may only be added or deleted from the top of the stack in the case of the call stack. The "Last in, first out" (LIFO) concept governs the organization of stacks in storage systems like this. It is the most recently added thing that gets deleted first if you have more than one item on top of it. 

    Let's have a look at the call stack as an example. When JavaScript detects a function call to functionA(), it adds it to the stack of functions that have already been invoked. In such a case, functionB() is pushed to the top of the call stack if functionA() calls functionB(). The call stack is cleared after JavaScript completes the execution of a function. Function B() will run first and be removed from the call stack as soon as it is finished. Then function A() will run and be removed from the call stack. Internal functions are always conducted before their external counterparts because of this. 

    In the case of an asynchronous action like writing to a file, JavaScript stores the result in a table in its memory. Whenever an operation is complete, the data in this table is sent to the appropriate function, which is stored in a separate table. Node.js async function adds the function associated with the operation to the message queue as soon as the operation is complete. List-like data structures like queues allow things to be added to the bottom but deleted from the top. There are two or more operations in the message queue that are both ready for their functions to be done, but only one of them has been finished before the other. 

    The call stack is full with functions that are waiting to be called. Checking if the call stack is full is the primary function of the event loop. Otherwise, the message queue's first entry is pushed up to the call stack. Functions in the message queue are given precedence over function calls that JavaScript understands in the code. Call stack, message queue and event loop work together to facilitate JavaScript code execution while handling asynchronous activities. 

    Your asynchronous code will run smoothly now that you have a firm grasp of the event loop. You may now write asynchronous code using callbacks, promises, and async await Node.js/await using this information. 

    Unlock Your Potential with our Programming Fundamentals Course - Start your journey to becoming a coding pro today! Join our unique programming courses and gain the skills you need to succeed. Enroll now!

    Conclusion

    The event loop in JavaScript is used to manage asynchronous processes such as the execution of functions. Async function Node.js programming methods were then used to build programs that generated CSV files after requesting movie data through an HTTP request. In the beginning, you employed a callback-based method that is now obsolete. Finally, async/await was added to the promise syntax to make it more concise. If you want to know more then KnowledgeHut’s Node.js certification course is the best option for you.

    Frequently Asked Questions (FAQs)

    1What do you mean by asynchronous in Node.js?

    Node.js programming using asynchronous events. Other operations might continue while the transmission is still in progress thanks to asynchronous input/output (I/O). 

    2Is everything asynchronous in Node.js?

    Network applications may be built using Node.js, an event-driven JavaScript runtime environment. The term "asynchronous" refers to all of JavaScript's functions that run in the background and do not interfere with other requests. 

    3Why do we use asynchronous in Node.js?

    Because Node.js is single-threaded, it prefers asynchronous APIs. Long-running actions must be non-blocking in order for this to work properly, and asynchronous APIs offer a mechanism to regulate the flow with several non-blocking operations. 

    4What are callbacks in asynchronous?

    A specific sort of callback is an event handler. A callback is just a function that is supplied to another function with the expectation that it will be invoked at a later time as necessary. Asynchronous functions in JavaScript used to be implemented via callbacks, as we've seen. 

    Profile

    Bala Krishna Ragala

    Blog Author

    Bala Krishna Ragala, Head of Engineering at upGrad, is a seasoned writer and captivating storyteller. With a background in EdTech, E-commerce, and LXP, he excels in building B2C and B2B products at scale. With over 15 years of experience in the industry, Bala has held key roles as CTO/Co-Founder at O2Labs and Head of Business (Web Technologies) at Zeolearn LLC. His passion for learning, sharing, and teaching is evident through his extensive training and mentoring endeavors, where he has delivered over 80 online and 50+ onsite trainings. Bala's strengths as a trainer lie in his extensive knowledge of software applications, excellent communication skills, and engaging presentation style.

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Select
    Your Message (Optional)

    Upcoming Web Development Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon