Introduction to Node.js

Introducing Node.js

• Node.js is an open-source, cross-platform runtime environment.
• Node.js enables developers to create server-side tools and applications using JavaScript.
• It operates outside of a browser context.
• The environment omits browser-specific JavaScript APIs.
• It incorporates support for traditional Operating System APIs, like HTTP and file system libraries.
• With Node.js, developers can use JavaScript for both front-end and back-end code.
• Using JavaScript across the entire stack reduces context switching time.
• It allows libraries to be shared more easily between back-end and front-end projects.
• Real-time applications that continuously send and receive data perform more efficiently when written in Node.js.

Benefits of Node.js

• It provides great performance.
• Code is written in "plain old JavaScript," reducing time spent on context switching between languages.
• It benefits from language design improvements relative to traditional web-server languages like Python and PHP.
• Node Package Manager (NPM) provides access to hundreds of thousands of reusable packages.
• Node.js is portable.
• Node.js facilitates the creation of simple web servers using the Node HTTP package.

Node.js and the V8 Engine

• Node.js operates on the V8 JavaScript engine, which powers Google Chrome, but outside the browser.
• V8 provides the runtime environment where JavaScript executes.
• A Node.js application runs in a single process.
• It does not create a new thread for each request.
• Node.js offers a set of asynchronous I/O primitives in its standard library that prevent JavaScript code from blocking.
• Libraries in Node.js are typically written using non-blocking paradigms, making blocking behavior unusual.
• When Node.js performs an I/O operation, it resumes operations upon response instead of blocking the thread.

Traditional Web Server Model

• Each request is managed by a dedicated thread from a thread pool.
• If no thread is available, the request waits.
• A dedicated thread executes a request and only returns to the thread pool after completion and response.

Node.js Process Model

• A single thread is used
• The thread is free to serve another request
• Asynchronous jobs run on a worker thread
• An even loop manages async job completion

Components of a Node.js Application

• Import required modules.
• Create server.
• Read request and return response.

Creating a Node.js Application

• Step 1: Import Required Module: Use require("http") to import the HTTP module.
• Step 2: Create Server: Call http.createServer() to create a server instance, binding it to port 8081 with the listen method.
• Step 3: Testing Request & Response: Run the server using $ node main.js and verify the output at http://127.0.0.1:8081/,

Node.js Console/REPL

• The Node.js Read-Eval-Print-Loop (REPL) is an interactive shell for processing Node.js expressions.
• The shell reads JavaScript code, evaluates it, prints the result, and loops until the user quits.
• Tasks include read, eval, print, and loop.
• Read - reads user input, parsing it into a JavaScript data structure, and storing it in memory.
• Eval – Takes and evaluates the data structure.
• Print - Prints the result.
• Loop – Loops the above command until the user presses ctrl-c twice.

Starting and Stopping the REPL

• Start the Node.js REPL by entering node in the command line shell.
• The > symbol indicates JavaScript code can be entered and immediately evaluated.
• Exit the REPL by typing .exit, pressing CTRL+D once, or pressing CTRL+C twice.

Using REPL Commands

• Commands begin with a dot (.).
• .help: Display help on all the commands.
• .break: Break out of a stuck situation.
• .clear: Alias for .break.
• .editor: Enter editor mode.
• .exit: Exit the repl.
• .help: Print this help message.
• .load: Load JS from a file into the REPL session.
• .save: Save all evaluated commands in this REPL session to a file.
• Press ^C to abort the current expression.
• Press ^D to exit the repl.

Node.js Module

• A module in Node.js organizes functionality into single or multiple JavaScript files for reuse.
• There are three types of modules: core, local, and third-party.

Node.js Core Modules

• http: Includes classes, methods, and events for creating Node.js HTTP servers.
• url: Includes methods for URL resolution and parsing.
• querystring: Includes methods to deal with query strings.
• path: Includes methods to deal with file paths.
• fs: Includes classes, methods, and events for file I/O.
• util: Includes utility functions useful for programmers.

Loading Core Modules

• Import core or NPM modules using the require() function: var module = require('module_name');.
• The require() function returns an object, function, property, or any other JavaScript type.
• To use the HTTP module:

var http = require('http');
var server = http.createServer(function(req, res) {
  //write code here
});
server.listen(5000);

• The require() function returns an object allowing its properties and methods to be used via dot notation.

Node.js Local Module

• Place a module in a separate JavaScript file named Log.js with the following code inside:

var log = {
  info: function (info) {
    console.log('Info: ' + info);
  },
  warning: function (warning) {
    console.log('Warning: ' + warning);
  },
  error: function (error) {
    console.log('Error: ' + error);
  }
};
module.exports = log;

• The object is assigned this object to module.exports which exposes a log object as a module.

Loading Local Modules

• Load local modules using the require() function in the same way as core modules:

var myLogModule = require('./Log.js');
myLogModule.info('Node.js started');

• The require() function returns a log object because the logging module exposes an object in Log.js using module.exports.
• Call any of its function with myLogModule.info(), myLogModule.warning(), or myLogModule.error() using dot notation.

Node.js Web Server

• Node.js provides capabilities to create your own web server which will handle HTTP requests asynchronously.
• Creating a simple web server:

var http = require('http'); // Import Node.js core module
var server = http.createServer(function (req, res) { // 2 creating server
  //handle incomming requests here..
});
server.listen(5000); //3 listen for any incoming requests
console.log('Node.js web server at port 5000 is running..')

• Import the HTTP module using require().
• call createServer() method of http and specify callback function with request and response parameter
• Call listen() method of server object which was returned from createServer() method with port number.

Handle HTTP Request

• The http.createServer() method includes request and response parameters supplied by Node.js.
• The request object gets information about the current HTTP request (e.g., URL, request header, data).
• The response object sends a response for a current HTTP request.

var http = require('http'); // Import Node.js core module
var server = http.createServer(function (req, res) { //create web server
  if (req.url == '/') { //check the URL of the current request
    // set response header
    res.writeHead(200, { 'Content-Type': 'text/html' });
    // set response content
    res.write('<html><body><p>This is home Page.</p></body></html>');
    res.end(); }
  else if (req.url == "/student") {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write('<html><body><p>This is student Page.</p></body></html>');
    res.end(); }
  else if (req.url == "/admin") {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write('<html><body><p>This is admin Page.</p></body></html>');
    res.end(); }
  else
    res.end('Invalid Request!');
}).listen(5000);
console.log('Node.js web server at port 5000 is running..')

Sending JSON Response

var http = require('http');
var server = http.createServer(function (req, res) {
  if (req.url == '/data') { //check the URL of the current request
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.write(JSON.stringify({ message: "Hello World"}));
    res.end();
  }
}).listen(5000);
console.log('Node.js web server at port 5000 is running..')

JSON vs XML

• JSON (JavaScript Object Notation) is a lightweight, language-independent data-interchange format that focuses on data encoding.
• XML (Extensible Markup Language) is designed to carry data, not display it, and focuses on simplicity and generality, utilizing Unicode for human languages.
• Both JSON and XML can be used to receive data from a web server.
• JSON Example:

{
    "employees":[
        {"firstName":"John", "lastName":"Doe" },
        {"firstName":"Anna", "lastName":"Smith"},
        {"firstName":"Peter", "lastName":"Jones" }
    ]
}

• XML Example:

<employees>
    <employee>
        <firstName>John</firstName> <lastName>Doe</lastName>
    </employee>
    <employee>
        <firstName>Anna</firstName> <lastName>Smith</lastName>
    </employee>
    <employee>
        <firstName>Peter</firstName> <lastName>Jones</lastName>
    </employee>
</employees>

Similarity between JSON and XML

• Both are "self describing" (human readable).
• Both are hierarchical (values within values).
• Both can be parsed and used by many programming languages.
• Both can be fetched with an XMLHttpRequest.

Differences between JSON and XML

• JSON doesn't use end tags.
• JSON is shorter.
• JSON is quicker to read and write.
• JSON can use arrays.
• XML must be parsed with an XML parser, while JSON can be parsed by a standard JavaScript function.

JSON's benefits compared to XML

• XML is more difficult to parse than JSON.
• JSON is parsed into a ready-to-use JavaScript object.
• JSON is faster and easier for AJAX applications.

Using JSON vs. XML

• XML: Fetch an XML document. Use the XML DOM to loop through the document. Extract values and store in variables.
• JSON: Fetch a JSON string. JSON.parse the JSON string.

Creating a Web Server using Node.js (Step 1)

• 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.js (Step 2)

• Create an HTML file named index.html in the same directory as server.js.

<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
</body>
</html>

• Run the server.js file using $ node server.js.
• Verify the output by navigating to http://127.0.0.1:8081/.

Example Node.js Application

• index.js:

const http = require('http');
const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Restarting the Application Automatically

• Use the nodemon module to automatically restart the server upon changes.
• Install globally: npm i -g nodemon.
• Install as a development dependency: npm i --save-dev nodemon.
• Run the application: nodemon app.js.

Node.js Frameworks and Tools

• AdonisJS: A TypeScript-based framework focused on developer ergonomics, stability, and confidence.
• Egg.js: A framework for building enterprise frameworks and apps with Node.js & Koa.
• Express: Provides simple yet powerful tools to create a web server.
• Fastify: Designed to provide the best developer experience with minimal overhead and a robust plugin architecture.
• FeatherJS: A lightweight framework for creating real-time applications and REST APIs.
• Gatsby: A React-based, GraphQL-powered static site generator.
• Hapi: Enables developers to focus on writing reusable application logic.
• Koa: Aims to be simpler and smaller than Express, building on years of knowledge.

Express Overview

• Express is a minimal and flexible Node.js web application framework for developing web and mobile applications.
• It has these core features:
  • Setting up middlewares (request handlers with access to the application's request-response cycle) to respond to HTTP Requests.
  • Defining a routing table, used to execute specific actions based on the HTTP Method and URL.
  • Dynamically rendering HTML Pages based on arguments passed to templates.

Request & Response in Express

• Express applications use a callback function with request and response objects as parameters.
• The request object represents the HTTP request, with properties for the query string, parameters, body, and HTTP headers.
• The response object represents the HTTP response sent by the Express app.

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

GET Method

<html>
<body>
<form action = "http://127.0.0.1:8081/process_get" method = "GET">
First Name: <input type = "text" name = "first_name"> <br>
Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</form>
</body>
</html>

var express = require('express');
var app = express();

app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
    res.sendFile(__dirname + "/" + "index.htm" );
})

app.get('/process_get', function (req, res) {
   // Prepare output in JSON format
   response = {
       first_name:req.query.first_name,
       last_name:req.query.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})

var server = app.listen(8081, function () {
  var host = server.address().address
  var port = server.address().port

  console.log("Example app listening at http://%s:%s", host, port)
})

POST Method

<html>
<body>
<form action = "http://127.0.0.1:8081/process_post" method = "POST">
First Name: <input type = "text" name = "first_name"> <br>
Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</form>
</body>
</html>

var express = require('express');
var app = express();
var bodyParser = require('body-parser');

// Create application/x-www-form-urlencoded parser
var urlencodedParser = bodyParser.urlencoded({ extended: false })

app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
   res.sendFile( __dirname + "/" + "index.htm" );
})
app.post('/process_post', urlencodedParser, function (req, res) {
   // Prepare output in JSON format
   response = {
       first_name:req.body.first_name,
       last_name:req.body.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})
var server = app.listen(8081, function () {
  var host = server.address().address
  var port = server.address().port

  console.log("Example app listening at http://%s:%s", host, port)
})

File Upload

<html>
<head>
<title>File Uploading Form</title>
</head>
<body>
<h3>File Upload:</h3>
Select a file to upload: <br />
<form action = "http://127.0.0.1:8081/file_upload" method = "POST"
enctype = "multipart/form-data">
<input type="file" name="file" size="50" />
<br />
<input type = "submit" value = "Upload File" />
</form>
</body>
</html>

var express = require('express');
var app = express();
var fs = require("fs");

var bodyParser = require('body-parser');
var multer  = require('multer');

app.use(express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}));

app.get('/index.htm', function (req, res) {
   res.sendFile( __dirname + "/" + "index.htm" );
})

app.post('/file_upload', function (req, res) {
   console.log(req.files.file.name);
   console.log(req.files.file.path);
   console.log(req.files.file.type);
   var file = __dirname + "/" + req.files.file.name;
   fs.readFile( req.files.file.path, function (err, data) {
        fs.writeFile(file, data, function (err) {
         if( err ){
              console.log( err );
         }else{
               response = {
                   message:'File uploaded successfully',
                   filename:req.files.file.name
              };
          }
         console.log( response );
         res.end( JSON.stringify( response ) );
      });
   });
})
var server = app.listen(8081, function () {

  var host = server.address().address
  var port = server.address().port

  console.log("Example app listening at http://%s:%s", host, port)

})

Major Comparison Between Node.js and JavaScript

What is NodeJS and why?

• Node.js is a single-threaded, open-source, cross-platform runtime environment.
• It is used for building fast and scalable server-side and networking applications.
• Runs on the V8 JavaScript runtime engine.
• It uses event-driven, non-blocking I/O architecture, making it efficient for real-time applications.

What is NodeJS used for?

• Node.js is an open-source, cross-platform JavaScript runtime environment and library.
• It is intended for running web applications outside the client's browser.
• Ryan Dahl initially developed it in 2009
• Its latest iteration, version 15.14, was released in April 2021.

Is Node JS frontend or backend?

• It can be used on the frontend as well as the backend.

Is Node.js basically JavaScript?

• Node.js is a JavaScript runtime environment for server-side development.
• Write JavaScript code that runs on the server instead of in the browser.