Node.

js
Node.js Introduction
Introduction
Hello and welcome to our backend track. In this track we are going to learn how to
create a backend server using Node.js, Express and MongoDB. These are the
technologies that we are going to use during this track.

Let’s start with Node.js. In this Super Skill, we are going to:

 Discover what Node.js is.

 Learn how to setup our environment and create our first application.
 Understand how to use the REPL terminal.
 Understand the node package module and the concept of modules in Node.js.
 Practice working with event loops, callback functions and file systems.

What is Node.js?
Node.js is a server-side platform built on Google Chrome's JavaScript
Engine (V8 Engine). Node.js was developed by Ryan Dahl in 2009. The
definition of Node.js as supplied by its official documentation is as follows:

Node.js is a platform built on Chrome's JavaScript runtime for easily

building fast and scalable network applications. Node.js uses an event-
driven, non-blocking I/O model that makes it lightweight and efficient,
perfect for data-intensive real-time applications that run across distributed
devices.

 Node.js is an open source, cross-platform runtime environment for

developing server-side and networking applications.
 Node.js applications are written in JavaScript, and can be run within
the Node.js runtime on OS X, Microsoft Windows, and Linux.
 Node.js also provides a rich library of various JavaScript modules
which simplifies the development of web applications using Node.js
to a great extent.

Node.js = Runtime Environment + JavaScript Library

Features of Node.js.
The Following are some of the important features that make Node.js the
software architects' first choice:

 Asynchronous and Event Driven − All APIs of Node.js library are

asynchronous, that means they are non-blocking. It essentially
means a Node.js based server never waits for an API to return data.
The server moves on to the next API after calling it and a notification
mechanism of Events of Node.js helps the server to get a response
from the previous API call.
 Very Fast − Being built on Google Chrome's V8 JavaScript Engine,
Node.js library is very fast in code execution.
 Single Threaded but Highly Scalable − Node.js uses a single
threaded model with event looping. Event mechanism helps the
server to respond in a non-blocking way and makes the server highly
scalable as opposed to traditional servers which create limited
threads to handle requests. Node.js uses a single threaded program
and the same program can provide service to a much larger number
of requests than traditional servers like Apache HTTP Server.
 No Buffering − Node.js applications never buffer any data. These
applications simply output the data in chunks.
 License − Node.js is released under the MIT license.
Who Uses Node.js?
It's now nearly impossible to find a complete list of projects, applications
and companies that do not use Node.js. Nowadays nearly everyone has
adopted it in one way or another. Nonetheless, here's a glimpse of some
Top Techs using Node.js.

Concepts
The following diagram depicts some important parts of Node.js which we
will discuss in detail in the subsequent chapters.

When to Use Node.js?

The following areas are the areas where Node.js is proving itself to be a
perfect technology partner.

 I/O bound Applications

 Data Streaming Applications
 Data Intensive Real-time Applications (DIRT)
 JSON API-based Applications
 Single-Page Applications

When Not to Use Node.js?

It is not advisable to use Node.js for CPU intensive applications.

Assessment: Quiz
What are the correct answers?

Node.js is a web framework (like Rails or Django, though it can be used to make
similar things). Node.js is a JavaScript runtime environment. A programming
language.
Who developed NodeJS?

Ryan Dahl Dan Abramov

What websites use or have used NodeJS?

Paypal Medium imgur Coursera

Why do we use NodeJS?
 It is useful for I/O based programs that need to be fast and/or handle lots of
connections It is a tool for writing Network programs using the protocols of the
web: HTTP, TCP, UDP, DNS and SSL Node.js combines the Google V8 JavaScript
engine, a single-threaded non-blocking event loop, and a low-level I/O API

Environment Setup
Local Environment Setup
To set up your environment for Node.js, you need the following two
softwares available on your computer (a) Text Editor and (b)
The Node.js binary installables.

Text Editor
This will be used to type your program. Examples of few editors include
Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi,
... or simply VSCode.

The name and version of the text editor can vary on different operating
systems. For example, Notepad will be used on Windows, and vim or vi
can be used on windows as well as Linux or UNIX.

The files you create with your editor are called source files and contain
program source code. The source files for Node.js programs are typically
named with the extension ".js".

Before starting your programming, make sure you have one text editor in
place and you have enough experience to write a computer program, save
it in a file, and finally execute it.

The Node.js Runtime

The source code written in a source file is simply JavaScript. The Node.js
interpreter will be used to interpret and execute your JavaScript code.

Node.js distribution comes as a binary installable for SunOS , Linux, Mac

OS X, and Windows operating systems with the 32-bit and 64-bit (amd64)
x86 processor architectures.

The following section will guide you on how to install Node.js binary
distribution on various OS.

Download Node.js
Download latest version LTS (Long Term Support) of Node.js installable
archive file from Node.js Downloads
Installation on UNIX/Linux/Mac OS X,
and SunOS
Based on your OS architecture, download and extract the archive node-
vx.x.x-osname.tar.gz into /tmp, and then finally move the extracted files
into /usr/local/nodejs directory. For example:
$ cd /tmp

$ wget http://nodejs.org/dist/v11.3.1/node-v11.3.1-linux-x64.tar.gz

$ tar xvfz node-v11.3.1-linux-x64.tar.gz

$ mkdir -p /usr/local/nodejs

$ mv node-v11.3.1-linux-x64/* /usr/local/nodejs

Add /usr/local/nodejs/bin to the PATH environment variable.

OS Output

Linux export
PATH=$PATH:/usr/local/nodejs/bin

Mac export
PATH=$PATH:/usr/local/nodejs/bin

FreeBS export
D PATH=$PATH:/usr/local/nodejs/bin

Installation on Windows
Use the MSI file and follow the prompts to install the Node.js. By default,
the installer uses the Node.js distribution in C:\Program Files\nodejs. The
installer should set the C:\Program Files\nodejs\bin directory in window's
PATH environment variable. Restart any open command prompts for the
change to take effect.

Verify installation
To verify that Node.js is installed in your machine just run the following
command:
node -v

Executing a File
Create a js file named main.js on your machine (Windows or Linux)
having the following code.
/* Hello, World! program in node.js */

console.log("Hello, World!")

Now execute main.js file using Node.js interpreter to see the result:
$ node main.js

If everything is fine with your installation, this should produce the following
result:
Hello, World!

Assessment: Quiz
How can I check if node is installed?

node -myversion node -v node --version

How to execute a .js file with node?

node -v <fileName> node <fileName>

The node program is created inside a .js file.

True False

First Application
First Application
Before creating an actual "Hello, World!" application using Node.js, let us
see the components of a Node.js application. A Node.js application
consists of the following three important components:

 Import required modules: We use the require directive to load

Node.js modules.
 Create server: A server which will listen to the client's requests
similar to Apache HTTP Server.
  Read request and return response: The server created in an
earlier step will read the HTTP request made by the client which can
be a browser or a console and then return the response.

Step 2 - Create Server

We use the created HTTP instance and call http.createServer() method to
create a server instance and then we bind it to port 8081 using
the listen method associated with the server instance. We pass it a
function with the parameters request and response.
Write the sample implementation to always return "Hello World".
http.createServer(function (request, response) {

// Send the HTTP header

// HTTP Status: 200 : OK

// Content Type: text/plain

response.writeHead(200, {'Content-Type': 'text/plain'});

// Send the response body as "Hello World"

response.end('Hello World\n');

}).listen(8081);

// Console will print the message

console.log('Server running at http://127.0.0.1:8081/');

The above code is enough to create an HTTP server which listens, i.e.,
waits for a request over 8081 port on the local machine.

Creating Node.js Application

Make a Request to the Node.js Server
Open http://127.0.0.1:8081/ in any browser and observe the following
result.
Assessment: Quiz
What are local modules?

Local modules are modules created locally in your Node.js application. Local
modules are part of Node.js modules.
To import a Node module, we use the keyword:

Import Require bring

HTTP modules need to be installed before use.

True False

REPL Terminal
Starting REPL
REPL stands for Read Eval Print Loop and it represents 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. It performs the
following tasks:

 Read − Reads user's input, parses the input into JavaScript data-
structure, and stores it into memory.
 Eval − Takes and evaluates the data structure.
 Print − Prints the result.
 Loop − Loops the above command until the user presses ctrl-
c twice.
The REPL feature of Node is very useful in experimenting with Node.js
codes and debugging JavaScript codes.

REPL can be started by simply running node on shell/console without any

arguments as follows.
$ node

You will see the REPL Command prompt > where you can type any Node.js
command.
$ node

>

Simple Expression
Let's try some simple mathematics with the Node.js REPL command
prompt:
$ node

> 1 + 3

> 1 + ( 2 * 3 ) - 4

>

Use Variables
You can use variables to store values and print them later like any
conventional script. If var keyword is not used, then the value is stored in
the variable and printed. Whereas if var keyword is used, then the value is
stored but not printed. You can print variables using console.log().
$ node

> x = 10

10

> var y = 10

undefined

> x + y
20

> console.log("Hello World")

Hello World

undefined

Multiline Expression
Node REPL supports multiline expression similar to JavaScript. Let's check
the following do-while loop in action.
$ 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

>

... comes automatically when you press Enter after the opening bracket.
Node automatically checks the continuity of expressions.

Underscore Variable
You can use underscore (_) to get the last result
$ node

> var x = 10
undefined

> var y = 20

undefined

> x + y

30

> var sum = _

undefined

> console.log(sum)

30

undefined

>

REPL Commands
 ctrl + c − terminates the current command.
 ctrl + c twice − terminates the Node REPL.
 ctrl + d − terminates the Node REPL.
 Up/Down Keys − see command history and modify previous
commands.
 tab Keys − list all of the current commands.
 .help − list all of the commands.
 .break − exits from multiline expression.
 .clear − exits from multiline expression.
 .save filename − saves the current Node REPL session to a file.
 .load filename − loads file content from current Node REPL
session.

Stopping REPL
As mentioned above, you will need to use ctrl-c twice to come out of
Node.js REPL.
$ node

>

(^C again to quit)

>
Fill in the blanks Solution
ctrl + c : terminates the current command. ctrl + d : terminates the Node REPL. tab
Keys : list all of the current commands. .break : exits from multiline expression. .save
filename : saves the current Node REPL session to a file. ctrl + c twice : terminates
the Node REPL. Up/Down Keys : see command history and modify previous
commands. .help : lists all of the commands. .clear : exits from multiline
expression. .load filename : loads file content from current Node REPL session.

Node Package Manager NPM

Installing Modules using NPM
Node Package Manager (NPM) provides two main functionalities:

 Online repositories for node.js packages/modules, which are

searchable, can be found here Link
 Command line utility to install Node.js packages, do version
management and dependency management of Node.js packages.

NPM comes bundled with Node.js installables after v0.6.3 version. To verify
the version, open the console and type the following command and see
the result:
$ npm --version

6.13.4

If you are running an old version of NPM then it is quite easy to update it
to the latest version. Just use the following command from root:
$ npm install npm -g

There is a simple syntax to install any Node.js module:

$ npm install <Module Name>

For example, the following is the command to install a famous Node.js web
framework module called Express:
$ npm install express

Now you can use this module in your .js file as follows:
var express = require('express');

Local vs Global Installation.

By default, NPM installs any dependency in the local mode. Here local
mode refers to the package installation in node_modules directory lying in
the folder where Node application is present. Locally deployed packages
are accessible via require() method.
For example, when we installed express module, it created node_modules
directory in the current directory where it installed the express module.``
$ ls -l

total 0

drwxr-xr-x 3 root root 12 Mar 20 14:23 node_modules

Alternatively, you can use npm ls command to list down all the locally
installed modules.

Globally installed packages/dependencies are stored in a system directory.

Such dependencies can be used in CLI (Command Line Interface) function
of any Node.js but cannot be imported using require() in Node application
directly. Now let's try installing the Express module using global
installation.
$ npm install express -g

This will produce a similar result but the module will be installed globally.
Here, the first line shows the module version and the location where it is
getting installed.
[email protected] /usr/lib/node_modules/express

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]

├── [email protected]
├── [email protected]

├── [email protected]

├── [email protected] ([email protected])

├── [email protected] ([email protected])

├── [email protected] ([email protected])

├── [email protected] ([email protected], [email protected])

├── [email protected] ([email protected], [email protected], [email protected])

├── [email protected] ([email protected])

├── [email protected] ([email protected], [email protected])

└── [email protected] ([email protected], [email protected])

You can use the following command to check all the modules that were
globally installed:
$ npm ls -g

Using package.json
package.jsonis present in the root directory of any Node
application/module and is used to define the properties of a package. Let's
open package.json from the express package present
in node_modules/express/
{

"name": "express",

"description": "Fast, unopinionated, minimalist web framework",

"version": "4.11.2",

"author": {

"name": "TJ Holowaychuk",

"email": "[email protected]"

},

"contributors": [{
 "name": "Aaron Heckmann",

"email": "[email protected]"

},

"name": "Ciaran Jessup",

"email": "[email protected]"

},

"name": "Douglas Christopher Wilson",

"email": "[email protected]"

},

"name": "Guillermo Rauch",

"email": "[email protected]"

},

"name": "Jonathan Ong",

"email": "[email protected]"

},

"name": "Roman Shtylman",

"email": "[email protected]"

},
{

"name": "Young Jae Sim",

"email": "[email protected]"

} ],

"license": "MIT", "repository": {

"type": "git",

"url": "https://github.com/strongloop/express"

},

"homepage": "https://expressjs.com/", "keywords": [

"express",

"framework",

"sinatra",

"web",

"rest",

"restful",

"router",

"app",

"api"

],

"dependencies": {

"accepts": "~1.2.3",

"content-disposition": "0.5.0",

"cookie-signature": "1.0.5",

"debug": "~2.1.1",

"depd": "~1.0.0",

"escape-html": "1.0.1",
 "etag": "~1.5.1",

"finalhandler": "0.3.3",

"fresh": "0.2.4",

"media-typer": "0.3.0",

"methods": "~1.1.1",

"on-finished": "~2.2.0",

"parseurl": "~1.3.0",

"path-to-regexp": "0.1.3",

"proxy-addr": "~1.0.6",

"qs": "2.3.3",

"range-parser": "~1.0.2",

"send": "0.11.1",

"serve-static": "~1.8.1",

"type-is": "~1.5.6",

"vary": "~1.0.0",

"cookie": "0.1.2",

"merge-descriptors": "0.0.2",

"utils-merge": "1.0.0"

},

"devDependencies": {

"after": "0.8.1",

"ejs": "2.1.4",

"istanbul": "0.3.5",

"marked": "0.3.3",

"mocha": "~2.1.0",

"should": "~4.6.2",

"supertest": "~0.15.0",

"hjs": "~0.0.6",
 "body-parser": "~1.11.0",

"connect-redis": "~2.2.0",

"cookie-parser": "~1.3.3",

"express-session": "~1.10.2",

"jade": "~1.9.1",

"method-override": "~2.3.1",

"morgan": "~1.5.1",

"multiparty": "~4.1.1",

"vhost": "~3.0.0"

},

"engines": {

"node": ">= 0.10.0"

},

"files": [

"LICENSE",

"History.md",

"Readme.md",

"index.js",

"lib/"

],

"scripts": {

"test": "mocha --require test/support/env

--reporter spec --bail --check-leaks test/ test/acceptance/",

"test-cov": "istanbul cover node_modules/mocha/bin/_mocha

-- --require test/support/env --reporter dot --check-leaks

test/ test/acceptance/",

"test-tap": "mocha --require test/support/env

 --reporter tap --check-leaks test/ test/acceptance/",

"test-travis": "istanbul cover node_modules/mocha/bin/_mocha

--report lcovonly -- --require test/support/env

--reporter spec --check-leaks test/ test/acceptance/"

},

"gitHead": "63ab25579bda70b4927a179b580a9c580b6c7ada",

"bugs": {

"url": "https://github.com/strongloop/express/issues"

},

"_id": "[email protected]",

"_shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",

"_from": "express@*",

"_npmVersion": "1.4.28",

"_npmUser": {

"name": "dougwilson",

"email": "[email protected]"

},

"maintainers": [{

"name": "tjholowaychuk",

"email": "[email protected]"

},

"name": "jongleberry",

"email": "[email protected]"

},
 {

"name": "shtylman",

"email": "[email protected]"

},

"name": "dougwilson",

"email": "[email protected]"

},

"name": "aredridel",

"email": "[email protected]"

},

"name": "strongloop",

"email": "[email protected]"

},

"name": "rfeng",

"email": "[email protected]"

}],

"dist": {

"shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",

"tarball": "https://registry.npmjs.org/express/-/express-
4.11.2.tgz"
 },

"directories": {},

"_resolved": "https://registry.npmjs.org/express/-/express-
4.11.2.tgz",

"readme": "ERROR: No README data found!"

Attributes of Package.json
Demystified
 name − the name of the package
 version − the version of the package
 description − the description of the package
 homepage − the homepage of the package
 author − the author of the package
 contributors − the name of the contributors to the package
 dependencies − the list of dependencies. NPM automatically
installs all the dependencies mentioned here in the node_module
package folder.
 repository − the repository type and the URL of the package.
 main − the package entry point.
 keywords − keywords.

Uninstalling a Module
Use the following command to uninstall a Node.js module.
$ npm uninstall express

Once NPM uninstalls the package, you can verify it by looking at the
content of /node_modules/ directory or type the following command −
$ npm ls

Updating a Module
Update package.json and change the version of the dependency to be
updated and run the following command.
$ npm update express
Search a Module
Search a package name using NPM.
$ npm search express

Create a Module
Creating a module requires package.json to be generated. Let's generate
package.json using npm init, which will generate the basic skeleton of the
package.json.
$ npm init

This utility will walk you through the creation of a package.json file.

It only covers the most common items, and tries to guess sane defaults.

See 'npm help json' for definitive documentation on these fields

and exactly what they do.

Use 'npm install <pkg> --save' afterwards to install a package and

save it as a dependency in the package.json file.

Press ^C at any time to quit.

name: (webmaster)

You will need to provide all the required information about your module.
You can take help from the above-mentioned package.json file to
understand the meanings of various information demanded. Once
package.json is generated, use the following command to register yourself
with NPM repository site using a valid email address.
$ npm adduser

Username: randomname

Password:

Email: (this IS public) [email protected]

It is time to publish your module.

$ npm publish
If everything is fine with your module, then it will be published in the
repository and will be accessible to install using NPM like any other Node.js
module.

Assessment: Quiz
What is the difference between core modules and third party modules?

The first one is installed separately and the second one is installed with Node.js.
The first one is installed with nodejs and the second must be installed separately.
What does npm init do?

Create a node folder. Initialize a node project with package.json file. Install
a module called init.
To install a package using npm, we run:

Npm i <package_name> Npm install <package_name> Npm import

<package_module>

Callbacks Concept
What is Callback?
Callback is an asynchronous equivalent of a function. A callback function is
called at the completion of a given task. Node makes heavy use of
callbacks. All the Node APIs are written in such a way that they support
callbacks.

For example, a file reading function may start reading files and return
control to the execution environment immediately so that the next
instruction can be executed. Once file I/O is complete, it will call the
callback function while passing the callback function, the content of the
file as a parameter. So there is no blocking or wait for File I/O. This makes
Node.js highly scalable as it can process a high number of requests
without waiting for any function to return results.

Blocking Code Example

Create a text file named input.txt with the following content:
Random Text Just For Testing!!!

Create a .js file named main.js with the following code:

var fs = require("fs");

// fs is the file system module we will see it later

var data = fs.readFileSync('input.txt');

console.log(data.toString());

console.log("Program Ended");

Now run the main.js to see the result:

$ node main.js

Verify the Output:

Random Text Just For Testing!!!

Program Ended

Non-Blocking Code Example

Create a text file named input.txt with the following content:
Random Text Just For Testing!!!

Update main.js to have the following code:

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {

//this is the callBack function

if (err) return console.error(err);

console.log(data.toString());

});

console.log("Program Ended");

Now run the main.js to see the result:

$ node main.js

Verify the Output:

Program Ended

Random Text Just For Testing!!!

Blocking vs Non-Blocking
These two examples explain the concept of blocking and non-blocking
calls.

 The first example shows that the program blocks the call until it
reads the file and only then it proceeds to end the program.
 The second example shows that the program does not wait for file
reading and proceeds to print "Program Ended" and at the same
time, the program, without blocking, continues reading the file.

Thus, a blocking program is executed in a sequence. From a programming

point of view, it is easier to implement the logic but non-blocking programs
do not execute in a sequence. In case a program needs to use any data to
be processed, it should be kept within the same block to make it a
sequential execution.

Assessment: Quiz
Node.js is a single-threaded application, but it can support concurrency with the
concept of events and callbacks.

True False
The blocking code approach means that the execution will stop until that part of code
finishes executing.

True False
Callbacks are the solution for handling asynchronous events.

True False

Event Loop
Node.js - Event Loop
Node.js is a single-threaded application, but it can support concurrency
via the concept of event and callbacks. Every Node.js API is
asynchronous and being single-threaded, they use async function
calls to maintain concurrency. Node uses observer patterns. Node thread
keeps an event loop and whenever a task gets completed, it fires the
corresponding event which signals the event-listener function to execute.

Event-Driven Programming
Node.js uses events heavily and it is also one of the reasons why Node.js is
pretty fast compared to other similar technologies. As soon as Node starts
its server, it simply initiates its variables, declares functions and then
simply waits for the event to occur.

In an event-driven application, there is generally a main loop that listens

for events, and then triggers a callback function when one of those events
is detected.

Event Loop
Although events look quite similar to callbacks, the difference lies in the fact that
callback functions are called when an asynchronous function returns its result,
whereas event handling works on the observer pattern. The functions that listen
to events act as Observers. Whenever an event gets fired, its listener function
starts executing. Node.js has multiple built-in events available through events
module and EventEmitter classes which are used to bind events and event-
listeners as follows:

// Import events module

var events = require('events');

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

The following is the syntax to bind an event handler with another event:
// Bind event and event handler as follows

eventEmitter.on('eventName', eventHandler);

We can fire an event programmatically as follows:

// Fire an event

eventEmitter.emit('eventName');

Example
Create a .js file named main.js with the following code:
// Import events module

var events = require('events');

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

// Create an event handler as follows

var connectHandler = function connected() {

console.log('connection succesful.');

// Fire the data_received event

eventEmitter.emit('data_received');

// Bind the connection event with the handler

eventEmitter.on('connection', connectHandler);
// Bind the data_received event with the anonymous function

eventEmitter.on('data_received', function() {

console.log('data received succesfully.');

});

// Fire the connection event

eventEmitter.emit('connection');

console.log("Program Ended.");

Now let's try to run the above program and check its output:
$ node main.js

It should produce the following result:

connection successful.

data received successfully.

Program Ended.

How Do Node Applications Work?

In Node Application, any async function accepts a callback as the last
parameter and a callback function accepts an error as the first parameter.
Let's revisit the previous example again. Create a text file
named input.txt with the following content:
Dummy Text Just for Testing !!!!

Create a .js file named main.js having the following code:

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {

if (err) {

console.log(err.stack);

return;
 }

console.log(data.toString());

});

console.log("Program Ended");

Here fs.readFile() is an async function whose purpose is to read a file. If an

error occurs during the read operation, then the err object will contain
the corresponding error, or else data will contain the contents of the
file. readFile passes (err) and data to the callback function after the read
operation is complete, which finally prints this content:
Program Ended

Dummy Text Just for Testing !!!!

Fill in the blanks Solution

The Event Loop is a queue of callback functions. When an async function executes,
the callback function is pushed into the queue. The JavaScript engine doesn't start
processing the event loop until the code has executed after an async function.

Event Emitter
EventEmitter Class
Many objects in a Node emit events, for example, a net.Server emits an
event each time a peer connects to it. An fs.readStream emits an event
when the file is opened. All objects which emit events are the instances of
events.EventEmitter.

As we have seen in the previous section, EventEmitter class lies in the

events module. It is accessible via the following code:
// Import events module

var events = require('events');

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

When an EventEmitter instance faces any error, it emits an 'error' event.

When a new listener is added, 'newListener' event is fired and when a
listener is removed, 'removeListener' event is fired.
EventEmitter provides multiple properties like on and emit. on property is
used to bind a function with the event and emit is used to fire an event.

Methods
 addListener(event, listener) : Adds a listener at the end of the
listeners array for the specified event. No checks are made to see if
the listener has already been added. Multiple calls passing the same
combination of event and listener will result in the listener being
added multiple times. Returns emitter, so calls can be chained.
 on(event, listener) : Adds a listener at the end of the listeners
array for the specified event. No checks are made to see if the
listener has already been added. Multiple calls passing the same
combination of event and listener will result in the listener being
added multiple times. Returns emitter, so calls can be chained.
 once(event, listener) : Adds a one time listener to the event. This
listener is invoked only the next time an event is fired, after which it
is removed. Returns emitter, so calls can be chained.
 removeListener(event, listener) : Removes a listener from the
listener array for the specified event. Caution − It changes the array
indices in the listener array behind the listener. removeListener will
remove, in most occasions, one instance of a listener from the
listener array. If any single listener has been added multiple times to
the listener array for the specified event, then removeListener must
be called multiple times to remove each instance. Returns emitter,
so calls can be chained.
 removeAllListeners([event]) : Removes all listeners, or those of
the specified event. It's not a good idea to remove listeners that
were added elsewhere in the code, especially when it's on an
emitter that you didn't create (e.g. sockets or file streams). Returns
emitter, so calls can be chained.
 setMaxListeners(n) : By default, EventEmitters will print a warning
if more than 10 listeners are added for a particular event. This is a
useful default state which helps finding memory leaks. Obviously not
all Emitters should be limited to 10. This function allows that to be
increased. Set to zero for unlimited.
 listeners(event) : Returns an array of listeners for the specified
event.
 emit(event, [arg1], [arg2], [...]) : Executes each of the listeners
in order with the supplied arguments. Returns true if the event had
listeners, false otherwise.

Class Methods
listenerCount(emitter, event) : Returns the number of listeners for a
given event.
  Example: create a file named listenerCount.js saved on your
machine,

//import event module

var events = require('events');

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

eventEmitter.emit('connection');

// count the number of listener to this event

eventListeners =
require('events').EventEmitter.listenerCount(eventEmitter,'connection');

console.log(eventListeners + " Listner(s) listening to connection

event");

Execute this piece of code by running the following command:

$ node listenerCount.js

 Output:

1 Listner(s) listening to connection event

Events
 newListener

o event − String: the event's name

o listener − Function: the event handler's function.
This event is emitted any time a listener is added. When this
event is triggered, the listener may have not yet been added
to the array of listeners for the event.
 removeListener

o event − String: The event's name.

o listener − Function: The event handler's function.
This event is emitted any time someone removes a listener.
When this event is triggered, the listener may not yet have
been removed from the array of listeners for the event.
Example
Create a .js file named main.js with the following Node.js code
var events = require('events');

var eventEmitter = new events.EventEmitter();

// listener #1

var listner1 = function listner1() {

console.log('listner1 executed.');

// listener #2

var listner2 = function listner2() {

console.log('listner2 executed.');

// Bind the connection event with the listner1 function

eventEmitter.addListener('connection', listner1);

// Bind the connection event with the listner2 function

eventEmitter.on('connection', listner2);

var eventListeners = require('events').EventEmitter.listenerCount

(eventEmitter,'connection');

console.log(eventListeners + " Listner(s) listening to connection

event");

// Fire the connection event

eventEmitter.emit('connection');
// Remove the binding of listner1 function

eventEmitter.removeListener('connection', listner1);

console.log("Listner1 will not listen now.");

// Fire the connection event

eventEmitter.emit('connection');

eventListeners =
require('events').EventEmitter.listenerCount(eventEmitter,'connection');

console.log(eventListeners + " Listner(s) listening to connection

event");

console.log("Program Ended.");

Now run the main.js to see the result.

$ node main.js

Verify the Output

2 Listner(s) listening to connection event

listner1 executed.

listner2 executed.

Listner1 will not listen now.

listner2 executed.

1 Listner(s) listening to connection event

Program Ended.

Assessment: Quiz
If an EventEmitter does not have at least one listener registered for the 'error' event,
and an 'error' event is emitted, the error is dismissed, a stack trace is printed, and
the Node.js process ____.

continues exits
Which method can be used to handle an event for just only one time?

eventEmitter.on() eventEmitter.once() Another one

How many listeners can we attach to an event in NodeJS?

Unlimited 10
By default EventEmitters will print a warning if more than ______ listeners are added
for a particular event:

10 20 30 100
When the EventEmitter object emits an event, all of the functions attached to that
specific event are called _______. Any values returned by the called listeners are
ignored and will be discarded.

synchronously asynchronously
All objects that emit events are instances of the EventEmitter class.

True False

File System
Synchronous vs Asynchronous
File System
Node implements File I/O using simple wrappers around standard POSIX
functions. The Node File System (fs) module can be imported using the
following syntax:
var fs = require("fs")

Every method in the FS module has synchronous as well as asynchronous

forms. Asynchronous methods take the last parameter as the completion
function callback and the first parameter of the callback function as an
error. It is better to use an asynchronous method instead of a synchronous
method, as the former never blocks a program during its execution,
whereas the latter does.

Example
Create a text file named input.txt with the following content:
Dummy Text For Testing !!!!

Let us create a .js file named main.js with the following code:
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());

console.log("Program Ended");

Now run the main.js to see the result

$ node main.js

Verify the Output:

Synchronous read: Dummy Text For Testing !!!!

Program Ended

Asynchronous read: Dummy Text For Testing !!!!

Let's take a look at a set of good examples on major File I/O methods:

Open a File
Syntax
The following is the method's syntax for opening a file in asynchronous
mode:
fs.open(path, flags[, mode], callback)

Parameters
Here is the description of the parameters used :

 path − This is the string that has the file name and the path.
 flags − Flags indicate the behavior of the file to be opened. All possible
values have been mentioned below.
  mode − It sets the file mode (permission and sticky bits), but only if the
file was created. It defaults to 0666, readable and writeable.
 callback − This is the callback function which gets two arguments (err,
fd).

Flags

 r : Opens file for reading. An exception occurs if the file does not exist.
 r+ : Opens file for reading and writing. An exception occurs if the file does
not exist.
 rs : Opens file for reading in synchronous mode.
 rs+ : Opens file for reading and writing, asking the OS to open it
synchronously. See notes for 'rs' about using this with caution.
 w : Opens file for writing. The file is created (if it does not exist) or
truncated (if it exists).
 wx : Like 'w' but fails if the path exists.
 w+ : Opens file for reading and writing. The file is created (if it does not
exist) or truncated (if it exists).
 wx+ : Like 'w+' but fails if path exists.
 a : Opens file for appending. The file is created if it does not exist.
 ax : Like 'a' but fails if the path exists.
 a+ : Opens file for reading and appending. The file is created if it does not
exist.
 ax+ : Like 'a+' but fails if the the path exists.

Example
Let us create a .js file named main.js that has the following code for
opening an input.txt file for reading and writing:
var fs = require("fs");

// Asynchronous - Opening File

console.log("Going to open file!");

fs.open('input.txt', 'r+', function(err, fd) {

if (err) {

return console.error(err);

console.log("File opened successfully!");

});

Now run the main.js to see the result:

$ node main.js
Verify the Output:
Going to open file!

File opened successfully!

Get a File's Information

Syntax
The following is one the methods' syntax for getting the file's information:
fs.stat(path, callback)

Parameters
Here is the description of the parameters used:

 path − This is the string that has the file name and the path.
 callback − This is the callback function which gets two arguments (err,
stats) where stats is an object of fs.Stats type which is printed below in the
example.

Apart from the important attributes which are printed below in the
example, there are several useful methods available in fs.Stats class
which can be used to check file type. These methods are given in the
following list:

 stats.isFile() : Returns true if file type of a simple file.

 stats.isDirectory() : Returns true if file type of a directory.
 stats.isBlockDevice() : Returns true if file type of a block device.
 stats.isCharacterDevice() : Returns true if file type of a character
device.
 stats.isSymbolicLink() : Returns true if file type of a symbolic link.
 stats.isFIFO() : Returns true if file type of a FIFO.
 stats.isSocket() : Returns true if file type of asocket.

Example
Let us create a js file named main.js with the following code
var fs = require("fs");

console.log("Going to get file info!");

fs.stat('input.txt', function (err, stats) {

if (err) {
 return console.error(err);

console.log(stats);

console.log("Got file info successfully!");

// Check file type

console.log("isFile ? " + stats.isFile());

console.log("isDirectory ? " + stats.isDirectory());

});

Now run the main.js to see the result

$ node main.js

Verify the Output

Going to get file info!

dev: 1792,

mode: 33188,

nlink: 1,

uid: 48,

gid: 48,

rdev: 0,

blksize: 4096,

ino: 4318127,

size: 97,

blocks: 8,

atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),

mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),

ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT)

Got file info successfully!

isFile ? true

isDirectory ? false

Writing a File
Syntax
The following is one of the methods' syntax for writing into a file:
fs.writeFile(filename, data[, options], callback)

This method will over-write the file if the file already exists. If you want to
write into an existing file then you should use another method available.

Parameters
Here is the description of the parameters used :

 path − This is the string having the file name including path.
 data − This is the String or Buffer to be written into the file.
 options − The third parameter is an object which will hold {encoding,
mode, flag}. By default. encoding is utf8, mode is octal value 0666. and
flag is 'w'
 callback − This is the callback function which gets a single parameter err
that returns an error in case of any writing error.

Example
Let us create a js file named main.js having the following code :
var fs = require("fs");

console.log("Going to write into existing file");

fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {

if (err) {

return console.error(err);

console.log("Data written successfully!");

console.log("Let's read newly written data");

 fs.readFile('input.txt', function (err, data) {

if (err) {

return console.error(err);

console.log("Asynchronous read: " + data.toString());

});

});

Now run the main.js to see the result

$ node main.js

Verify the Output

Going to write into existing file

Data written successfully!

Let's read newly written data

Asynchronous read: Simply Easy Learning!

Reading a File
Syntax
The following is one of the methods' syntax for reading from a file:
fs.read(fd, buffer, offset, length, position, callback)

This method will use a file descriptor to read the file. If you want to read
the file directly using the file name, then you should use another method
available.

Parameters
Here is the description of the parameters used:

 fd − This is the file descriptor returned by fs.open().

 buffer − This is the buffer that the data will be written to.
 offset − This is the offset in the buffer to start writing at.
 length − This is an integer specifying the number of bytes to read.
 position − This is an integer specifying where to begin reading from
inside the file. If a position is null, data will be read from the current file
position.
 callback − This is the callback function which gets the three arguments,
(err, bytesRead, buffer)
Example
Let us create a .js file named main.js with the following code:
var fs = require("fs");

var buf = new Buffer(1024);

console.log("Going to open an existing file");

fs.open('input.txt', 'r+', function(err, fd) {

if (err) {

return console.error(err);

console.log("File opened successfully!");

console.log("Going to read the file");

fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){

if (err){

console.log(err);

console.log(bytes + " bytes read");

// Print only read bytes to avoid junk.

if(bytes > 0){

console.log(buf.slice(0, bytes).toString());

});

});

Now run the main.js to see the result:

$ node main.js

Verify the Output

Going to open an existing file
File opened successfully!

Going to read the file

67 bytes read

Dummy Text For Testing!!!!!

Closing a File
Syntax
The following is the syntax for closing an opened file:
fs.close(fd, callback)

Parameters
Here is the description of the parameters used:

 fd − This is the file descriptor returned by file fs.open() method.

 callback − This is the callback function. No arguments other than a
possible exception are given to the completion callback.

Example
Let us create a js file named main.js having the following code
var fs = require("fs");

var buf = new Buffer(1024);

console.log("Going to open an existing file");

fs.open('input.txt', 'r+', function(err, fd) {

if (err) {

return console.error(err);

console.log("File opened successfully!");

console.log("Going to read the file");

fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {

if (err) {
 console.log(err);

// Print only read bytes to avoid junk.

if(bytes > 0) {

console.log(buf.slice(0, bytes).toString());

// Close the opened file.

fs.close(fd, function(err) {

if (err) {

console.log(err);

console.log("File closed successfully.");

});

});

});

Now run the main.js to see the result:

$ node main.js

Verify the Output:

Going to open an existing file

File opened successfully!

Going to read the file

Dummy Text For Testing !!!!!

File closed successfully.

Truncate a File
Syntax
The following is the method's syntax for truncating an opened file:
fs.ftruncate(fd, len, callback)

Parameters
Here is the description of the parameters used:

 fd − This is the file descriptor returned by fs.open().

 len − This is the length of the file after which the file will be truncated.
 callback − This is the callback function. No arguments other than a
possible exception are given to the completion callback.

Example
Let us create a .js file named main.js that has the following code:
var fs = require("fs");

var buf = new Buffer(1024);

console.log("Going to open an existing file");

fs.open('input.txt', 'r+', function(err, fd) {

if (err) {

return console.error(err);

console.log("File opened successfully!");

console.log("Going to truncate the file after 10 bytes");

// Truncate the opened file.

fs.ftruncate(fd, 10, function(err) {

if (err) {

console.log(err);

console.log("File truncated successfully.");

console.log("Going to read the same file");

 fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){

if (err) {

console.log(err);

// Print only read bytes to avoid junk.

if(bytes > 0) {

console.log(buf.slice(0, bytes).toString());

// Close the opened file.

fs.close(fd, function(err) {

if (err) {

console.log(err);

console.log("File closed successfully.");

});

});

});

});

Now run the main.js to see the result

$ node main.js

Verify the Output

Going to open an existing file

File opened successfully!

Going to truncate the file after 10 bytes

File truncated successfully.

Going to read the same file

Dummy Text
File closed successfully.

Delete a File
Syntax
The following is the method's syntax for deleting a file:
fs.unlink(path, callback)

Parameters
Here is the description of the parameters used :

 path − This is the file name including its path.

 callback − This is the callback function. No arguments other than a
possible exception are given to the completion callback.

Example
Let us create a .js file named main.js having the following code
var fs = require("fs");

console.log("Going to delete an existing file");

fs.unlink('input.txt', function(err) {

if (err) {

return console.error(err);

console.log("File deleted successfully!");

});

Now run the main.js to see the result

$ node main.js

Verify the Output

Going to delete an existing file

File deleted successfully!

Create a Directory
Syntax
The following is the method's syntax for creating a directory:
fs.mkdir(path[, mode], callback)

Parameters
Here is the description of the parameters used:

 path − This is the directory name including its path.

 mode − This is the directory permission to be set. Defaults to 0777.
 callback − This is the callback function. No arguments other than a
possible exception are given to the completion callback.

Example
Let us create a .js file named main.js having the following :
var fs = require("fs");

console.log("Going to create directory /tmp/test");

fs.mkdir('/tmp/test',function(err) {

if (err) {

return console.error(err);

console.log("Directory created successfully!");

});

Now run the main.js to see the result:

$ node main.js

Verify the Output:

Going to create directory /tmp/test

Directory created successfully!

Read a Directory
Syntax
The following is the method's syntax for reading a directory:
fs.readdir(path, callback)

Parameters
Here is the description of the parameters used:

 path − This is the directory name including path.

 callback − This is the callback function which gets two arguments (err,
files) where files is an array of the names of the files in the directory
excluding '.' and '..'.

Example
Let us create a js file named main.js having the following code:
var fs = require("fs");

console.log("Going to read directory /tmp");

fs.readdir("/tmp/",function(err, files) {

if (err) {

return console.error(err);

files.forEach( function (file) {

console.log( file );

});

});

Now run the main.js to see the result:

$ node main.js

Verify the Output:

Going to read directory /tmp

ccmzx99o.out

ccyCSbkF.out

employee.ser

hsperfdata_apache
test

test.txt

Remove a Directory
Syntax
The following is the method's syntax for removing a directory:
fs.rmdir(path, callback)

Parameters
Here is the description of the parameters used:

 path − This is the directory name including path.

 callback − This is the callback function. No arguments other than a
possible exception are given to the completion callback.

Example
Let us create a .js file named main.js having the following code:
var fs = require("fs");

console.log("Going to delete directory /tmp/test");

fs.rmdir("/tmp/test",function(err) {

if (err) {

return console.error(err);

console.log("Going to read directory /tmp");

fs.readdir("/tmp/",function(err, files) {

if (err) {

return console.error(err);

files.forEach( function (file) {

console.log( file );
 });

});

});

Now run the main.js to see the result −

$ node main.js

Verify the Output.

Going to read directory /tmp

ccmzx99o.out

ccyCSbkF.out

employee.ser

hsperfdata_apache

test.txt

Assessment: Quiz
'FS' is an acronym for

File System Fichier Système Force System

FS modules allow us to:

Create files Read files Update files Delete files

What is the result of the following code:

fs.appendFile('movies.txt', 'Titatnic', function (err) {

if (err) throw err;
console.log('Saved!');
});
console.log('End of code')

'Saved!' and then 'End of code' 'End of code' and then 'Saved!' 'End of
code' then 'Titatnic' and then 'Saved!'
What is the difference between writeFile and appendFile?

The fs.writeFile() method replaces the specified file and content if it exists while
fs.appendFile appends data to a file The first is synchronous and the second is
asynchronous
What is the result of the following code:

fs.readFile('movies.txt', function (err, data) {

 if (err) throw err;
console.log(data);
});

the content of the file as string value the content of the file as raw buffer
Which FS module method is used to open a file?

fs.openFile(path, flags[, mode], callback) fs.open(path, flags[, mode], callback)

fs.openPath(path, flags[, mode], callback) None of the above

Global Objects
__filename
Node.js global objects are global in nature and they are available in all
modules. We do not need to include these objects in our application, but
instead, we can use them directly. These objects are modules, functions,
strings and objects themselves. We will explain more in the upcoming
slides.

The __filename represents the filename of the code being executed. This is
the resolved absolute path of the code file. For a main program, this is not
necessarily the same filename used in the command line. The value inside
a module is the path to that module's file.

Example
Create a .js file named main.js with the following code:
// Let's try to print the value of __filename

console.log( __filename );

Now run the main.js to see the result:

$ node main.js

Based on the location of your program, it will print the main file name as
follows:
/web/com/1427091028_21099/main.js

__dirname
The __dirname represents the name of the directory that the currently
executing script resides in.
Example
Create a .js file named main.js with the following code:
// Let's try to print the value of __dirname

console.log( __dirname );

Now run the main.js to see the result:

$ node main.js

Based on the location of your program, it will print current directory names
as follows:
/web/com/1427091028_21099

setTimeout(cb, ms)
The setTimeout(cb, ms) global function is used to run callback (cb)
after at least ms milliseconds. The actual delay depends on external
factors like OS timer granularity and system load. A timer cannot span
more than 24.8 days.

Example
Create a .js file named main.js with the following code:
function printHello() {

console.log( "Hello, World!");

// Now call above function after 2 seconds

setTimeout(printHello, 2000);

Now run the main.js to see the result:

$ node main.js

Verify that the output is printed as after a little delay:

Hello, World!
clearTimeout(t)
The clearTimeout(t) global function is used to stop a timer that was
previously created with setTimeout(). Here t is the timer returned by the
setTimeout() function.

Example
Create a .js file named main.js with the following code:
function printHello() {

console.log( "Hello, World!");

// Now call above function after 2 seconds

var t = setTimeout(printHello, 2000);

// Now clear the timer

clearTimeout(t);

Now run the main.js to see the result:

$ node main.js

Verify the output where you will not find anything printed.

setInterval(cb, ms)
The setInterval(cb, ms) global function is used to run a
callback cb repeatedly after at least a few ms milliseconds. The actual
delay depends on external factors like OS timer granularity and system
load. A timer cannot span more than 24.8 days.

This function returns an opaque value that represents the timer which can
be used to clear the timer using the function clearInterval(t).

Example
Create a .js file named main.js with the following code:
function printHello() {

console.log( "Hello, World!");

}
// Now call above function after 2 seconds

setInterval(printHello, 2000);

Now run the main.js to see the result:

$ node main.js

The above program will execute printHello() after every 2 second. Due to
system limitation.

Assessment: Quiz
The __filename give us:

The name of the file being executed and its absolute path. The list of files in
the directory. The list of files in the directory.
The setTimeout(cb,ms) allows us to

Run the program after a period of time. Run the cb function after the time has
passed. Create a time interval in the callback parameters.
Which of the following is true about global objects in Node applications?

Global objects are global in nature and they are available in all modules.
Global objects are not required to be included in an application, rather they can be
used directly. None of the above.

Utility Modules
There are several utility modules available in the Node.js module library.
Among the most frequently used, we can mention the following, make
sure to check them out:

 OS Module:
Provides basic operating-system related utility functions.

 Path Module:
Provides utilities for handling and transforming file paths.

 Net Module:
Provides both servers and clients as streams. Acts as a network
wrapper.
  DNS Module:
Provides functions to do actual DNS lookup as well as to use
underlying operating system name resolution functionalities.

 Domain Module:
Provides ways to handle multiple different I/O operations as a single
group.

Assessment: Quiz
The OS module provides operating system related utility methods and properties.

True False
The net module provides an asynchronous network API for creating stream-based
TCP or IPC servers.

True False
What is a module?

It is a simple or complex functionality organized in single or multiple JavaScript

files which can be reused throughout the Node.js application. It is the installation
of Node.js.

Web Module
What is a Web Server?
A Web Server is a software application which handles HTTP requests sent
by the HTTP client, like web browsers, and returns web pages in response
to the clients. Web servers usually deliver HTML documents along with
images, style sheets, and scripts.

Most of the web servers support server-side scripts. They use scripting
languages and redirect the task to an application server which retrieves
data from a database and performs complex logic. Finally a result is sent
to the HTTP client through the web server.

Web Application Architecture

A Web application is usually divided into four layers:
  Client : This layer consists of web browsers, mobile browsers or
applications which can make HTTP requests to the web server.
 Server : This layer has the web server which can intercept the
requests made by the clients and pass them the response.
 Business : This layer contains the application server which is
utilized by the web server to do the required processing. This layer
interacts with the data layer via the database or some external
programs.
 Data : This layer contains the databases or any other source of data.

Creating a Web Server using Node

Node.js provides an HTTP module which can be used to create an HTTP
client of a server. The following is the bare minimum structure of the HTTP
server which listens to the 8081 port.

Create a js file named server.js :

File: server.js
var http = require('http');

var fs = require('fs');

var url = require('url');

// Create a server

http.createServer( function (request, response) {

// Parse the request containing file name

var pathname = url.parse(request.url).pathname;

 // Print the name of the file for which request is made.

console.log("Request for " + pathname + " received.");

// Read the requested file content from file system

fs.readFile(pathname.substr(1), function (err, data) {

if (err) {

console.log(err);

// HTTP Status: 404 : NOT FOUND

// Content Type: text/plain

response.writeHead(404, {'Content-Type': 'text/html'});

} else {

//Page found

// HTTP Status: 200 : OK

// Content Type: text/plain

response.writeHead(200, {'Content-Type': 'text/html'});

// Write the content of the file to response body

response.write(data.toString());

// Send the response body

response.end();

});

}).listen(8081);

// Console will print the message

console.log('Server running at http://127.0.0.1:8081/');

Creating a Web Server using Node
Next, let's create the following HTML file named index.html in the same
directory where you have created server.js.

File: index.html
<html>

<head>

<title>Sample Page</title>

</head>

<body>

Hello World!

</body>

</html>

Now let us run the server.js to see the result:

$ node server.js

Verify the Output

Server running at http://127.0.0.1:8081/

Make a request to Node.js's server.

Open http://127.0.0.1:8081/index.htm in any browser and you should see
our "Hello World" displayed on the page.
Verify the Output at server end:
Server running at http://127.0.0.1:8081/

Request for /index.htm received.

Creating Web client using Node

A web client can be created using HTTP module. Let's check the following
example.

Create a .js file named client.js:

File: client.js
var http = require('http');

// Options to be used by request

var options = {

host: 'localhost',

port: '8081',

path: '/index.html'

};

// Callback function is used to deal with a response

var callback = function(response) {

// Continuously update stream with data

var body = '';

response.on('data', function(data) {

body += data;

});

response.on('end', function() {

// Data received completely.

console.log(body);

});

// Make a request to the server

var req = http.request(options, callback);

req.end();

Now run the client.js from a different command terminal other than
server.js to see the result:
$ node client.js

Verify the output:

<html>

<head>

<title>Sample Page</title>

</head>

<body>

Hello World!

</body>

</html>

Verify the output at the server's end:

Server running at http://127.0.0.1:8081/

Request for /index.htm received.

Assessment: Quiz
Select the Node.js module types from the following options:

Global Modules Core Modules Local Modules Second Party Modules

Third Party Modules
Which modules are core modules?

HTTP URL FS
To use the HTTP module, we have to use:

import http from 'http' const http = require("http")

Conclusion
Node.js RECAP
Congratulation! By now, we can say we're pretty good with Node.js. We're
able to create and manipulate a web server using Node.js. The main
important thing is that we understand how Node.js treats the async event
and function and that is pretty impressive.

Express (Routing)
Express (Routing) Introduction
What is Express.js ?
After the big rise of Node.js, there are plenty of frameworks and library
that have been created. The most used one for backend rendering is
Express. That will be the topic of this Super Skill. So during this chapter we
are going to explore:

 What is Express?
 How to setup an Express environment?
 What is routing via Express?
 What are middlewares and what is their use?
 How to work with a template engine?
What is Express.js ?
The Express website describes Express as a "minimal and flexible Node.js
web application framework that provides a robust set of features for web
and mobile applications." What does that really mean, exactly?
Express provides basic tools that facilitate the creation of Node.js
applications without obscuring Node.js features that you know and love.
It provides a set of methods for processing HTTP requests and provides a
middleware system that extends its functionality.
It also makes it easier to manage the path (URL) of your application and
not to mention that it uses templates.

If you have wrote any serious apps only using the core Node.js modules,
you must have likely found yourself reinventing the wheel by repeatedly
writing the same code for the same tasks such as:

 Parsing of HTTP request bodies.

 Parsing of cookies.
 Managing sessions.
 Organizing routes with a chain of if conditions based on URL paths
and HTTP request methods.
 Determining proper response headers based on data types.

How Does Express Work ?

Express.js usually has an entry point or in other words, a main file. In that
file, we can perform the following steps:

1. Include third party dependencies.

2. Configure Express.js app settings such as the template engine and
its files’ extensions.
3. Define middlewaress such as error handlers, static files folder,
cookies and other parsers.
4. Define routes.
5. Connect to databases such as MongoDB, Redis or MySQL.
6. Start the app.

When Express.js app is running, it listens to requests. Each incoming

request is processed through a defined chain of middlewares and routes
starting from top to bottom. For example, we can have multiple functions
handling each request and some of those functions will be in the middle
(hence the name middleware):

1. Parse cookie information and go to the next step when done.

2. Parse parameters from the URL and go to the next step when done.
 3. Get the information from the database based on the parameter's
value, if a user is authorized (cookie/session), and go to the next
step if there is a match.
4. Display the data and end the response.

Assessment: Quiz
What are the core features of Express framework?

Allows us to set up middlewares so we can respond to HTTP Requests. It

defines a routing table which is used to perform different actions based on HTTP
method and URL. Dynamically renders HTML pages. All of the above
What is Express.js?

A free open-source, light-weight node js based web application framework.

Designed for building (single-page, multi-page, and hybrid) web applications and
APIs. A third party module. The only web framework for Node.js.
Who developed Express?

Ryan Dahl TJ Holowaychuk Dan Abramov

Environment
Installation
Assuming you’ve already installed Node.js, you should create a directory
to hold your application and make that your working directory.
$ mkdir myapp

$ cd myapp

Once we are inside the project folder, we can create a package.json

manually in a text editor or with the npm init terminal command.
$ npm init

This command prompts you a number of things, such as the name and
version of your application. For now, you can simply hit RETURN to accept
the defaults for most of them, with the following exception:
entry point: (index.js)

Enter app.js, or whatever you want the name of the main file to be. If you
want it to be index.js, hit RETURN to accept the suggested default file
name.
Finally, we can install the module utilizing NPM
$ npm install express --save

Express application generator

Use the application generator tool, express-generator, to quickly create an
application skeleton. Install the application generator as a global npm
package and then launch it.
$ npm install -g express-generator

$ express

For example, the following creates an Express app named myapp. The app
will be created in a folder named myapp in the current working directory
and the view engine will be set to Pug:
$ express --view=pug myapp

The generated app has the following directory structure:

.

├── app.js

├── bin

│ └── www

├── package.json

├── public

│ ├── images

│ ├── javascripts

│ └── stylesheets

│ └── style.css

├── routes

│ ├── index.js

│ └── users.js

└── views

├── error.pug

├── index.pug
 └── layout.pug

7 directories, 9 files

Express application generator

Then install dependencies:
$ cd myapp

$ npm install

run the app with this command:

$ npm start

Then load http://localhost:3000/ in your browser to access the app, you

should see this common response

Command Line Options

This generator can also be configured using command flags:
$ express -h

Usage: express [options] [dir]

Options:

-h, --help output usage information

 --version output the version number

-e, --ejs add ejs engine support

--hbs add handlebars engine support

--pug and pug engine support

-H, --hogan and hogan.js engine support

--no-view generate without view engine

-v, --view <engine> add view <engine> support (ejs|hbs|hjs|jade|

pug|twig|vash) (defaults to jade)

-c, --css <engine> add stylesheet <engine> support (less|stylus|

compass|sass) (defaults to plain css)

--git add .gitignore

-f, --force force on non-empty directory

Watching for File Changes

Node.js applications are stored into memory and if we make changes to
the source code, we need to restart the process, i.e. node.
So to make our development process a lot easier, we will install a tool
from npm, nodemon. This tool restarts our server as soon as we make a
change in any of our files.
To install nodemon, use the following command:
$ npm install -g nodemon

You can now start working on Express.

Assessment: Quiz
To install Node.js express module, we use

$ npm install express --save $ npm install express $ node install express
$ npm install
To generate an express application skeleton without view engine, we use

$ express --no=view myapp $ express --no-view myapp express --without-

view myapp npm express --no-view myapp
How to execute an index.js file with nodemon?

$ nodemon index.js $ nodemon $ nodemon index All of the above

First Application (Hello World)

Hello world Example(1/4)
Let’s create our first application using Express.

include this library:

const express = require('express');

Now we can create an application:

const app = express();

The application is a web server that will run locally on port 4000:
const port = 4000;

Let’s define a wildcard route (*) with app.get() function:

app.get('*', function(req, res){ res.end('Hello World'); });

The app.get() function above accepts regular expressions of the URL

patterns in a string format. In our example, we’re processing all URLs with
the wildcard * character.

The second parameter to the app.get() is a request handler. A typical

Express.js request handler is similar to the one we pass as a callback to
the native/core Node.js http.createServer() method.

Lastly, we start the Express.js web server and output a user-friendly

terminal message in a callback:
app.listen(port, function() {

console.log('The server is running, ' +

' please, open your browser at http://localhost:%s',

port);

});

Hello world Example(2/4)

The full code of the index.js file
const express = require('express');

const app = express();

const port = 4000;

app.get('*', function(req, res){

 res.end('Hello World');

});

app.listen(port, function(){

console.log('The server is running, ' +

' please, open your browser at http://localhost:%s',

port);

});

To run the script, we execute node index.js from the project folder:
$ node index

Now, if you open your browser at http://localhost:4000 (same

as http://127.0.0.1:4000), you should see the “Hello World” message

Hello world Example(3/4)

We can make our example a little more interactive by echoing the name
that we provide to the server along with the “Hello” phrase. To do so, add
the following route before the all-encompassing route from the previous
example.
app.get('/name/:user_name', function(req,res) {

res.status(200);

res.set('Content-type', 'text/html');

res.send('<html><body>' +

'<h1>Hello ' + req.params.user_name + '</h1>' +

 '</body></html>'

);

});

Inside of the /name/:name_route route, we set the proper HTTP status

code (200 means okay), HTTP response headers and wrap our dynamic
text in HTML body and h1 tags.

res.send() is a special Express.js method that conveniently goes beyond

what our old friend from core HTTP module res.end() does. For example,
the former automatically adds a Content-Length HTTP header for us. It
also augments Content-Type based on the data provided to it.

Hello world Example(4/4)

The full source code of the index.js file:
const express = require('express');

const app = express();

const port = 4000;

app.get('/name/:user_name', function(req,res) {

res.status(200);

res.set('Content-type', 'text/html');

res.send('<html><body>' +

'<h1>Hello ' + req.params.user_name + '</h1>' +

'</body></html>'

);

});

app.get('*', function(req, res){

res.end('Hello World');

});

app.listen(port, function(){

console.log('The server is running, ' +

' please, open your browser at http://localhost:%s',

port);
});

After shutting down the previous server and launching the index.js script,
you’ll be able to see the dynamic response, e.g., by
entering http://localhost:4000/name/Gomycode in your browser yields:

Assessment: Quiz
How can we use express?

const express = require('./express'); const app = express(); const express =

require('express'); const app = express(); const express = require('express');
const myApp = express();
Let's suppose you have mysql running on 3000, what would be the result of this
code?

var server = app.listen(3000, function (err){

if(err) console.log('server not running')
else console.log("Calling app.listen's callback function.");
});

Calling server not running Calling Calling app.listen callback function.

Let's assume that we are working on http://localhost:3000. How can we view the
result 'hello world'?

app.get('/home', function(req, res) { res.send('hello world');

});

http://localhost:3000/ http://localhost:3000/home/ http://localhost/home/

Routing.
Routes Introduction
Routes are one of the core concepts in Express and one of the things that
make it really useful.
Routing refers to determining how an application responds to a client
request, at a particular endpoint, which is called a URI (or path) and a
specific HTTP request method (GET, POST, and so on).
Each route can have one or more handler functions which are executed
when the route is matched.
Route definition takes the following structure:
app.METHOD(PATH, HANDLER)

 app is an instance of express.

 METHOD is an HTTP request method, in lowercase.
 PATH is a path on the server.
 HANDLER is the function executed when the route is matched.

Route methods (1/2)

A route method is derived from one of the HTTP methods and it is
attached to an instance of the express class.

The following code is an example of routes that are defined for the GET
and the POST methods to the root of the app.
// GET method route

app.get('/', function (req, res) {

res.send('GET request to the homepage');

})

// POST method route

app.post('/', function (req, res) {

res.send('POST request to the homepage');

})

Route methods (2/2)

There is a special routing method, app.all(), used to load middleware
functions at a path for all HTTP request methods. For example, the
following handler is executed for requests to the route “/secret” whether
using GET, POST, PUT, DELETE, or any other HTTP request method
supported in the HTTP module.
app.all('/secret', function (req, res, next) {

console.log('Accessing the secret section ...');

next(); // pass control to the next handler

})

Express allows us to attach the methods to it.

app.get('/', function (req, res) {

res.send('GET request to the homepage');

}).post('/', function (req, res) {

res.send('POST request to the homepage');

}).all('/secret', function (req, res, next) {

console.log('Accessing the secret section ...');

next(); // pass control to the next handler

}).use(function(req, res, next){

res.status(404).send('Page introuvable !');

});

Route paths (1/2)

The route path is used to define an endpoint where requests can be made.
It is like a backend endpoint. In the Express, route paths can be:

 string
 string patterns
 regular expressions.

The characters ?, +, *, and () are subsets of their regular expression

counterparts.
The hyphen (-) and the dot (.) are literally interpreted by string-based
paths.

If you need to use the dollar character ($) in a path string, enclose it within
([ and ]). For example, the path string for requests at “/data/$book”, would
be “/data/([$])book”.
  Here are some examples of route paths based on strings.

This route path will match requests to /about.

app.get('/about', function (req, res) {

res.send('about');

})

This route path will match requests to /random.text.

app.get('/random.text', function (req, res) {

res.send('random.text');

})

Route paths (2/2)

 Here are some examples of route paths based on string patterns.

This route path will match acd and abcd.

app.get('/ab?cd', function (req, res) {

res.send('ab?cd');

})

This route path will match abcd, abbcd, abbbcd, and so on.
app.get('/ab+cd', function (req, res) {

res.send('ab+cd');

})

This route path will match abcd, abxcd, abRANDOMcd, ab123cd, and so
on.
app.get('/ab*cd', function (req, res) {

res.send('ab*cd');

})

This route path will match /abe and /abcde.

app.get('/ab(cd)?e', function (req, res) {
 res.send('ab(cd)?e');

})

 Examples of route paths based on regular expressions:

This route path will match anything with an “a” in it.

app.get(/a/, function (req, res) {

res.send('/a/');

})

This route path will match butterfly and dragonfly, but not butterflyman,
dragonflyman, and so on.
app.get(/.*fly$/, function (req, res) {

res.send('/.*fly$/');

})

Route Parameters
The route parameters are used to capture the values that are assigned to
a particular position in the URL. They are called the URL segments.

The values obtained are made available in a req.params object, using the
name of the route parameter specified in the path as the values' keys.
Route path: /users/:userId/books/:bookId

Request URL: http://localhost:3000/users/34/books/8989

req.params: { "userId": "34", "bookId": "8989" }

To define routes with route parameters, simply specify the route

parameters in the path of the route as shown below.
app.get('/users/:userId/books/:bookId', function (req, res) {

res.send(req.params)

})

To have more control over the exact string that can be matched by a route
parameter, you can append a regular expression in parentheses (()):
Route path: /user/:userId(\d+)

Request URL: http://localhost:3000/user/42

req.params: {"userId": "42"}

Route handlers
We can have multiple request handlers, hence the name middleware. They
accept the third parameter/function next and calling which (next()) to be
executed will switch the execution flow from one handler to the next:
For Example :
app.get('/api/v1/stories/:id', function(req,res, next) {

//do authorization

//if not authorized or there is an error

//return next(error);

//if authorized and no errors

return next();

}), function(req,res, next) {

//extract id and fetch the object from the database

//assuming no errors, save story in the request object

req.story = story;

return next();

}), function(req,res) {

//output the result of the database search

res.send(res.story);

});

Another useful technique is to pass callbacks as items of an array, thanks

to the inner workings of arguments. JavaScript mechanism:
const authAdmin = function (req, res, next) {

...

return next();

const getUsers = function (req, res, next) {

...

return next();

}
const renderUsers = function (req, res) {

res.end();

const admin = [authAdmin, getUsers, renderUsers];

app.get('/admin', admin);

app.route()
You can create chainable route handlers for a route path by using
app.route(). Because the path is specified at a single location, creating
modular routes is helpful, as well as reducing redundancies and typos.
Here is an example of chained route handlers that are defined by using
app.route().
app.route('/book')

.get(function (req, res) {

res.send('Get a random book');

})

.post(function (req, res) {

res.send('Add a book');

})

.put(function (req, res) {

res.send('Update the book');

})

app.route()
The express.Router middleware allows us to group the route handlers for a
particular part of a site together and access them using a common route-
prefix.

The code below provides a concrete example of how we can create a route
module and then use it in an Express application.
First, we create routes for a post in a module named post.js. Then, the
code imports the Express application object, uses it to get a Router object,
and adds a couple of routes to it using the get() method. Lastly, the
module exports the Router object.

post.js - post route module.

const express = require('express');
const router = express.Router();

// post page route.

router.route('/post/:slug')

.all(function(req, res, next) {

// runs each time

// we can fetch the post by id from the database

})

.get(function(req, res, next) {

//render post

})

.put(function(req, res, next) {

//update post

})

.post(function(req, res, next) {

//create new comment

})

.del(function(req, res, next) {

//remove post

});

module.exports = router

To use the router module in our main app file we first require() the route
module (post.js). We then call use() on the Express application to add the
router to the middleware handling path while specifying the URL path of
'/blog'.
const post = require(‘./post’);

app.use(‘/blog, post);

The app will now be able to handle requests to /blog/post.

Assessment: Quiz
Route paths, in combination with a request method, define the endpoints at which
requests can be made. Which of the following are a valid form of route path?

Strings string patterns regular expressions All of above

Select all the valid route parameter formats.

./users/:userId/books/:bookId /flights/:from-:to /books/!:from-:to

In Express.JS, the method app.all(path, callback [, callback ...]) can accept all HTTP
methods.

True False Insufficient data None

Which function arguments are available to Express.js Route handlers?

req - the request object res - the response object Next All of the above
How many number of callback functions can be attached to handle a request?

Just one Unlimited

Is the following code valid?

const cb0 = function (req, res, next) {

console.log('CB0')
next()
}

const cb1 = function (req, res, next) {

console.log('CB1')
next()
}

const cb2 = function (req, res) {

res.send('Hello from C!')
}

app.get('/example/c', [cb0, cb1, cb2])

True False
Is the following code valid?

const cb0 = function (req, res, next) {

console.log('CB0')
next()
}
const cb1 = function (req, res, next) {
console.log('CB1')
 next()
}
app.get('/example/d', [cb0, cb1], function (req, res, next) {
console.log('the response will be sent by the next function ...')
next()
}, function (req, res) {
res.send('Hello from D!')
})

True False

Middleware
Middleware Introduction
Middleware functions are functions that have access to the request
object (req), the response object (res), and the next function in the
application’s request-response cycle.

The next function is a function in the Express router that, when invoked,
executes the middleware succeeding the current middleware.
Middleware functions can perform the following tasks:

 Execute any code.

 Make changes to the request and the response objects.
 End the request-response cycle.
 Call the next middleware in the stack.

If the current middleware function does not end the request-response

cycle, it must call next() to pass control to the next middleware function.
Otherwise, the request will be left hanging.

Writing middleware (1/2)

Here is a simple example of a middleware function
//Simple request time logger

const myLogger = function (req, res, next) {

console.log("A new request received at " + Date.now());

next();

}
To load the middleware function, call app.use(), specifying which
middleware function. For example, the following code loads the myLogger
middleware function before the route to the root path (/).
const express = require('express');

const app = express();

//Simple request time logger

const myLogger = function (req, res, next) {

console.log("A new request received at " + Date.now());

next();

app.use(myLogger);

app.get('/', function (req, res) {

res.send('Hello World!')

})

app.listen(3000);

The above middleware is called for every request on the server. So after
every request, we will get the following message in the console:
A new request received at 1584954785016

Writing middleware (2/2)

To restrict it to a specific route (and all its subroutes), provide that route
as the first argument of app.use(). For Example,
const express = require('express');

const app = express();

//Middleware function to log request protocol

app.use('/things', function(req, res, next){

console.log("A request for things received at " + Date.now());

next();

});

// Route handler that sends the response

app.get('/things', function(req, res){

res.send('Things');

});

app.listen(3000);

Now, whenever you request any subroute of '/things', that will be the
instance where it will log the time.

Error-handling middleware
Express JS comes with default error handling parameters. We can define
error-handling middleware functions in the same way as other middleware
functions, except error-handling functions have four arguments instead of
three:
app.use(function (err, req, res, next) {

console.error(err.stack)

res.status(500).send('Something broke!')

})

In order to call an error-handling middleware, you simply pass the error to

next(), like this:
app.get('/', (req, res, next) => {

next(new Error('I am passing you an error!'));

});
If you pass anything to the next() function (except the string 'route'),
Express regards the current request as being an error and will skip any
remaining non-error handling routing and middleware functions.

Third Party Middlewares

A list of third party middlewares for Express are available here. The
following are some of the most commonly used middleware. We will also
learn how to mount and use them.

body-parser: parse incoming request bodies in a middleware before your

handlers. It's available under the req.body property.
To mount body parser, we need to install it using
npm install --save body-parser

and to mount it, include the following lines in your index.js

const bodyParser = require('body-parser');

//To parse URL encoded data

app.use(bodyParser.urlencoded({ extended: false }))

//To parse json data

app.use(bodyParser.json())

To view all available options for the body-parser middleware, visit its
GitHub page.

cookie-parser: It parses Cookie header and populates req.cookies with

objects that have cookie names as keys. To mount cookie parser, we need
to install it using
npm install --save cookie-parser

and to mount it, include the following lines in your index.js

var cookieParser = require('cookie-parser');

app.use(cookieParser())
Middleware Order is Important
When a request is received by Express, each middleware that matches the
request is run in the order it is initialized in until there is a concluding
action (like a response being sent).

So if an error occurs, all middlewares that are assigned to handle errors will be
called in order until one of them does not call the next() function call.

Fill in the blanks Solution

Middleware functions are functions that have access to the request object,
the response object ,and the next function in the application’s request-response
cycle. These functions are used to modify req and res objects for tasks like parsing
request bodies, adding response headers, etc.

Template Engines
Template engines Introduction
A template engine facilitates the use of static template files in your
applications. At runtime, it replaces variables in a template file with actual
values, and transforms the template into an HTML file sent to the client. So
this approach is favoured because it allows us to design HTML pages
easily.

Some popular template engines that work with Express are Pug, Mustache,
and EJS. The Express application generator uses Pug (formerly known as
jade) as its default one, but it also supports several others.
See Template Engines (Express wiki) for a list of template engines you can
use with Express. See also Comparing JavaScript Templating Engines: Pug,
Mustache, Dust and More.

Using template engines with Express

Template engine allows you to use static template files in your application.
To render template files you have to set the following application setting
properties:
  Views: It specifies a directory where the template files are located.
 For example: app.set('views', './views').
 view engine: It specifies the template engine that you use. For example,
to use the Pug template engine: app.set('view engine', 'pug').

Let's take the Pug template engine.

Pug Template Engine

Let's learn how to use Pug template engine in Node.js applications using
Express.js. Pug is a template engine for Node.js. Pug uses white spaces
and indentation as part of its syntax. Its syntax is easy to learn.

Install Pug
Execute the following command to install Pug template engine:
npm install pug --save

Pug Template Engine 1/2

Install pug
Execute the following command to install Pug template engine:
npm install pug --save
Pug Template Engine 2/2
Now that Pug is installed, set it as the default template engine for your
app. You don't need to 'require' it. Add the following code to
your index.js file.
app.set('view engine', 'pug');

app.set('views','./views');

Now create a new directory called "views". Inside it, create a file called
first_view.pug, and enter the following data in.
doctype html

html

head

title = "Hello Pug"

body

p.greetings#people Hello World!

To run this page, add the following route to your app.

app.get('/first_template', function(req, res){
 res.render('first_view');

});

You will get the output: Hello World!

Pug converts this very simple looking markup into HTML. We don’t need to
close our tags nor use class and ID keywords. Instead, we use '.' and '#' to
define them. The previous code first gets converted into:
<!DOCTYPE html>

<html>

<head>

<title>Hello Pug</title>

</head>

<body>

<p class = "greetings" id = "people">Hello World!</p>

</body>

</html>

Pug is capable of doing much more than simplifying HTML markup.

Important Pug Features (1/5)

Important Pug Features
Let us now explore a few important Pug features.

Simple Tags
Tags are nested according to their indentation. Like in the example
before, <title> was indented within the <head> tag, so it was inside it.
But, the <body> tag was on the same indentation and that means it is a
sibling of the <head> tag.

We don’t need to close tags. As soon as Pug encounters the next tag on
the same or outer indentation level, it closes the tag automatically.
We have 3 methods for putting text inside a tag:

Space separated
h1 Welcome to Pug

Piped text
div
 | To insert multiple lines of text,

| You can use the pipe operator

Block of text
div.

But that gets tedious if you have a lot of text.

You can use "." at the end of a tag to denote a block of text.

To put tags inside this block, simply enter tag in a new line and

indent it accordingly.

Comments
Pug uses the same syntax as JavaScript(//) for creating comments. These
comments are converted into HTML comments(<!--comment-->). For
example,
//This is a Pug comment

<!--This is a Pug comment-->

Attributes
To define attributes, we use a list of attributes that are separated by
commas and put them inside parenthesis. Class and ID attributes have
special representations. The following line of code covers defining
attributes, classes and HTML tag ID.
div.container.column.main#division(width = "100", height = "100")

This line of code gets converted into the following:

<div class = "container column main" id = "division" width = "100"
height = "100"></div>

Important Pug Features (2/5)

Passing Values to Templates
When we render a Pug template, we can actually pass it a value from our
route handler, which we can then use in our template. Create a new route
handler with the following.
const express = require('express');

const app = express();

app.get('/dynamic_view', function(req, res){

res.render('dynamic', {

name: “Gomycode",

url:"http://www.tutorialspoint.com"

});

});

app.listen(3000);

And create a new view file in views directory, called dynamic.pug, with the
following code
html

head

title=name

body

h1=name

a(href = url) URL

Open localhost:3000/dynamic_view in your browser; You should get the

following output

Important Pug Features (3/5)

We can also use these passed variables within text. To insert passed
variables in between text of a tag, we use #{variableName} syntax. For
example, in the above example, if we wanted to put Greetings from
TutorialsPoint, then we could have done the following.
html

head

title = name

body

h1 Greetings from #{name}

a(href = url) URL

This method of using values is called interpolation. The above code will
display the following output.

Important Pug Features. (4/5)

Conditionals
We can use conditional statements and looping constructs as well.
Consider the following
If a User is logged in, the page should display "Hi, User" and if not, then
the "Login/Sign Up" link. To achieve this, we can define a simple template
like
html

head

title Simple template

 body

if(user)

h1 Hi, #{user.name}

else

a(href = "/sign_up") Sign Up

When we render this using our routes, we can pass an object as in the
following program
res.render('/dynamic',{

user: {name: "Ayush", age: "20"}

});

You will receive a message − Hi, Ayush. But if we don’t pass any object or
pass one with no user key, then we will get a signup link.

Important Pug Features (5/5)

Include and Components
Pug provides a very intuitive way to create components for a web page.
For example, if you see a news website, the header with logo and
categories is always fixed. Instead of copying that to every view we create,
we can use the include feature. Following example shows how we can use
this feature.
Create 3 views with the following code

HEADER.PUG
div.header.

I'm the header for this website.

CONTENT.PUG
html

head

title Simple template

body

include ./header.pug

h3 I'm the main content

include ./footer.pug
FOOTER.PUG
div.footer.

I'm the footer for this website.

Create a route for this as follows

var express = require('express');

var app = express();

app.get('/components', function(req, res){

res.render('content');

});

app.listen(3000);

Go to localhost:3000/components, you will receive the following output

include can also be used to include plaintext, css and JavaScript.

There are many more features of Pug. But those are out of the scope for this
tutorial. You can further explore Pug at Pug

Assessment: Quiz
What are the names of the template engines imposed by Express.js?

EJS Pug Handlebars No template engines are imposed.

Express.js is a lightweight web application that helps in organizing the web
application into MVC architecture on the server's side.

True False
Can we create our own template engine?

True False

Conclusion
Express Routing RECAP
Kudos to you for making it this far!

We'll try and do a little recap before we move on to other things.

After diving deep into this Super Skill, we have covered the basics of
Express.js. It is a super powerful framework for backend rendering, but
that is not all.

For the time being, we have only seen the server part in backend
development. There are still more tools to learn. Let's jump into the next
Super Skill.