__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}`);
});
Frameworks
Nestjs
- It is a progressive Node.js framework for building efficient, reliable, and scalable server-side applications. It is built with TypeScript and heavily inspired by Angular, making it a good choice for developers familiar with Angular. It uses Express by default but can be configured to use Fastify for improved performance
- follows the Model-View-Controller (MVC) architecture and supports dependency injection, making it easier to manage complex applications
- It is ideal for building enterprise-level applications, e-commerce platforms, and applications that require a well-structured and maintainable codebase
Expressjs
- It is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. It is known for its simplicity and ease of use, making it a popular choice for building web servers and APIs
- It is suitable for building simple web servers, APIs, fintech applications, and real-time streaming services
- It is known for its high performance and ability to handle asynchronous operations efficiently. It is lightweight and can be easily extended with middleware
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
Top comments (0)