NodeJS.
md 2025-05-13
Node.js
Why Node.js?
JavaScript Everywhere (Full Stack JavaScript)
Unified Language: Use JavaScript for both client-side and server-side development.
Code Reusability: Share libraries, functions, and models between the client and server.
Asynchronous, Event-Driven Model
Non-blocking I/O: Single-threaded event loop for handling many simultaneous requests.
Event Loop: Uses callbacks and promises for asynchronous execution.
Real-Time Interaction: Ideal for real-time apps like chat and gaming.
Performance and Speed
V8 JavaScript Engine: Compiles JavaScript directly into machine code for fast execution.
Efficient Memory Management: Non-blocking model reduces memory usage.
Scalability
Single-Threaded but Scalable: Event loop handles many I/O operations without separate threads.
Horizontal Scaling: Supports clustering for scaling across multiple CPU cores.
Community and Ecosystem
Node Package Manager (NPM): Large ecosystem of open-source libraries and packages.
Active Community: Constant improvement through community contributions.
Cross-Platform Development
Works on Multiple Platforms: Windows, Linux, macOS.
Serverless Computing: Ideal for serverless architectures like AWS Lambda and Google Cloud
Functions.
Microservices Architecture
Lightweight Services: Ideal for building microservices that are independent and scalable.
Cost-Effective for I/O Heavy Applications
I/O Bound Applications: Efficient handling of concurrent I/O tasks like file operations and
database queries.
What is Node.js?
Definition
Node.js: A runtime environment for executing JavaScript code on the server side using Google’s
V8 engine.
1/5
NodeJS.md 2025-05-13
Core Features
Single-Threaded Event Loop: Handles multiple requests concurrently on a single thread.
Asynchronous Programming: Uses callbacks, promises, and async/await for non-blocking
operations.
Built-In Modules: Includes modules like http, fs, path, and events for common tasks.
NPM: Package manager for installing and sharing third-party libraries.
Core Architecture
V8 JavaScript Engine: Compiles JavaScript directly to machine code for fast execution.
Event Loop: Manages asynchronous I/O tasks with callbacks and event handling.
Libuv: Library that handles asynchronous I/O operations.
Common Use Cases
Web Servers: Lightweight, non-blocking I/O web servers.
Real-time Applications: Powers chat apps, live data feeds, multiplayer games.
API Servers: Efficiently handles RESTful and GraphQL APIs.
Microservices: Ideal for building scalable microservices.
Command-Line Tools: Can interact with the operating system for creating CLI tools.
Modular and Extensible
Modules and Packages: Create reusable and shareable modules through NPM.
Microservices and Serverless Architecture: Perfect for modular applications and cloud-based
serverless functions.
How to use Node.js
Installation:
Download from Node.js Official Website
Install via package managers (Homebrew, apt, etc.)
Creating a Node.js Application:
Initialize with npm init
Install dependencies with npm install <package_name>
Start server with node app.js
Create a Web Server in Node.js
Basic Web Server:
const http = require("http");
const server = http.createServer((req, res) => {
res.writeHead(200, { "Content-Type": "text/plain" });
res.end("Hello, Node.js!");
});
server.listen(3000, () =>
console.log("Server running on http://localhost:3000")
);
2/5
NodeJS.md 2025-05-13
http module: Imports the built-in HTTP module for handling requests and responses.
http.createServer(): Creates a server that handles incoming requests.
req: The request object containing request details like URL, method, and headers.
res: The response object used to send data back to the client.
res.writeHead(): Sets the status code and headers for the response.
res.end(): Sends the response body and ends the request.
server.listen(): Binds the server to a port (e.g., 3000) and begins accepting requests.
Node Package Manager (NPM)
What is NPM:
Package manager for Node.js.
Manages libraries and dependencies.
Common NPM Commands:
npm init: Initialize a new Node.js project.
npm install <package_name>: Install dependencies.
npm start: Start a script defined in package.json.
npm install --save-dev <package_name>: Install as development dependency.
Modular Programming in Node.js
Modularity: Split large applications into smaller modules.
Exporting Modules:
// greeting.js
// Function that returns a greeting message
function sayHello(name) {
return `Hello, ${name}!`;
}
// Export the function so it can be used in other files
module.exports = sayHello;
Importing Modules:
// Import the 'greeting' module
const greet = require('./greeting');
// Use the 'sayHello' function from the 'greeting' module
console.log(greet('Alice'));
3/5
NodeJS.md 2025-05-13
Restarting Node Application
Nodemon:
Automatically restarts the Node.js application on file changes.
npm install -g nodemon
Start with nodemon app.js
PM2:
Advanced process manager for Node.js.
Monitors, reloads, and ensures uptime.
npm install pm2 -g
Start with pm2 start app.js
**forever** (deprecated, now largely replaced by pm2).
File Operations in Node.js
Reading Files:
Asynchronous: fs.readFile('file.txt', 'utf8', callback)
Synchronous: fs.readFileSync('file.txt', 'utf8')
Writing Files:
Asynchronous: fs.writeFile('file.txt', data, callback)
Synchronous: fs.writeFileSync('file.txt', data)
Other File Operations:
Appending: fs.appendFileSync('file.txt', data)
Deleting: fs.unlink('file.txt', callback)
Renaming: fs.renameSync('oldname.txt', 'newname.txt')
Directory Operations: fs.mkdirSync('newDir')
Error Handling in Node.js
Error in Asynchronous Code:
fs.readFile("non_existent_file.txt", (err, data) => {
if (err) {
console.error("Error:", err);
return;
}
console.log(data);
});
Error in Synchronous Code:
4/5
NodeJS.md 2025-05-13
try {
let result = 10 / 0;
} catch (err) {
console.error("Error:", err);
}
Connect
GitHub omteja04
LinkedIn omteja
5/5
