NODE.

JS

Node.js
TABLE OF CONTENTS

Preface 1
Introduction 1
Advantages and Disadvantages of Node.js . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Installing Node.js 1
Node.js Architecture 2
Node.js Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
The Event Loop 3
Common APIs 4
The Node Package Manager (NPM) 6
Node.js "Hello Word" Example 7
Pyramid Of Doom 8
Popular Modules And Frameworks 10
Resources 11

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 1 NODE.JS

PREFACE
PREFACE Advantages Disadvantages

This Node.js Cheatsheet has been meticulously Non-Blocking I/O: Limited

crafted to serve as a quick reference guide for Node.js uses an event- Multithreading:
Node.js developers of all levels. It provides a driven, non-blocking I/O Although Node.js can
concise and organized collection of essential model, allowing for use worker threads, it
information, tips, and best practices to help you efficient handling of a lacks native support for
navigate the Node.js ecosystem with confidence and large number of true multithreading,
efficiency. concurrent connections. which is a limitation for
certain applications.
INTRODUCTION
INTRODUCTION Vast Ecosystem: Node.js Learning Curve:
has a rich ecosystem of Developers new to
Node.js is an open-source, server-side runtime modules and packages asynchronous
environment that allows developers to build available through NPM, programming may face
scalable, high-performance web applications using making it easy to find a learning curve when
JavaScript. It is designed to be lightweight, efficient, and reuse code. working with Node.js.
and ideal for building real-time, data-intensive
Cross-Platform: Node.js Debugging Challenges:
applications. Node.js is based on the V8 JavaScript
runs on various Debugging
engine and is known for its event-driven, non-
platforms, including asynchronous code can
blocking I/O model, making it a popular choice for
Windows, macOS, and be more challenging
building network applications and APIs.
Linux, providing a compared to
consistent development synchronous code.
Node.js has gained widespread popularity in web
environment.
development due to its versatility and the ability to
use a single language, JavaScript, on both the client Real-Time Capabilities: Callback Hell:
and server sides. It has a vast ecosystem of modules Node.js is excellent for Managing asynchronous
and packages available through NPM (Node building real-time code using callbacks can
Package Manager), enabling developers to applications like chat lead to complex and
streamline their development process. apps and online gaming, hard-to-maintain code
thanks to its low-latency structures, commonly
and event-driven referred to as "callback
ADVANTAGES AND DISADVANTAGES OF
architecture. hell."
NODE.JS
Community and
These advantages and disadvantages can help you Support: Node.js has a
understand when Node.js is an appropriate choice large and active
for your project and when it might have limitations. community, offering
Remember that the suitability of Node.js depends extensive
on the specific requirements of your application documentation,
and your team’s familiarity with asynchronous tutorials, and support.
JavaScript programming.
Scalability: Node.js
applications can be
Advantages Disadvantages
easily scaled
High Performance: Single-Threaded: While horizontally by adding
Node.js is built on the V8 Node.js’s event loop is more server instances
JavaScript engine, which efficient, it’s still single- due to their lightweight
compiles JavaScript into threaded, which can nature.
native machine code, lead to performance
resulting in exceptional bottlenecks for CPU-
INSTALLINGNODE.JS
INSTALLING NODE.JS
performance. bound tasks.

To download and install Node.js on your computer,

follow these steps:

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 2 NODE.JS

1. Visit the Node.js website install a code editor or integrated development

environment (IDE). Popular choices include Visual
Go to the official Node.js website at Studio Code, Sublime Text, and WebStorm.
https://nodejs.org.
NODE.JSARCHITECTURE
NODE.JS ARCHITECTURE
2. Choose the Node.js version

Node.js has a unique architecture that sets it apart

You’ll find two versions of Node.js on the website:
from traditional server-side technologies.
LTS (Long-Term Support) and Current. For most
Understanding its event-driven, non-blocking
production and development purposes, it’s
nature empowers developers to create responsive,
recommended to choose the LTS version as it’s
real-time applications and manage I/O-bound
more stable and receives long-term support. Click
operations effectively.
on the "LTS" tab to see the LTS version.

The main difference between synchronous and

3. Download the installer
asynchronous programming lies in how they
handle tasks and operations that may take time to
Click on the appropriate installer for your operating
complete. Synchronous programming executes
system. Node.js supports various operating systems,
tasks one after another, in a blocking manner,
including Windows, macOS, and Linux. Choose the
while asynchronous programming enables
installer that matches your system. For example, on
concurrent execution and continues working on
Windows, you can choose the ".msi" installer, while
other tasks without waiting for operations to
on macOS, you’ll want the ".pkg" installer.
complete. Asynchronous programming is especially
4. Run the installer beneficial for I/O-bound operations and situations
where responsiveness and resource utilization are
After downloading the installer, run it by double- essential, but it can be more challenging to write
clicking on the downloaded file. This will launch and reason about due to its event-driven nature.
the Node.js installer.
The key components of Node.js architecture
5. Install Node.js include:

Follow the on-screen instructions in the installer to • V8 Engine: At the core of Node.js is the V8
install Node.js on your system. You can typically JavaScript engine, developed by Google. V8 is
accept the default settings, but you may customize known for its high-performance JavaScript
the installation directory if needed. execution and just-in-time (JIT) compilation of
JavaScript code into native machine code. This
6. Verify the installation enables Node.js to execute JavaScript with
remarkable speed.
After the installation is complete, open a terminal
• Libuv: Libuv is a C library that Node.js uses to
or command prompt, and type the following
abstract and handle I/O operations and provide
commands to verify that Node.js and NPM (Node
an event loop. It enables Node.js to work across
Package Manager) are correctly installed:
various operating systems, managing tasks like
file system operations and network
node -v communication in an efficient, non-blocking
manner.
npm -v
• Event Loop: The event loop is the central part
of Node.js, responsible for managing
These commands should display the versions of
asynchronous operations. It allows Node.js to
Node.js and NPM, confirming that the installation
handle I/O operations, such as file reading,
was successful.
network requests, and database queries,
without blocking the entire process. Node.js is
7. Optional: Install a code editor (IDE)
single-threaded, but the event loop’s non-
blocking I/O operations make it highly efficient
To start developing with Node.js, you may want to

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 3 NODE.JS

for handling a large number of concurrent serves as a set of built-in libraries that extend the
connections. capabilities of JavaScript beyond what’s available in
a browser environment.
• Callback Queue: Callbacks are functions that
are executed once an asynchronous operation
Finally, the application layer is where Node.js
is completed. Node.js relies on a callback
developers write their JavaScript code to create
mechanism to handle asynchronous code.
server-side applications and services. This layer
When an asynchronous task finishes, its
includes the user’s custom JavaScript code, which
callback is placed in the callback queue, and
utilizes the Node.js API and any additional third-
the event loop processes these callbacks in a
party modules installed via NPM. Developers build
first-in, first-out (FIFO) order.
web servers, APIs, real-time applications, and
various other server-side applications in this layer.
NODE.JS STACK They also handle business logic and application-
specific functionality.
The Node.js stack consists of several layers, starting
with the V8 engine, linuv and other native support
THEEVENT
THE EVENTLOOP
LOOP
libraries at the core.

Node.js is single-threaded, which means it runs on a

single main thread of execution. This single thread
is responsible for executing JavaScript code and
handling I/O operations. Nevertheless, it is also non-
blocking, meaning it doesn’t wait for I/O operations
(like file reading, network requests) to complete.
Instead, it initiates the operation and continues
executing other code while it waits for the I/O to
complete. In other words, Node.js is event-driven,
meaning it relies on events and callbacks to handle
asynchronous operations. It uses event emitters
and listeners to manage events and responses.

The event loop is a loop that continually checks if

there are any pending events, such as I/O
operations or timer expirations. When an event is
detected, the associated callback function is added
to a callback queue for execution. The callback
queue holds all the callback functions that are
Figure 1. Node.js Stack waiting to be executed. Callbacks are processed in
the order they were added to the callback queue
The Node.js binding layer acts as a bridge between (FIFO).
JavaScript and C/C++ code. It allows Node.js to
The event loop follows a repeating cycle. Each
incorporate native code modules, such as those
phase in the cycle has its own callback queue and
used to interact with hardware or low-level system
only when the callback queue has been exhausted
functions. This layer is responsible for managing
(or the callback limit is reached), the event loop
and exposing native functionality to JavaScript,
moves to the next phase:
making it accessible in Node.js applications.

• Timers: Check the event queue for timer

On top of the binding layer resides the Node.js API
expiration events and executes any related
layer which provides a wide range of JavaScript
callbacks (e.g. registered using the setTimeout()
modules and functions that allow developers to
or setInterval() functions).
work with the file system, network, cryptography,
streams, and more. These modules simplify • Pending Callbacks: Executes I/O-related
common tasks and make them accessible through callbacks e.g., regarding file read or network
JavaScript code. The Node.js API layer essentially request events, deferred to the next loop

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 4 NODE.JS

iteration. included with Node.js can be found in the Node.js

API documentation.
• Idle, Prepare: Internal mechanisms for
managing the event loop.
Node.js Api Description
• Poll: Check the event queue for new I/O events
fs (File System) Provides functions for
(blocks if necessary); execute I/O related
working with the file
callbacks (almost all with the exception of close
system, allowing you to
callbacks, the ones scheduled by timers, and
read, write, delete, and
setImmediate()).
manipulate files and
• Check: Execute any callbacks registered via directories.
setImmediate().
http, https, http2 Enables you to create
• Close Callbacks: Execute any 'close' event HTTP servers and
callbacks, such as on('close') for server clients, making it
connections. possible to build web
servers and interact
Prior moving to a next phase, all callback functions with HTTP resources.
registered using process.nextTick() are executed. Similar to the http
This is the case for moving to the first phase also. module https is used for
The queue that maintains this type of callbacks is HTTPS (secure)
also known as the microtasks queue. Since they are connections. http2
the first to get executed, microtasks have a higher extends the capabilities
priority than other asynchronous operations, such of the http and https
as timer and I/O related callbacks. modules to support
process.nextTick() is used when you want to HTTP/2, a modern
ensure that a callback is executed at the completion version of the HTTP
of the current callback, before other asynchronous protocol that enhances
tasks, making it useful for scenarios like setting up performance.
event listeners before emitting events.
os (Operating System) Provides information
Between each run of the event loop, Node.js checks about the operating
if it is waiting for any asynchronous I/O or timers system on which the
and shuts down cleanly if there are not any. Node.js application is
running, such as CPU
Node.js’s event-driven, non-blocking architecture architecture and system
makes it suitable for handling many concurrent memory.
connections efficiently. Multiple requests can be path Offers utilities for
processed without the need for creating a new
working with file and
thread for each request, reducing the overhead
directory paths in a
associated with thread management.
cross-platform manner,
helping to resolve and
COMMONAPIS
COMMON APIS manipulate file paths.
events Allows you to work with
Node.js provides a diverse set of built-in APIs that
event emitters and
empower developers to perform a wide range of
listeners, facilitating
tasks, from working with the file system to creating
event-driven
web servers and handling cryptographic
programming and event
operations. This table provides a quick reference
handling within your
for some of the most commonly used Node.js APIs,
application.
along with concise descriptions of their purposes
and functionalities. These APIs form the foundation
for building feature-rich, high-performance server-
side applications in Node.js. A complete list of APIs

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 5 NODE.JS

Node.js Api Description Node.js Api Description

util Provides various utility zlib Provides compression
functions for debugging, and decompression
formatting, and functionality using the
inspecting objects, as zlib library, allowing
well as other you to work with
miscellaneous utilities. compressed data
child_process streams.
Enables the creation of
child processes to readline Offers a simple way to
execute external create interactive
commands and scripts, command-line
making it possible to interfaces (CLIs) by
run additional programs providing methods for
alongside your Node.js reading input and
application. writing output to the
crypto console.
Offers cryptographic
functionality for secure cluster Allows you to create
data hashing, child processes and
encryption, and manage them efficiently
decryption, as well as to utilize multiple CPU
support for SSL and TLS cores for improved
protocols. performance in a
net Node.js application.
Allows you to create
network servers and stream Provides a framework
clients for building for working with
custom network streams of data,
protocols and handling enabling efficient data
TCP/UDP processing and
communication. transmission, such as
reading/writing large
dns (Domain Name Provides DNS resolution
files or network
System) and DNS server
communication.
functionality, enabling
the translation of buffer Represents a fixed-size
domain names to IP memory allocation used
addresses and vice for working with binary
versa. data directly, which is
url especially important for
Offers utilities for URL
file I/O and network
parsing and formatting,
communication.
making it easier to work
with URLs, both for process Offers information and
HTTP requests and other control over the Node.js
purposes. process, including
querystring environment variables,
Facilitates the parsing
command-line
and formatting of URL
arguments, standard I/O,
query strings, allowing
and process events.
for the manipulation of
query parameters in
URLs.

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 6 NODE.JS

Node.js Api Description contains metadata about the project, including

its name, version, dependencies, and scripts.
debugger Provides a debugging The package.json file helps NPM understand the
API and tools for project’s requirements and facilitates version
debugging Node.js management.
applications. It allows
you to inspect and • Dependencies: Dependencies are packages
debug your code during that a Node.js project relies on to function
development. correctly. These dependencies are listed in the
project’s package.json file. When you run npm
modules Node.js uses the install, NPM reads the package.json and
CommonJS module downloads the specified dependencies from the
system, allowing you to registry. Managing dependencies ensures that
create, load, and your application can be easily replicated on
manage modules for different systems.
better code organization
and reusability. To create a new NPM package based on existing
files in your project directory, just navigate inside
THENODE
THE NODEPACKAGE
PACKAGEMANAGER
MANAGER that directory and type the following command: npm
init
(NPM)
(NPM)
Running this command will prompt you to answer
The Node Package Manager (NPM) is a package a series of questions to create a package.json file for
manager for JavaScript and Node.js. It is the default your project. You can press Enter to accept the
package manager that comes bundled with Node.js. default values or provide your own answers. After
NPM plays a central role in managing and completing the initialization, NPM will generate a
distributing open-source JavaScript packages and package.json file in your project directory. Here’s an
libraries. Here’s a brief description of its main example of what the package.json file might look
components: like using default values (<package-name> is
replaced with the project’s directory name):
• Packages: Packages are reusable JavaScript
modules or libraries. A package typically
includes JavaScript files, documentation, and {
metadata. These packages can be installed in "name": "<package-name>",
Node.js applications, allowing developers to "version": "1.0.0",
leverage existing code to build applications
"description": "",
more efficiently.
"main": "index.js",
• Registry: The NPM registry is a massive online "scripts": {
collection of public JavaScript packages. It is "test": "echo \"Error: no test
the central repository where package authors specified\" && exit 1"
publish their code for others to use. The
},
registry hosts a wide variety of items, ranging
"keywords": [],
from small utility libraries to entire web
"author": "",
frameworks.
"license": "ISC"
• CLI (Command-Line Interface): The NPM CLI }
is a command-line tool that you can use to
interact with the registry and manage
packages. It provides commands for installing, To add a new dependency to your Node.js project,
updating, publishing, and managing you can use the npm install command followed by
dependencies. the name of the package you want to install. For
this example, let’s say you want to add the lodash
• package.json File: Every Node.js project
package as a dependency. You can install it using
typically includes a package.json file, which
the following command while in your project’s top
serves as a manifest for the project. This file

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 7 NODE.JS

folder: npm install lodash as listed in package.json.

Under the hood, the npm install command By defining and running scripts in your
downloads the designated package from the package.json file, you can easily automate common
registry and installs it, along with all of its tasks, making it convenient to start, test, and
dependencies, to the node_modules/ directory inside manage your Node.js applications.
your project folder; it then updates your project’s
package.json file to include the newly added NODE.JS"HELLO
NODE.JS "HELLOWORD"
WORD"EXAMPLE
EXAMPLE
dependency. Open the package.json file, and you
should see an updated "dependencies" section that To run JavaScript files in Node.js, you can use the
lists the lodash package and its version. The latest node command followed by the name of the file
version available at the time of installation is containing the code to be executed.
selected.
For a "hello world" application, that simply outputs
a "hello world" message to the console, let’s create a
... JavaScript file, name it myapp.js (you are free to
"dependencies": { choose whatever name you like of course) and add
"lodash": "^4.17.21" the following code in it:
}
...
console.log("Hello, Node.js!");

NPM also allows you to define and execute scripts

in your Node.js project. These scripts are defined as Execute the file by using the command node
key-value pairs in the scripts section of your myapp.js. Node.js will interpret the JavaScript code
package.json file. The key is the script name, and and execute it in the Node.js runtime environment.
the value is the command to execute when the You should see the Hello, Node.js! output in your
script is run. For example, let’s create a new custom terminal.
script called "start" that will run our Node.js
You can run any JavaScript file this way, whether
application by executing the command node app.js
it’s a simple script like the one in this example or a
(assuming our application is contained in app.js):
more complex Node.js application. For example, a
simple HTTP server can be created using the
... following code:

"scripts": {
"test": "echo \"Error: no test // Import the 'http' module, which
specified\" && exit 1", is a built-in module for creating
"start": "node app.js" HTTP servers.
} const http = require('http');
...
// Define the hostname and port for
To run the script, use the npm run command the server to listen on.
followed by the script name like this: npm run start const hostname = '127.0.0.1'; //
Loopback address for the local
NPM also provides a few built-in scripts that you machine
can use without defining them in the "scripts"
const port = 3000; // Port number
section. Some common built-in scripts include:

• npm start: Runs the "start" script if defined.

// Create an HTTP server using the
'createServer' method of the 'http'
• npm test: Runs the "test" script if defined.
module.
• npm install: Installs the project’s dependencies const server = http.createServer

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 8 NODE.JS

((req, res) => {

// Set the response's HTTP status fs.readFile('file1.txt', 'utf8',
code and content type. (err, data1) => {
res.statusCode = 200; if (err) {
res.setHeader('Content-Type', console.error(err);
'text/plain'); } else {
fs.readFile('file2.txt', 'utf8',
// Write a response message. (err, data2) => {
res.end('Hello, Node.js HTTP if (err) {
Server!\n'); console.error(err);
}); } else {
fs.readFile('file3.txt',
// Start the server and make it 'utf8', (err, data3) => {
listen for incoming HTTP requests. if (err) {
server.listen(port, hostname); console.error(err);
} else {
// Output message that the server // Do something with
has started data1, data2, and data3
console.log(`Server running at }
https://${hostname}:${port}/`); });
}
});
Although Node.js is single-threaded, listening on the }
specified port will not block execution. Instead, a
});
callback is registered that executes the handler
logic defined in the createServer function, when an
HTTP request is received. Once the callback is To mitigate the pyramid of doom and improve code
registered, the phrase Server running at readability, several approaches have been adopted
https://127.0.0.1:3000/ is outputted. in JavaScript and Node.js:

Note that this application requires the http package Promises: Promise objects provide a way to handle
which allows us to create an HTTP server and asynchronous operations in a more linear and
handle incoming HTTP requests. You can install the readable fashion. They allow you to chain .then()
http package by running npm install http while in and .catch() calls, avoiding deeply nested
the top folder of your project. callbacks.

PYRAMIDOF
PYRAMID OFDOOM
DOOM
const fs = require('fs').promises;
The "pyramid of doom" is a term used to describe a // Using Promises for file
situation where multiple levels of nested callbacks operations
result in code that has a deeply nested and indented
structure. This nested structure can make your fs.readFile('file1.txt', 'utf8')
program hard to read, understand, and maintain, .then(data1 => fs.readFile(
resembling a pyramid-like shape. 'file2.txt', 'utf8'))
.then(data2 => fs.readFile(
The "pyramid of doom" typically occurs in scenarios
'file3.txt', 'utf8'))
like handling I/O operations, making network
requests, or dealing with event-driven
.then(data3 => {
programming in general. Here’s an example of the // Do something with data1,
"pyramid of doom" scenario using three nested data2, and data3
callbacks: })
.catch(err => {

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 9 NODE.JS

console.error(err); asynchronous function. Asynchronous functions

}); remove much of the boilerplate code required for
the resolution of Promises and Promise chains within
the function body. Also the await keyword is
Here the fs.readFile() function returns a Promise permitted, which can be used to "wait" for a Promise
object. Promise objects support two properties, the to be resolved and return its resolved value. So, in
state and result of the asynchronous execution of our example, the three assignments of data1, data2
the function that spawned them. A Promise can and data3, happen sequentially and only after each
either be in the pending, fulfilled or rejected state. respective Promise has been resolved.
In the fulfilled state the corresponding function has
executed successfully and the Promise result has the It is important to note that using await does not
returned value, whereas in the rejected state actually block the executing thread. Using async
Promise result is the error raised after a failed /await just abstracts the underlaying use of Promises
function execution. To handle the result (either to allow us to write asynchronous code in a more
value or error) both Promise.then() and/or synchronous manner.
Promise.catch() can be used. Promise.then() takes
two arguments, a callback for success and an Control Flow Libraries: Libraries like async.js
optional callback for failure. Promise.then() also offer utilities for controlling the flow of
returns a Promise object regarding the asynchronous operations using functions like
asynchronous execution of either its success or async.waterfall and async.series.
failure callback, to enable chaining.

Async/Await: async/await is a modern JavaScript const async = require('async');

feature that simplifies asynchronous code by const fs = require('fs');
allowing you to write it in a more synchronous,
structured way. It’s built on top of Promises. async.waterfall([
function(callback) {
fs.readFile('file1.txt', 'utf8',
const fs = require('fs').promises;
callback);
// Using Promises for file
},
operations
function(data1, callback) {
fs.readFile('file2.txt', 'utf8',
async function readFiles() {
(err, data2) => callback(err, data1,
try {
data2));
const data1 = await fs.readFile
},
('file1.txt', 'utf8');
function(data1, data2, callback) {
const data2 = await fs.readFile
fs.readFile('file3.txt', 'utf8',
('file2.txt', 'utf8');
(err, data3) => callback(err, data1,
const data3 = await fs.readFile
data2, data3));
('file3.txt', 'utf8');
}
], (err, data1, data2, data3) => {
// Do something with data1,
if (err) {
data2, and data3
console.error(err);
} catch (err) {
} else {
console.error(err);
// Do something with data1,
}
data2, and data3
}
}
});
readFiles();

Event Emitters: In event-driven scenarios, you can

Here the async keyword is used to create an

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 10 NODE.JS

use Node.js’s event emitter pattern to handle asynchronous code, making it more readable and
asynchronous events more elegantly. maintainable, while avoiding the pyramid of doom.
The choice of which approach to use depends on
the specific requirements of your project and your
const fs = require('fs'); personal coding style.
const EventEmitter = require('
events'); POPULARMODULES
POPULAR MODULESAND
AND
FRAMEWORKS
FRAMEWORKS
const emitter = new EventEmitter();
The Node.js ecosystem thrives on the contributions
emitter.on('data1', () => { of third-party developers, resulting in a vast
fs.readFile('file1.txt', 'utf8', collection of modules and frameworks that extend
(err, data1) => { the capabilities of Node.js for various purposes. In
if (err) { this table, we provide a quick overview of some of
the most popular third-party modules and
console.error(err);
frameworks, along with brief descriptions of their
} else {
key features and use cases. These tools empower
emitter.emit('data2', data1);
Node.js developers to streamline development,
} implement real-time features, simplify
}); authentication, and much more. Explore this table
}); to discover the wealth of resources available to
enhance your Node.js projects.
emitter.on('data2', (data1) => {
fs.readFile('file2.txt', 'utf8', Module/framework Description
(err, data2) => { Express Express.js is a widely
if (err) { used web application
console.error(err); framework for Node.js.
} else { It simplifies the process
emitter.emit('data3', data1, of building robust and
data2); scalable web
} applications with a rich
}); set of features and
middleware. Express is
});
known for its
minimalistic and
emitter.on('data3', (data1, data2)
flexible design.
=> {
fs.readFile('file3.txt', 'utf8', Passport Passport is an
authentication
(err, data3) => {
middleware for Node.js
if (err) {
applications. It supports
console.error(err);
various authentication
} else { strategies, such as
// Do something with data1, username and
data2, and data3 password, OAuth, and
} OpenID, making it easier
}); to implement user
}); authentication and
authorization in your
emitter.emit('data1'); web applications.

These approaches help to organize and simplify

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 11 NODE.JS

Module/framework Description Module/framework Description

Sequelize Sequelize is an Object- PM2 (Process Manager) PM2 is a production

Relational Mapping process manager for
(ORM) library for Node.js applications. It
Node.js that simplifies simplifies process
database interactions management, load
with relational balancing, and
databases like MySQL, monitoring for Node.js
PostgreSQL, and SQLite. apps. It can be used to
It provides a model- keep applications
based approach to running continuously,
database operations and manage clustering, and
supports migrations, provide production-
validations, and ready environment
associations. management for Node.js
apps.
NestJS NestJS is a progressive
and modular framework Axios Axios is a popular HTTP
for building efficient client library for making
and scalable server-side HTTP requests from
applications. It is built Node.js applications. It
with TypeScript and supports promises and
embraces the use of async/await, provides an
decorators and easy-to-use API for
dependency injection to sending HTTP requests,
create structured and and includes features
maintainable code. like request/response
NestJS is often used for interception and error
building APIs and handling. Axios is often
microservices. used for interfacing with
RESTful APIs and other
Jest Jest is a popular
HTTP services.
JavaScript testing
framework for Node.js
and the browser. It RESOURCES
RESOURCES
offers a comprehensive
and developer-friendly These resources cover a wide range of learning and
testing experience, with development needs for Node.js, whether you’re a
features like test beginner or an experienced developer looking to
runners, assertion stay current with the latest trends and best
libraries, mocking, and practices.
code coverage reporting.
Jest is often used for unit • Node.js Official Website: The official website
testing, integration provides downloads, documentation, and
testing, and end-to-end updates about Node.js.
testing of Node.js • Node.js Documentation: The official
applications. documentation is a comprehensive resource for
learning about Node.js, its core modules, and
best practices.

• npm Website: npm is the package manager for

Node.js, offering a vast repository of packages
and modules that you can use in your projects.
You can search for packages and manage

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!

 12 NODE.JS

dependencies using the npm command-line tool.

• GitHub Node.js Topic: GitHub hosts many open-

source Node.js projects. You can explore,
contribute to, and learn from Node.js
repositories on GitHub.

• nodeschool.io: NodeSchool offers interactive

workshops for learning Node.js and related
technologies.

• learnyounode: Learn You The Node.js For Much

Win! is a NodeSchool workshop for getting
hands-on experience with Node.js.

• Node.js Official Blog: The official Node.js blog

provides updates, announcements, and insights
into the Node.js ecosystem.

JCG delivers over 1 million pages each month to more than 700K software
developers, architects and decision makers. JCG offers something for everyone,
including news, tutorials, cheat sheets, research guides, feature articles, source code
and more.
CHEATSHEET FEEDBACK
WELCOME
[email protected]

Copyright © 2014 Exelixis Media P.C. All rights reserved. No part of this publication may be SPONSORSHIP
reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, OPPORTUNITIES
mechanical, photocopying, or otherwise, without prior written permission of the publisher. [email protected]

JAVACODEGEEKS.COM | © EXELIXIS MEDIA P.C. VISIT JAVACODEGEEKS.COM FOR MORE!