Backend Development
With Node.JS
Instructor – Satya Priya Arya
UNIT 1
Introduction to Node.js
Frontend v/s Backend v/s Database
The front end is the part of the website users
can see and interact with such as the
graphical user interface (GUI) and the
command line including the design,
navigating menus, texts, images, videos, etc.
Examples – HTML, CSS, Java-Script, jQuery,
React
The backend, on the contrary, is the part of
the website users cannot see and interact
with.
Example – C, C++, Java, Node.JS, C#
The database used to store permanent
What is Node.JS
Node.js is an open source server environment
Node.js runs on various platforms (Windows,
Linux, Unix, Mac OS X, etc.)
Node.js uses JavaScript on the server
History of Node.js
Before 2009, web browsers used JavaScript.
JS was invented in the 1990 as a scripting
language for adding dynamic features to a
web page from an HTML file.
On the other hand, Ryan Dahl created a
runtime environment for JavaScript to
operate outside of web browsers in 2009.
npm, a package manager for the Node.js
environment, was released in January 2010.
Current version is 19.4.0 (LTS version is
18.13.0)
Why Node.js – part 1/2
Typical backend application works
Receive Request
Process Request
Send Response
Wait for next request
How Node.JS work
Receive Request
Ready to handle next request
Send response when previous request
completed
Why Node.js – part 2/2
Node.js eliminates the waiting, and simply
continues with the next request.
Node.js is
single-threaded,
non-blocking,
asynchronous programming
Node.js Architecture – part 1/3
Requests: Depending on the actions that a user needs to perform,
the requests to the server can be either blocking (complex) or non-
blocking (simple).
Node.js Server: The Node.js server accepts user requests,
processes them, and returns results to the users.
Event Queue: The main use of Event Queue is to store the incoming
client requests and pass them sequentially to the Event Loop.
Thread Pool: The Thread pool in a Node.js server contains the
threads that are available for performing operations required to
process requests.
Event Loop: Event Loop receives requests from the Event Queue
and sends out the responses to the clients.
External Resources: In order to handle blocking client requests,
external resources are used. They can be of any type ( computation,
storage, etc).
Node.js Architecture – part 2/3
Node.js Architecture – part 3/3
Users send requests (blocking or non-blocking) to the server
for performing operations.
The requests enter the Event Queue first at the server-side.
The Event queue passes the requests sequentially to the event
loop. The event loop checks the nature of the request
(blocking or non-blocking).
Event Loop processes the non-blocking requests which do not
require external resources and returns the responses to the
corresponding clients
For blocking requests, a single thread is assigned to the
process for completing the task by using external resources.
After the completion of the operation, the request is
redirected to the Event Loop which delivers the response back
to the client.
Working and Features
Installation and Setup
Install Node.JS from
https://nodejs.org/
Install Visual Studio Code from
https://code.visualstudio.com/download
REPL Environment
REPL is a computer environment like a Windows
console or Unix/Linux shell where a command is
entered and the system responds with an output
in an interactive mode. Node.js or Node comes
bundled with a REPL environment
Read − Reads user's input, parses the input into
JavaScript data-structure, and stores in memory.
Eval − Takes and evaluates the data structure.
Print − Prints the result.
Loop − Loops the above command until the user
presses ctrl-c twice.
REPL Environment Samples
$ node
>1+2
3
$ node
> console.log("Hello World")
Hello World
$ node
> var x = 0
undefined
> do {
... x++;
... console.log("x: " + x);
... }
while ( x < 5 );
x: 1
x: 2
x: 3
x: 4
x: 5 undefined
>
REPL Commands
ctrl + c − terminate the current command.
ctrl + c twice − terminate the Node REPL.
ctrl + d − terminate the Node REPL.
Up/Down Keys − see command history and modify
previous commands.
tab Keys − list of current commands.
.help − list of all commands.
.break − exit from multiline expression.
.clear − exit from multiline expression.
.save filename − save the current Node REPL session to a
file.
.load filename − load file content in current Node REPL
session.
Components of Node.js
Node contains many components to develop,
test and deploy applications. Main
components are
Node CLI
NPM
Package.json
Modules
Third party modules (example mongodb)
Core modules (example update)
Development tools and framework
UNIT 2
Node.js Modules
Modules
Modules is same as libraries.
functionality you want to include in your
application.
Module in Node.js is a simple or complex
functionality organized in single or multiple
JavaScript files which can be reused
throughout the Node.js application
Few build-in modules are fs, http, net, os,
path, querystring, stream, url, util
We can create our own modules too.
First Program
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.end('Hello World!');
}).listen(8080);
Save file as hello.js
Run “node hello.js” from terminal
Open browser and open http://localhost:8080/
Modify res.end('Hello World!'); to res.write(req.url)
and try with http://localhost:8080/Hello/
Module Exports
The module.exports in Node.js is used to
export any literal, function or object as a
module. It is used to include JavaScript file
into node.js applications.
module.exports = literal | function | object
Here the assigned value (literal | function |
object) is directly exposed as a module and
can be used directly.
module.exports.variable = literal | function |
object
Here the assigned value (literal | function |
object) is indirectly exposed as a module and
Exports Literals
module.exports = “Hello world example";
save in app.js
const demo = require("./app");
console.log(demo);
save in index.js
Exports Objects
module.exports = {
name: ‘Learn node js',
website: 'https://nodejs.org'
}
const demo = require('./app');
console.log(demo.name);
console.log(demo.website);
Exports Functions
module.exports = function (a, b) {
console.log(a + b);
}
const sum = require('./app');
sum(2, 5);
Exports Functions as Class
module.exports = function () {
this.name = ‘Hello Demo';
this.website = 'https://nodjs.org';
this.info = () => {
console.log(`Company name - ${this.name}`);
console.log(`Website - ${this.website}`);
}
}
const Company = require('./app');
const firstCompany = new Company();
firstCompany.info();
Exports Multiple Functions
Store many related functions in one js file
function add(x, y) { return x + y; }
function subtract…
function mutliply …
function divide…
…
Module.exports = { add, subtract, multiply, … }
Use whichever is required
const f = require('./func');
const result = f.add(10, 5);
Loading Module from separate folder
Navigate to parent or child folder and locate
location of module.
Examples:
const index =
require('./models/folder/path/index.js');
const module =
require('../../controllers/index.js');
File System Module
File System module allows you to work with
the file system on your computer.
var fs = require('fs');
Common use for the File System module:
Create
Read
Update
Rename
Delete
Synchronous v/s Asynchronous
Synchronous also called blocking functions
It waits for operation to complete, and only
after that, it executes the next operation
Asynchronous also called non-blocking
functions
It never waits for each operation to complete,
rather it executes all operations in the first go
itself
Most asynchronous methods has
corresponding synchronous method and
suffixed as “Sync”
Read
var fs = require("fs");
// Asynchronous read
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
Observe err if file doesn’t exist
Create, Update, Append
//If the file does not exist, the file will be created
fs.appendFile('mynewfile1.txt', 'Hello content!', function (err) {
if (err) throw err;
console.log('Saved!');
});
//If the file does not exist, an empty file is created
fs.open('mynewfile2.txt', 'w', function (err, file) {
if (err) throw err;
console.log('Saved!');
});
//If the file does not exist, a new file, with text, will be created
fs.writeFile('mynewfile3.txt', 'Hello content!', function (err) {
if (err) throw err;
console.log('Saved!');
});
Other useful operations
exists()
existsSync()
truncate()
renameSync()
unlink()
Events and Event Emitters
Node.js is perfect for event-driven applications.
Every action on a computer is an event. Like when a connection
is made or a file is opened.
Node.JS provides way to create and handle custom events.
The EventEmitter class can be used to create and handle
custom events module.
2 steps:
Listening events: Before emits any event, it must register
functions(callbacks) to listen to the events.
Removing Listener: The eventEmitter.removeListener() takes
two argument event and listener, and removes that listener from
the listeners array that is subscribed to that event.
While eventEmitter.removeAllListeners() removes all the
listener from the array which are subscribed to the mentioned
event.
Handling Events
Emitting events example
// Importing events
var EventEmitter = require('events');
// Initializing event emitter instances
var eventEmitter = new EventEmitter();
// Registering to myEvent
eventEmitter.on('myEvent', (msg) => {
console.log(msg);
});
// Triggering myEvent
eventEmitter.emit('myEvent', "First event");
Handling Events
// Initializing event emitter instances
var eventEmitter = new EventEmitter();
var geek1= (msg) => {
console.log("Message from geek1: " + msg);
};
var geek2 = (msg) => {
console.log("Message from geek2: " + msg);
};
// Registering geek1 and geek2
eventEmitter.on('myEvent', geek1);
eventEmitter.on('myEvent', geek2);
// Removing listener geek1 that was
// registered on the line 13
eventEmitter.removeListener('myEvent', geek1);
// Triggering myEvent
eventEmitter.emit('myEvent', "Event occurred");
// Removing all the listeners to myEvent
eventEmitter.removeAllListeners('myEvent');
// Triggering myEvent
eventEmitter.emit('myEvent', "Event occurred");
In-built modules Operating System
The os module provides information about the computer operating system on which node
running.
var os = require('os');
// return the cpu architecture
console.log("CPU architecture: " + os.arch());
// It returns the amount of free system memory in bytes
console.log("Free memory: " + os.freemem());
// It return total amount of system memory in bytes
console.log("Total memory: " + os.totalmem());
// It returns the list of network interfaces
console.log('List of network Interfaces: ' + os.networkInterfaces());
// It returns the operating systems default directory for temp files.
console.log('OS default directory for temp files : ' + os.tmpdir ());
os module common methods
arch()Returns the operating system CPU architecture
cpus()Returns an array containing information about the computer's
CPUs
freemem()Returns the number of free memory of the system
hostname()Returns the hostname of the operating system
loadavg()Returns an array containing the load averages, (1, 5, and
15 minutes)
platform()Returns information about the operating system's
platform
tmpdir()Returns the operating system's default directory for
temporary files
totalmem()Returns the number of total memory of the system
type()Returns the name of the operating system
uptime()Returns the uptime of the operating system, in seconds
userInfo()Returns information about the current user
