Introduction to NodeJS

Node.js is a powerful and popular JavaScript runtime built on Chrome's V8 JavaScript engine.

Features

1) Event-Driven Architecture:
Node.js uses an event-driven, non-blocking I/O model

Blocking operations:
The program execution halts or waits until the operation completes. During this time, the system or thread is not available for other tasks.
Blocking operations are typically synchronous because they halt the execution of the following code until they complete

Synchronous:
The program waits for the operation to finish before moving to the next task.
Ex. Reading a file synchronously in Node.js:

Non-Blocking operations:
The program does not wait for the operation to complete. Instead, it proceeds with other tasks while the operation continues in the background.

Asynchronous:
The program can perform other tasks while waiting for the operation to complete.More complex, requiring mechanisms for handling asynchronous results (e.g., callbacks, promises, async/await).

Event Loop
The event loop is responsible for managing and executing callbacks for asynchronous operations.

2) Asynchronous and Non-Blocking:

The event loop is a core component of Node.js that manages and coordinates the execution of asynchronous operations.

Components of the Event Loop:

Call Stack:
The call stack keeps track of the functions currently being executed. It is a stack data structure where functions are added when called and removed when completed.

Callback Queue:
This queue holds callbacks for asynchronous operations (like I/O operations, timers, or network requests) that have completed and are waiting to be executed.

Event Queue:
Similar to the callback queue, this holds events and their associated callbacks. Events are things like user interactions, timer expirations, or network responses.

Microtask Queue (or Next Tick Queue):
This queue holds microtasks, which are typically promises and their .then() callbacks. Microtasks have higher priority than callbacks and are processed before the event queue.

Timers:
The event loop manages timers using setTimeout() and setInterval(). These are scheduled to execute after a specified delay or at regular intervals.

I/O Operations:
The event loop handles I/O operations like file reads, network requests, and database queries. It allows Node.js to handle these operations asynchronously without blocking the main thread.

const fs = require('fs');

// Asynchronous file read
fs.readFile('file.txt', 'utf8', (err, data) => {
  console.log('File read complete:', data);
});

// Synchronous operation
console.log('This prints first');

// Timer
setTimeout(() => {
  console.log('Timeout executed');
}, 0);

console.log('This prints second');

Execution Order:

The synchronous code (console.log('This prints first') and console.log('This prints second')) runs first, as it is added to the call stack.

The fs.readFile callback and setTimeout callback are added to their respective queues (callback queue and timer queue).

After synchronous code execution, the event loop processes the timer queue and executes the setTimeout callback. Next, it processes the callback queue and executes the fs.readFile callback.

Server Creation

var http = require('http');

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

server.listen(8080, () => {
  console.log('Server running at http://127.0.0.1:8080/');
});

Callbacks

A callback is a function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action.

function downloadFile(url, callback) {
    console.log(`Starting to download file from ${url}`);
    setTimeout(() => {
        console.log('File downloaded successfully');
        callback('File content');
    }, 2000); 
}

function processFile(content) {
    console.log(`Processing file with content: ${content}`);
}

downloadFile('http://example.com/file', processFile);

Promises

An object representing the eventual completion (or failure) of an asynchronous operation and its resulting value.

function downloadFile(url) {
    console.log(`Starting to download file from ${url}`);
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const error = Math.random() > 0.5; // Simulate a random error
            if (error) {
                reject('Error downloading file');
            } else {
                console.log('File downloaded successfully');
                resolve('File content');
            }
        }, 2000); // Simulate a 2-second download time
    });
}

function processFile(content) {
    console.log(`Processing file with content: ${content}`);
}

downloadFile('http://example.com/file')
    .then(processFile)
    .catch((error) => {
        console.error(`Error: ${error}`);
    });

Stay Connected!
If you enjoyed this post, don’t forget to follow me on social media for more updates and insights:

Twitter: madhavganesan
Instagram: madhavganesan
LinkedIn: madhavganesan