Ultimate Node.js for Cross-Platform App Development: Learn to Build Robust, Scalable, and Performant Server-Side JavaScript Applications with Node.js (English Edition)

CHAPTER 1

Getting Started with Node.js

Introduction

This chapter will help in get started with Node.js, involving activities such as installation, running CLI commands, and creating our first Node.js applications. In this chapter, we will also briefly review some of the topics covered across further chapters of this book.

Structure

In this chapter, the following topics will be covered:

History of Node.js

Defining Node.js

Some Important Uses of Node.js

Installing and Setting Up a Local Environment

Understanding Some of the Core Concepts of Node.js

Node.js Console REPL

NPM and package.json

Creating our First Applications

History of Node.js

Today, JavaScript is one of the world’s most popular programming languages. Node.js was created by Ryan Dahl back in 2009 and was initially supported only on Linux and MacOS. Its early development and maintenance were sponsored by Joyent.

In 2010, NPM, a package manager, was introduced, which makes it very easy for developers to publish and share the source code of Node.js. In late 2014, because of internal conflict over Joyent governance, a group of techies who were also contributors to the original node project forked Node into something called IO.js for rapid development and to make the latest features available. In early 2015, the Node.js foundation was announced with key members such as IBM, Intel, Microsoft, PayPal, and many more.

The first official release of Node.js after its merger with IO.js was versioned as 4.x. The new Node.js foundation has taken the entire framework to new heights by releasing new versions with the latest features as well as fixing several issues related to security and performance, which have become a key for the adoption of Node.js into mainstream enterprise web application development.

Unlike other programming languages such as JAVA and .NET, PHP Node is also a platform. This means you have full control over your app logic and the environment within which it must operate. You can effectively write your app code using JavaScript or TypeScript and utilize amazing server stack support.

Defining Node.js

As per official documentation from the Node.js website:

Node.js is an open-source and cross-platform JavaScript runtime environment. It is a popular tool for almost any kind of project!

Let’s break this definition down into three important parts, as follows:

First, Node.js is an open-source framework, which means the source code for Node.js is publicly available for sharing, modification, and improvements.

Second, Node.js is cross-platform, which means we can run any application developed using Node.js on any platform such as Mac, Windows, and Linux.

Finally, Node.js is a JavaScript runtime environment, which means it provides all required infrastructure and support to execute application code using the V8 JavaScript engine outside the browser environment.

Some other definitions are as follows. The following definition is taken from https://www.toptal.com:

Node.js is composed of Google’s V8 JavaScript engine, the libUV platform abstraction layer, and a core library that is written in JavaScript. Additionally, Node.js is based on the open web stack (HTML, CSS, and JS) and operates over the standard port 80.

As per flaviocopes (https://flaviocopes.com/nodejs/):

Node.js is open source and cross-platform, and since its introduction in 2009, it has become hugely popular and now plays a significant role in the web development scene. If GitHub stars are one popularity indication factor, having 100k+ stars means being very popular.

Features of Node.js

Some of the core features of Node.js are as follows:

Asynchronous

The core of Node.js lies in the fact that its APIs are mostly based on asynchronous nature where Node.js doesn’t wait for processing requests; it keeps on moving to the next one using the Event loop technique. It works on events, and when processing is done, it will get a response back to the caller of the service.

Event Driven

Node provides a module called Event that has an EventEmitter class, which gives us the power to implement event-driven programming. An event handler is a user-defined function that is called when an event is triggered. The main loop listens for event triggers and calls the appropriate event handler.

An EventEmitter has several methods, including emit(), which is used to trigger the event. emit() has two arguments: the first is the name of the event, and the second argument is used to pass the data. The on() method is used to listen for and execute published events.

No Buffering

In Node.js, there is no buffering of data because of its asynchronous nature, and users always receive data more easily as they don’t have to keep waiting for the entire operation to complete. This all happens when we use callback functions, which help to keep processing data until everything is done completely.

Single-Threaded Architecture

Node.js architecture is based on a single-threaded event loop model architecture that can handle multiple client requests at the same time. The main event loop is executed by a single thread, but in the background, most of the time-consuming I/O work is done using separate threads. Due to this, all operations performed by Node.js are asynchronous (non-blocking design) to accommodate event loops. The event loop allows node.js to perform all non-blocking operations seamlessly.

Highly Scalable

Node.js backend applications are highly scalable and can handle millions of requests using a single thread asynchronously and can use child processes to partition applications horizontally to handle all requests.

Fast Execution

Node.js can execute code much faster by using the V8 engine, which compiles JavaScript code into machine code and helps to reduce the overall time taken to handle multiple requests in Node.js applications.

Cross-Platform

The main advantage of Node.js is running applications across multiple platforms like Windows, Mac, Linux, and more. Since it’s a very lightweight framework, it helps to build and deploy easily on server-based processor architecture.

Reasons for Node.js Popularity

While we have explored some of the key features that have made Node.js one of the popular frameworks across enterprises, it’s not only driving the development community towards Node.js. Let’s discuss some more general benefits of using Node.js to build enterprise applications:

Single JavaScript language

Node.js is a technology with which you can build end-to-end JavaScript applications. Learn one language, and you can develop both the frontend and backend for your apps.

Widely Adoption of Node.js

Several major companies, such as LinkedIn, Netflix, and PayPal, have all migrated from other back-end technologies to Node.js.

Full-stack Development Demand

Full-stack development is one of the most sought-after skill sets by companies right now. If you’re a front-end developer, learning Node.js will help you become a full-stack developer easily.

Huge Community Support

There is a huge community support for Node.js, and you will always get help on any issues or concerns related to development.

Apart from this, the following are some of the key features that also made Node.js so popular:

Building real-time apps like chat

Real-time gaming applications

Apps that require lots of asynchronous I/O operations

Scalable web applications like e-commerce

Serverless web apps using Azure function, AWS Lambda, or Google Cloud functions

Lightweight mobile friendly RESTful APIs

Power of running entire application on a single thread

There are many frameworks that are open source and can be used to develop applications on top of core Node.js, such as:

Express.js

Meteor.js

Koa.js

Sails.js

Next.js

Hapi.js

Node.js cannot be used in case of the following facts:

Performance bottlenecks with heavy computation tasks

Callback hell issue

Immature tooling and dependency management

Unstable APIs developed by third parties

Applications using high CPU usage

Node.js versus Browser JavaScript

The following table displays the difference between JavaScript and Node.js:

Table 1.1: Difference between Node.js and Browser JavaScript

Installing Node.js

There are various ways by which we can install Node.js on our local system. The easiest way to install is by downloading it from the official website of Node.js.

Perform the following steps to download and install Node.js on the Windows system:

Go to the official website: https://nodejs.dev/download/

Download for 64-bit Windows setup file node-v20.10.0-x64.msi

Figure 1.1: Downloading Node.js setup file

Run the setup by double-clicking the downloaded file from the setup files and follow these steps:

Click Install and wait for it to finish setup.

Once the setup is completed, open cmd or Terminal and type node –-version to verify the successfully installed node version.

Figure 1.2: Checking Node.js Version

Here are the following steps to install Node.js on a Mac system:

Download the macOS installer from the official website:

Figure 1.3: Downloading setup file for macOS

Running Node.js Installer:

Introduction -> Licence -> Select Destination -> Agree Installation Type -> Install -> Authenticate with your Mac cred -> Summary

Figure 1.4: Node.js Installation on Mac

Verify Node.js Installation:

$ node -v node -v // The command tells what version of Node.js is installed currently.

Update NPM version:

$ sudo npm install npm --global // Update the npm cli client

Now let’s install Node.js on Linux/Unix.

We can install any software on a Linux machine by using the APT package repository. Before installing any software, we need to update the System’s Package repository.

Update System’s Package:

$ sudo apt update

Figure 1.5: Software update on Linux

Download and install Node.js:

$ sudo apt install nodejs -y

Figure 1.6: Node.js Installation on Linux

Installing NPM:

$ sudo apt install npm -y

Figure 1.7: NPM Installation on Linux

Checking installed versions:

$ nodejs –version

Figure 1.8: Checking Node.js Installation on Linux

Installing NVM on Windows

We can install NVM through the following link:

https://learn.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows

The following steps will be used to install NVM on Windows:

We need to download the latest package from https://github.com/coreybutler/nvm-windows/releases

Figure 1.9: Downloading NVM package

Running installation from downloaded exe file:

Figure 1.10: Starting NVM installation process

Setting the installation path, keep the default:

Figure 1.11: Setting up installation path

Click Install to start the installation process:

Figure 1.12: Start installation

Accept the pop-up to Node xxx is already installed. Do you want to NVM control this version:

Figure 1.13: Allow NVM to control existing Node.js version

Finish setup.

Figure 1.14: Click Finish to complete NVM installation

Verifying NVM Installation

Let’s perform the following step to verify NVM installation on our local system:

Open CMD and type nvm command:

Figure 1.15: Open CMD to verify installation

To check the list of Node.js installation on Windows, type nvm list:

Figure 1.16: Get the list of all Node.js versions

To switch Node.js versions, type nvm use 14.20.0:

Figure 1.17: Switching to different Node.js versions

Some Core Concepts of Node.js

Let us understand some core concepts of Node.js.

V8 Engine

Node.js implements Google’s incredibly powerful JavaScript engine, also known as Chrome V8.

What exactly do we mean by JavaScript engine?

A JavaScript engine is responsible for compiling and executing JavaScript code and managing resources and memory allocation written in C++. The V8 engine is already being used in our Chrome browser. V8 can be made to run as a standalone program or be embedded into any C++ program, thus enabling a JavaScript-based scripting interface, all the while delivering incredible performance and flexibility. This also allows you to expand and introduce your own flavor of JavaScript as needed in a specific scenario. Since V8 is a virtual machine, which means that it abstracts the underlying hardware from the actual JavaScript code by simulating a universal environment for the execution environment. You can use V8 and consequently not just on Windows, Mac, and Linux almost seamlessly. This is great since it enables developers to deploy their apps virtually into any kind of execution environment without worrying too much about the underlying hardware.

JavaScript, coupled with the performance benefits of C++ programming, can make a difference. Now as far as Node.js goes, V8 is implemented along with an abstraction layer called libuv, which enables Node.js to perform seamless input and output operations across a gamut of operating systems in a non-blocking way. Along with libuv, node.js also comes with a built-in core library that provides a host of useful methods that developers can use to write programs, such as web servers and network apps.

Figure 1.18: V8 engine core layers

Blocking versus Non-blocking Operations

Let’s try and understand what this really means, and why it makes Node.js different from other server technologies, such as Java, PHP, and more.

Blocking operations happen when the execution of JavaScript code inside the Node.js process has to wait until all the code executes synchronously and the control moves to execute the next statement.

For example, when we read a File System using the fs NPM package:

const fs = require(fs);

const data = fs.readFileSync(/file.md); // blocks here until file is read

console.log(data);

In the preceding code, fs.readFileSync() will block the execution of any additional JavaScript unless the entire file data is read completely and the output is shown in the console.

Non-blocking operations are asynchronous in nature and don’t wait for the operation to complete; they continue to execute the next line of statements. Once the operation is successful, the code inside the error first callback function (err, data) is executed:

const fs = require(fs);

fs.readFile(/file.md, (err, data) => {

if (err) throw err;

console.log(data);

});

In the preceding example, the file content is read asynchronously. After operation is completed, the callback function (err, data) is executed to either throw an error or log data into the console.

Figure 1.19: Synchronous vs. Asynchronous I/O

Event Loop

Node.js is a single-threaded, event-driven framework that can execute asynchronous, non-blocking code. It is efficient regarding memory, thanks to these features. Although JavaScript is single-threaded, Node.js can conduct non-blocking I/O operations because of the event loop. This is accomplished by delegating tasks to the operating system whenever it is practical.

Figure 1.20: Synchronous vs. Asynchronous I/O

The Event Loop has one simple job - to monitor the Call Stack, the Callback Queue, and the Microtask queue. If the Call Stack is empty, the Event Loop will take the first event from the microtask queue and then from the callback queue and will push it to the Call Stack, which effectively runs it. Such an iteration is called a tick in the Event Loop.

As JavaScript is single-threaded, which means two statements in JavaScript cannot be executed in parallel. Execution happens line by line, which means each JavaScript statement is synchronous and blocking in nature. However, there is a way to run your code asynchronously or in parallel. If you use the setTimeout() function, your code executes after a specified time (in milliseconds).

Let’s understand this with the following example:

console.log(Start);

setTimeout(function callbackFunc(){

console.log(Settimeout called after 5 seconds);

// now sum will be called"

sum();

},5000);

fetch(http://example.com/).then(function outPutFunc(){

console.log(Call back from example api);

});

function sum(x, y){

return x +y;

}

//......................

//.....................

console.log(end);

setTimeout takes a callback function as the first parameter and a time in milliseconds as the second parameter. After the execution of the preceding statement in the browser console, it will print:

Start

End

Call back from example api

Settimeout called after 5 seconds

Now sum will be called

Note: Your asynchronous code runs after all the synchronous code is done executing.

Following are the key steps that happen while running the preceding application:

JS engine executes the first line and prints Start in the console.

The Second line sees the setTimeout(), a function named callbackFunc, and the JS engine pushes the callbackFunc function to the callback queue.

Subsequently, the pointer will directly jump to line seven, and there it will see the promise. The JS engine pushes the outputFunc() function to the microtask queue.

Then, it will execute other lines of code, and finally at the end of the program, it will print End.

After the main thread ends execution, the event loop will first check the microtask queue and then call back the queue. In our case, it takes the callbackFunc() function from the microtask queue and pushes it into the call stack. Then, it will pick the outputFunc() function from the callback queue and pushes it into the call stack.

Figure 1.21: Example of Event loop in action

Callback functions

JavaScript is synchronous by default, which means code will be executed in a sequential fashion. For example, the following code will be executed line by line and the final output will be logged to the console:

const a = 1;

const b = 2;

const c = a * b;

console.log(c);

doSomething();

As per the official definition from the Node.js website https://nodejs.dev/en/learn/javascript-asynchronous-programming-and-callbacks

A callback is a simple function that’s passed as a value to another function and will only be executed when the event happens. We can do this because JavaScript has first-class functions, which can be assigned to variables and passed around to other functions (called higher-order functions)

setTimeout(() => {

// runs after 2 seconds

}, 2000);

Above the setTimeout function, there is a classic example that accepts the first argument as a callback function, and the second parameter is time in milliseconds after which the callback function will be executed.

Callback functions are a great way of handling asynchronous function calls, but with every callback, it adds a level of nesting and results in callback hell when there are lots of callbacks happening within the same code:

window.addEventListener(‘load’, () => {

document.getElementById(‘button’).addEventListener(‘click’, () => {

setTimeout(() => {

fetch(http://example.com/).then(function cbF() {

items.forEach(item => {

// more code

});

});

}, 2000);

});

});

This example shows so many callback functions are invoked within 10 lines of code; it becomes very messy to handle this kind of situation of callback hell.

Defining Callback Hell in Node.js

Callback functions are used for the lazy execution of a function until another function has executed and returned data. However, in some cases, we may need to nest multiple callbacks within callbacks. This nested nature of callbacks can stretch horizontally and become unreadable and confusing if you have many interdependent consecutive asynchronous requests. This nesting of callbacks within callbacks is called callback hell and is sometimes also referred to pyramid of doom.

In the following code, we have called multiple setTimout(), which accept a callback function. In this case, every time a setTimeout callback function is executed, it triggers a new setTimeout() function in return:

function callbackhellexample() {

// first setTimeout function

setTimeout(() => {

console.log(10)

// second setTimeout function

setTimeout(() => {

console.log(20)

// third setTimeout function

setTimeout(() => {

console.log(30)

}, 500)

}, 2000)

}, 1000)

};

Once the innermost setTimeout function completes execution, then only the callback function returns execution to the outside upper callback function.

Ways to Avoid Callback hell

The following are some of the ways to avoid callback hell issues in Node.js:

Promise

A Promise is a JavaScript object that represents the eventual success or failure of an asynchronous operation and its final output. In other words, a Promise is an object to which you attach callback functions instead of passing directly into a function.

Following is an example of how we can create a promise, and based on the operation status, either resolve is called if successful, or reject in case of failure:

var displayGreeting = (name) => alert(‘Welcome ‘ + name);

var processUserInput = () => {

return new Promise((resolve, reject) => {

var name = prompt(please enter name);

if (name) {

resolve(name)

}

reject(false);

});

}

processUserInput().then(res => displayGreeting(res));

A promise is a proxy for a value that isn’t necessarily known at the time the promise is