Node.js¶

// Variables (prefer const/let, avoid var)
const name = "Node.js";        // Immutable
let version = 22;              // Mutable
// var is legacy (function-scoped, hoisting issues)

// String templates (backticks)
const greeting = `Hello, ${name} v${version}`;  // (1)!

// Arrow functions (modern syntax)
const add = (a, b) => a + b;
const greet = name => `Hello, ${name}`;  // Single param, no parens

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

// Destructuring (clean object/array extraction)
const user = { id: 1, name: "Alice", email: "alice@example.com" };
const { name: userName, email } = user;  // (2)!

const numbers = [1, 2, 3, 4, 5];
const [first, second, ...rest] = numbers;  // rest = [3, 4, 5]

// Spread operator (copy, merge)
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5];  // [1, 2, 3, 4, 5]
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 };  // { a: 1, b: 2, c: 3 }

// Promises (async operations)
const fetchUser = (id) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (id > 0) {
                resolve({ id, name: "Alice" });
            } else {
                reject(new Error("Invalid ID"));
            }
        }, 1000);
    });
};  // (3)!

// Async/await (modern promise syntax)
async function getUser(id) {
    try {
        const user = await fetchUser(id);
        console.log(user);
        return user;
    } catch (error) {
        console.error("Error:", error.message);
    }
}  // (4)!

// Array methods (functional style)
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);        // [2, 4, 6, 8, 10]
const evens = numbers.filter(n => n % 2 === 0); // [2, 4]
const sum = numbers.reduce((acc, n) => acc + n, 0);  // 15

// Classes (ES6+)
class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
    }

    greet() {
        return `Hello, ${this.name}`;
    }

    static createGuest() {
        return new User("Guest", "guest@example.com");
    }
}

// Modules (ESM - modern Node.js)
// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;
export default class Calculator { }  // (5)!

// app.js
import Calculator, { add, subtract } from './math.js';
// OR CommonJS (legacy)
const { add, subtract } = require('./math.js');

// Express.js REST API (most popular framework)
import express from 'express';
const app = express();

app.use(express.json());  // Parse JSON bodies  // (1)!

// GET endpoint
app.get('/api/users', async (req, res) => {
    const users = await db.query('SELECT * FROM users');
    res.json(users);
});

// POST endpoint with validation
app.post('/api/users', async (req, res) => {
    const { name, email } = req.body;
    if (!name || !email) {
        return res.status(400).json({ error: 'Missing fields' });
    }
    const user = await db.insert({ name, email });
    res.status(201).json(user);
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});  // (2)!

// Fastify (faster alternative to Express)
import Fastify from 'fastify';
const fastify = Fastify({ logger: true });

fastify.get('/api/users', async (request, reply) => {
    const users = await db.query('SELECT * FROM users');
    return users;  // Auto-serialized to JSON
});

await fastify.listen({ port: 3000 });  // (3)!

// Database connection (PostgreSQL with pg)
import pg from 'pg';
const { Pool } = pg;

const pool = new Pool({
    host: 'localhost',
    port: 5432,
    database: 'mydb',
    user: 'postgres',
    password: 'password',
    max: 20,  // Connection pool size
});

// Query with parameterized statement (prevent SQL injection)
const getUserById = async (id) => {
    const result = await pool.query(
        'SELECT * FROM users WHERE id = $1',
        [id]  // Parameterized query
    );
    return result.rows[0];
};  // (4)!

// File operations (fs/promises - async API)
import { readFile, writeFile, mkdir } from 'fs/promises';
import { join } from 'path';

// Read file
const content = await readFile('data.json', 'utf-8');
const data = JSON.parse(content);

// Write file (create directories if needed)
await mkdir('output', { recursive: true });
await writeFile('output/result.json', JSON.stringify(data, null, 2));

// HTTP requests (fetch is built-in in Node.js 18+)
const response = await fetch('https://api.example.com/users');
const users = await response.json();  // (5)!

// Or use axios (more features)
import axios from 'axios';
const { data } = await axios.get('https://api.example.com/users', {
    headers: { 'Authorization': 'Bearer token' }
});

// Environment variables (.env file)
import 'dotenv/config';  // Load .env file
const dbUrl = process.env.DATABASE_URL;
const apiKey = process.env.API_KEY;  // (6)!

// Error handling middleware (Express)
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({ error: 'Internal server error' });
});

// Graceful shutdown
process.on('SIGTERM', async () => {
    console.log('SIGTERM received, closing server...');
    await pool.end();  // Close DB connections
    server.close(() => {
        console.log('Server closed');
        process.exit(0);
    });
});  // (7)!

// Testing with Vitest (modern, fast)
import { describe, it, expect } from 'vitest';

describe('add function', () => {
    it('adds two numbers', () => {
        expect(add(2, 3)).toBe(5);
    });

    it('handles negative numbers', () => {
        expect(add(-1, 1)).toBe(0);
    });
});  // (8)!

// WebSockets (real-time communication)
import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (ws) => {
    ws.on('message', (message) => {
        // Broadcast to all clients
        wss.clients.forEach((client) => {
            if (client.readyState === 1) {  // OPEN
                client.send(message);
            }
        });
    });
});  // (9)!

// Streams (memory-efficient file processing)
import { createReadStream, createWriteStream } from 'fs';
import { pipeline } from 'stream/promises';
import { createGzip } from 'zlib';

// Compress file (stream avoids loading entire file in memory)
await pipeline(
    createReadStream('large-file.txt'),
    createGzip(),
    createWriteStream('large-file.txt.gz')
);  // (10)!