Chapter 11: Node.js Fundamentals

Take JavaScript outside the browser — build servers, read files, and create command-line tools with Node.js.

What is Node.js?

Modules

File System

HTTP Server

NPM

Quiz

What is Node.js?

Imagine JavaScript is an employee who only works in one office (the browser). Node.js gives that employee the ability to work anywhere — servers, command line, file systems, databases. Node.js is not a new language; it's the same JavaScript you already know, but running outside the browser.

Key facts about Node.js:

Same language — It's JavaScript! Variables, functions, arrays, objects — all the same
Built on Chrome's V8 engine — The same engine that runs JS in Chrome
Non-blocking I/O — Can handle thousands of requests without waiting (async by nature)
Huge ecosystem — Over 2 million packages on NPM

Try It! Basic JavaScript in Node

These playgrounds run JavaScript just like Node.js would. Try them out:

JavaScript — Node.js Basics

// Variables and types — same as browser JS!
const appName = 'Task Manager';
const version = 2.5;
const isRunning = true;
const features = ['tasks', 'users', 'auth'];

console.log('App:', appName);
console.log('Version:', version);
console.log('Running:', isRunning);
console.log('Features:', features);

// Template literals work everywhere
console.log(`${appName} v${version} has ${features.length} features`);

// Destructuring
const [first, ...rest] = features;
console.log('First feature:', first);
console.log('Other features:', rest);

What Node CAN'T do: Node.js does not have document, window, or alert() — those are browser-only. Instead, Node has access to the file system, network, and operating system.

Modules

Modules are like LEGO bricks. Each brick does one thing (a wheel, a window, a door), and you snap them together to build something complex. In Node.js, each file is a module — it exports what it wants to share, and other files import what they need.

CommonJS (require/module.exports)

This is the traditional Node.js way of importing and exporting:

Node.js — CommonJS Modules

// ===== math.js (the module) =====
// module.exports = what this file SHARES with others

function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

module.exports = { add, multiply };
// Now other files can use these functions!


// ===== app.js (using the module) =====
// require() = import from another file

const { add, multiply } = require('./math');
// './' means "same folder"

console.log(add(5, 3));        // 8
console.log(multiply(4, 7));   // 28

// You can also import the whole object:
// const math = require('./math');
// math.add(5, 3);

ES Modules (import/export)

The modern way — same syntax you use in React:

Node.js — ES Modules

// ===== math.js (ES Module) =====
export function add(a, b) {
  return a + b;
}

export function multiply(a, b) {
  return a * b;
}

// Default export (one per file)
export default function subtract(a, b) {
  return a - b;
}


// ===== app.js (using ES modules) =====
import subtract, { add, multiply } from './math.js';
// To use ES modules in Node, add "type": "module" to package.json

Practice: Working with Functions and Objects

JavaScript — Functions & Objects Practice

// Simulating a module pattern
// In real Node, each file is its own module

const UserService = {
  users: [],

  addUser(name, email) {
    const user = { id: this.users.length + 1, name, email };
    this.users.push(user);
    return user;
  },

  getAll() {
    return this.users;
  },

  findByEmail(email) {
    return this.users.find(u => u.email === email);
  }
};

// Use the "module"
UserService.addUser('Rahul', 'rahul@example.com');
UserService.addUser('Priya', 'priya@example.com');
UserService.addUser('Amit', 'amit@example.com');

console.log('All users:', UserService.getAll());
console.log('Find Priya:', UserService.findByEmail('priya@example.com'));

File System

The File System module (fs) gives Node.js the power to read, write, and manage files on your computer — like a digital filing cabinet. The browser can't do this (for security reasons), but Node can because it runs on the server.

Node.js — File System (fs) Module

const fs = require('fs');

// ===== READING a file =====
// Async version (non-blocking — preferred!)
fs.readFile('data.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});

// ===== WRITING to a file =====
const users = [
  { name: 'Rahul', age: 25 },
  { name: 'Priya', age: 22 },
];

fs.writeFile('users.json', JSON.stringify(users, null, 2), (err) => {
  if (err) console.error('Error writing:', err);
  else console.log('File saved!');
});


// ===== PROMISE-based version (modern way) =====
const fsPromises = require('fs').promises;

async function readConfig() {
  try {
    const data = await fsPromises.readFile('config.json', 'utf8');
    const config = JSON.parse(data);
    console.log('Config:', config);
  } catch (err) {
    console.error('Failed to read config:', err.message);
  }
}

Practice: Working with JSON Data

JavaScript — JSON Parse & Stringify

// JSON is the language of APIs and data files
// JSON.stringify() = object -> string (to save/send)
// JSON.parse() = string -> object (to read/use)

const users = [
  { name: 'Rahul', age: 25, city: 'Mumbai' },
  { name: 'Priya', age: 22, city: 'Delhi' },
];

// Convert to JSON string (like saving to a file)
const jsonString = JSON.stringify(users, null, 2);
console.log('JSON string:');
console.log(jsonString);

console.log('---');

// Convert back to JavaScript object (like reading a file)
const parsed = JSON.parse(jsonString);
console.log('Parsed back:', parsed);
console.log('First user:', parsed[0].name);

// This is exactly what happens when Node reads/writes JSON files!
// fs.writeFile('users.json', JSON.stringify(users))
// const users = JSON.parse(fs.readFileSync('users.json'))

HTTP Server

An HTTP server is like a receptionist at an office. People (browsers) walk in and ask for things ("I want the homepage," "I want user data"). The receptionist listens, figures out what they want, and hands them the right response. Node.js can be that receptionist!

Node.js — Creating an HTTP Server

const http = require('http');

// Create a server that handles requests
const server = http.createServer((req, res) => {
  // req = what the client is asking for
  // res = what we send back

  console.log(`${req.method} ${req.url}`);

  // Simple routing based on URL
  if (req.url === '/' && req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>Welcome to my server!</h1>');
  }
  else if (req.url === '/api/users' && req.method === 'GET') {
    const users = [
      { id: 1, name: 'Rahul' },
      { id: 2, name: 'Priya' },
    ];
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(users));
  }
  else {
    res.writeHead(404, { 'Content-Type': 'text/html' });
    res.end('<h1>404 - Not Found</h1>');
  }
});

// Start listening on port 3000
const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
});

// To test: run "node server.js" in terminal
// Then open http://localhost:3000 in your browser
// Try http://localhost:3000/api/users too!

This is how every website works! When you visit google.com, your browser sends a GET request to Google's server. The server processes it and sends back HTML. Node.js lets YOU build that server.

Practice: Request and Response Concepts

JavaScript — Simulating Request/Response

// Simulating how a server handles different routes
function handleRequest(method, url) {
  console.log(`Incoming: ${method} ${url}`);

  // Route matching
  if (url === '/' && method === 'GET') {
    return { status: 200, body: 'Welcome!' };
  }
  if (url === '/api/users' && method === 'GET') {
    return {
      status: 200,
      body: [{ id: 1, name: 'Rahul' }, { id: 2, name: 'Priya' }]
    };
  }
  if (url === '/api/users' && method === 'POST') {
    return { status: 201, body: { message: 'User created!' } };
  }

  return { status: 404, body: 'Not Found' };
}

// Simulate different requests
const requests = [
  { method: 'GET', url: '/' },
  { method: 'GET', url: '/api/users' },
  { method: 'POST', url: '/api/users' },
  { method: 'GET', url: '/unknown' },
];

requests.forEach(req => {
  const response = handleRequest(req.method, req.url);
  console.log(`Response: ${response.status}`, response.body);
  console.log('---');
});

NPM (Node Package Manager)

NPM is like an app store for code. Need to send emails? There's a package for that. Need to hash passwords? There's a package. Need to connect to a database? Package. Instead of building everything from scratch, you install packages that other developers have already built and tested.

Essential NPM Commands

Terminal — NPM Commands

# Initialize a new project (creates package.json)
npm init -y

# Install a package (adds to dependencies)
npm install express

# Install a dev-only package (testing, linting, etc.)
npm install --save-dev nodemon

# Install all packages from package.json
npm install

# Run a script defined in package.json
npm run dev
npm start

# Uninstall a package
npm uninstall express

# Check for outdated packages
npm outdated

package.json — Your Project's ID Card

package.json — Example

{
  "name": "task-manager-api",
  "version": "1.0.0",
  "description": "Backend API for Task Manager",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "sequelize": "^6.35.0",
    "pg": "^8.11.3",
    "cors": "^2.8.5",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.2"
  }
}

// dependencies = needed in production (express, database drivers)
// devDependencies = only for development (nodemon auto-restarts server)

Never commit node_modules! This folder can contain thousands of files. Always add node_modules/ to your .gitignore. Anyone who clones your project can run npm install to get the packages.

Practice: Array Methods (Used Everywhere in Node)

JavaScript — Array Methods for Backend Dev

// These methods are used CONSTANTLY in Node.js backends

const tasks = [
  { id: 1, title: 'Learn Node', completed: true, priority: 'high' },
  { id: 2, title: 'Build API', completed: false, priority: 'high' },
  { id: 3, title: 'Write tests', completed: false, priority: 'medium' },
  { id: 4, title: 'Deploy app', completed: false, priority: 'low' },
];

// filter — get items matching a condition
const highPriority = tasks.filter(t => t.priority === 'high');
console.log('High priority:', highPriority);

// find — get FIRST item matching a condition
const task2 = tasks.find(t => t.id === 2);
console.log('Found task:', task2);

// map — transform each item
const titles = tasks.map(t => t.title);
console.log('All titles:', titles);

// some — check if ANY item matches
const hasCompleted = tasks.some(t => t.completed);
console.log('Any completed?', hasCompleted);

// reduce — accumulate values
const completedCount = tasks.reduce((count, t) => {
  return t.completed ? count + 1 : count;
}, 0);
console.log('Completed count:', completedCount);

📝 Chapter 11 Quiz

1. What is Node.js?

A new programming language

A runtime that lets JavaScript run outside the browser

A CSS framework

A database system

2. Which function imports a module in CommonJS (traditional Node.js)?

import()

include()

require()

load()

3. Which Node.js module is used to read and write files?

file

disk

4. What does NPM stand for?

New Programming Method

Node Program Manager

Network Package Module

Node Package Manager

5. Why should you never commit node_modules/ to Git?

It contains secret passwords

It's huge and can be recreated with npm install

Git doesn't support folders

It only works on Windows

← Chapter 10: React Full Project Chapter 12: Express.js →