Node js - Quick Recap of Beginner Concepts

Quick Recap of Beginner Concepts in Node.js 

Introduction to Node.js

Node.js is a powerful, open-source, cross-platform runtime environment that allows developers to execute JavaScript code outside of a web browser. It is built on Google Chrome’s V8 JavaScript engine and is designed to build scalable and high-performance applications, especially server-side applications. For beginners, Node.js provides a unified JavaScript development experience, meaning developers can use the same language for both frontend and backend development.

In this detailed guide, we will revisit all the essential beginner-level Node.js concepts in a structured and easy-to-understand format. This recap is especially useful for students, aspiring developers, and professionals preparing for interviews or strengthening their backend development knowledge.

What is Node.js?

Node.js is not a programming language or a framework. It is a runtime environment that enables JavaScript to run on the server side. Traditionally, JavaScript was only used for client-side scripting, but Node.js changed the landscape by allowing JavaScript to power backend services.

Key Features of Node.js

• Asynchronous and event-driven architecture
• Single-threaded but highly scalable
• Fast execution with V8 engine
• Non-blocking I/O operations
• Cross-platform compatibility
• Large ecosystem via npm (Node Package Manager)

Installing Node.js

To get started with Node.js, you need to install it from the official website. The installation includes both Node.js and npm. After installation, you can verify it using the command line.

node -v
npm -v

Understanding the Node.js Architecture

Node.js uses a single-threaded event loop architecture. Unlike traditional multi-threaded servers, Node.js handles multiple client requests using a single thread with event-driven programming.

Event Loop

The event loop is the core of Node.js. It continuously listens for events and executes callback functions when tasks are completed.

Non-Blocking I/O

Node.js performs I/O operations asynchronously. This means it does not wait for tasks like file reading or database queries to complete before moving to the next task.

Running Your First Node.js Application

Creating a simple Node.js application is straightforward. You can write JavaScript code in a file and execute it using Node.js.

// app.js
console.log("Hello, Node.js!");

node app.js

Modules in Node.js

Modules are reusable pieces of code. Node.js follows a modular architecture, allowing developers to organize code efficiently.

Types of Modules

• Core Modules (built-in)
• Local Modules (custom)
• Third-party Modules (installed via npm)

Using Core Modules

const http = require('http');

const server = http.createServer((req, res) => {
    res.write("Hello World");
    res.end();
});

server.listen(3000);

Creating a Custom Module

// math.js
exports.add = (a, b) => a + b;

// app.js
const math = require('./math');
console.log(math.add(5, 3));

Node Package Manager (npm)

npm is the default package manager for Node.js. It allows developers to install, manage, and share packages.

Common npm Commands

npm init
npm install express
npm install lodash --save
npm uninstall package-name

Working with File System (fs Module)

The fs module allows interaction with the file system such as reading, writing, and deleting files.

const fs = require('fs');

fs.writeFile('file.txt', 'Hello World', (err) => {
    if (err) throw err;
    console.log('File created');
});

Asynchronous Programming in Node.js

Asynchronous programming is a core concept in Node.js. It ensures non-blocking execution and improves performance.

Callbacks

setTimeout(() => {
    console.log("Executed after 2 seconds");
}, 2000);

Promises

const promise = new Promise((resolve, reject) => {
    resolve("Success");
});

promise.then(result => console.log(result));

Async/Await

async function fetchData() {
    return "Data received";
}

fetchData().then(console.log);

Creating a Simple HTTP Server

Node.js makes it easy to create web servers using the http module.

const http = require('http');

const server = http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Server is running');
});

server.listen(3000, () => {
    console.log('Server running on port 3000');
});

Introduction to Express.js

Express.js is a popular web framework built on top of Node.js. It simplifies routing, middleware, and server creation.

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

app.get('/', (req, res) => {
    res.send('Hello Express');
});

app.listen(3000);

Routing in Node.js

Routing determines how an application responds to client requests.

app.get('/about', (req, res) => {
    res.send('About Page');
});

Middleware in Node.js

Middleware functions execute during the request-response cycle. They can modify request and response objects.

app.use((req, res, next) => {
    console.log('Middleware executed');
    next();
});

Working with JSON Data

Node.js easily handles JSON data, which is commonly used in APIs.

app.use(express.json());

app.post('/data', (req, res) => {
    res.send(req.body);
});

Error Handling

Error handling ensures that applications run smoothly and gracefully handle failures.

app.use((err, req, res, next) => {
    res.status(500).send('Something went wrong');
});

Environment Variables

Environment variables are used to store configuration values securely.

process.env.PORT

Debugging in Node.js

Debugging helps identify and fix issues in applications.

console.log("Debugging message");

This quick recap of beginner Node.js concepts provides a strong foundation for building backend applications. Understanding these core principles such as modules, asynchronous programming, event loop, and server creation is essential for progressing to advanced topics like authentication, database integration, and microservices.