035.1 Lesson 1

It is hard to tell how much time your Node.js program will take to handle a request. Some requests may be short—​perhaps just looping through variables in memory and returning them—​whereas others may require time-consuming activities such as opening a file on the system or issuing a query to a database and waiting for the results. How does Node.js handle this uncertainty? The event loop is the answer.

Imagine a chef doing multiple tasks. Baking a cake is one task that requires a lot of time for the oven to cook it. The chef does not stay there waiting for the cake to be ready and then set out to make some coffee. Instead, while the oven bakes the cake, the chef makes coffee and other tasks in parallel. But the cook is always checking whether it is the right time to switch focus to a specific task (making coffee), or to get the cake out of oven.

The event loop is like the chef who is constantly aware of the surrounding activities. In Node.js, an “event-checker” is always checking for operations that have completed or are waiting to be processed by the JavaScript engine.

Using this approach, an asynchronous and long operation does not block other quick operations that come after. This is because the event loop mechanism is always checking whether that long task, such as an I/O operation, is already done. If not, Node.js can continue to process other tasks. Once the background task is complete, the results are returned and the application on top of Node.js can use a trigger function (callback) to further process the output.

Because Node.js avoids the use of multiple threads, as other environments do, it is called a single-threaded environment, and therefore a non-blocking approach is of the utmost importance. This is why Node.js uses an event loop. For compute-intensive tasks, Node.js is not among the best tools, however: there are other programming languages and environments that address these problems more efficiently.

In the following sections, we will take a closer look at callback functions. For now, understand that callback functions are triggers that are executed upon the completion of a predefined operation.

It is a best practice to break down complex functionality and extensive pieces of code into smaller parts. Doing this modularization helps to better organize the codebase, abstract away the implementations, and avoid complicated engineering problems. To meet those necessities, programmers package blocks of source code to be consumed by other internal or external parts of code.

Consider the example of a program that calculates the volume of a sphere. Open up your text editor and create a file named volumeCalculator.js containing the following JavaScript:

Now, execute the file using Node:

Here, a simple function was used to compute the volume of a sphere, based on its radius. Imagine that we also need to calculate the volume of a cylinder, cone, and so on: we quickly notice that those specific functions must be added to the volumeCalculator.js file, which can become a huge collection of functions. To better organize the structure, we can use the idea behind modules as packages of separated code.

In order to do that, create a separated file called polyhedrons.js:

Now, in the volumeCalculator.js file, delete the old code and replace it with this snippet:

And then run the filename against the Node.js environment:

In the Node.js environment, every source code file is considered a module, but the word “module” in Node.js indicates a package of code wrapped up as in the previous example. By using modules, we abstracted the volume functions away from the main file, volumeCalculator.js, thus reducing its size and making it easier to apply unit tests, which are a good practice when developing real world applications.

Now that we know how modules are used in Node.js, we can use one of the most important tools: the Node Package Manager (NPM).

One of the main jobs of NPM is to manage, download, and install external modules into the project or in the operating system. You can initialize a node repository with the command npm init.

NPM will ask the default questions about the name of your repository, version, description, and so on. You can bypass these steps using npm init --yes, and the command will automatically generate a package.json file that describes the properties of your project/module.

Open the package.json file in your favorite text editor and you will see a JSON file containing properties such as keywords, script commands to use with NPM, a name, etc.

One of those properties is the dependencies that are installed in your local repository. NPM will add the name and version of these dependencies into package.json, along with package-lock.json, another file used as fallback by NPM in case package.json fails.

Type the following in your terminal:

The i flag is a shortcut for the argument install. If you are connected to the internet, NPM will search for a module named dayjs in the remote repository of Node.js, download the module, and install it locally. NPM will also add this dependency to your package.json and package-lock.json files. Now you can see that there is a folder called node_modules, which contains the installed module along with other modules if they are needed. The node_modules directory contains the actual code that is going to be used when the library is imported and called. However, this folder is not saved in versioning systems using Git, since the package.json file provides all the dependencies used. Another user can take the package.json file and simply run npm install in their own machine, where NPM will create a node_modules folder with all the dependencies in the package.json, thus avoiding version control for the thousands of files available on the NPM repository.

Now that the dayjs module is installed in the local directory, open the Node.js console and type the following lines:

The dayjs module is loaded with the require keyword. When a method from the module is called, the library takes the current system datetime and outputs it in the specified format:

This is the same mechanism used in the previous example, where the Node.js runtime loads the third party function into the code.

Because Node.js controls the back end of web applications, one of its core tasks is to handle HTTP requests.

Here is a summary of how web servers handled incoming HTTP requests. The functionality of the server is to listen for requests, determine as quickly as possible what response each needs, and return that response to the sender of the request. This application must receive an incoming HTTP request triggered by the user, parse the request, perform the calculation, generate the response, and send it back. An HTTP module such as Node.js is used because it simplifies those steps, alowing a web programmer to focus on the application itself.

Consider the following example that implements this very basic functionality:

Save these contents in a file called basic_server.js and run it through a node command. The terminal running Node.js will display the following message:

Then visit the following URL in your web browser: http://127.0.0.1:3000/numbers?a=2&b=17

Node.js is running a web server in your computer, and using two modules: http and url. The http module sets up a basic HTTP server, processes the incoming web requests, and hands them to our simple application code. The URL module parses the arguments passed in the URL, converts them into an integer format, and performs the addition operation. The http module then sends the response as text to the web browser.

In a real web application, Node.js is commonly used to process and retrieve data, usually from a database, and return the processed information to the front end to display. But the basic application in this lesson concisely shows how Node.js makes use of modules to handle web requests as a web server.