NODE.JS &
EXPRESS CHEATSHEET.

Node.js Basics

Run Script

node app.js
node --watch app.js    // auto‑restart (Node 18+)

NPM Commands

npm init -y                // create package.json
npm install express       // install dependency
npm install -g nodemon    // global install
npm install --save-dev jest // dev dependency
npm run start             // run script

package.json Scripts

"scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js",
    "test": "jest"
}

Core Modules

const fs = require('fs');

// Read file (async)
fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

// Read file (sync)
const data = fs.readFileSync('file.txt', 'utf8');

// Write file
fs.writeFile('file.txt', 'Hello', (err) => {
    if (err) throw err;
});

// Write file (sync)
fs.writeFileSync('file.txt', 'Hello');

// Append
fs.appendFileSync('file.txt', ' World');

// Check if exists
fs.existsSync('file.txt');

// Rename
fs.renameSync('old.txt', 'new.txt');

// Delete
fs.unlinkSync('file.txt');

// Read directory
const files = fs.readdirSync('./');

const path = require('path');

path.join('folder', 'file.txt');  // folder/file.txt
path.resolve('file.txt');         // absolute path
path.basename('/a/b/file.txt');   // file.txt
path.dirname('/a/b/file.txt');    // /a/b
path.extname('file.txt');         // .txt
path.parse('/a/b/file.txt');      // { root, dir, base, ext, name }

const os = require('os');
os.platform();    // 'linux', 'win32', 'darwin'
os.cpus();        // CPU info
os.totalmem();    // total memory
os.freemem();     // free memory
os.homedir();     // home directory

const http = require('http');

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

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

const url = require('url');

const parsed = url.parse('http://example.com:8080/path?query=1#hash');
// { protocol, hostname, port, pathname, query, hash }

// New URL API (recommended)
const myURL = new URL('http://example.com:8080/path?query=1#hash');
myURL.searchParams.get('query'); // 1

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}
const emitter = new MyEmitter();

emitter.on('event', (data) => {
    console.log('Event received:', data);
});

emitter.emit('event', { message: 'Hello' });

const { exec, spawn } = require('child_process');

exec('ls -la', (error, stdout, stderr) => {
    console.log(stdout);
});

const child = spawn('ls', ['-la']);
child.stdout.on('data', (data) => {
    console.log(data.toString());
});

Event Loop & Async Patterns

Async/Await

async function fetchData() {
    try {
        const data = await fs.promises.readFile('file.txt', 'utf8');
        console.log(data);
    } catch (error) {
        console.error(error);
    }
}

Promises

const fs = require('fs').promises;

fs.readFile('file.txt', 'utf8')
    .then(data => console.log(data))
    .catch(err => console.error(err));

Callback

fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) return console.error(err);
    console.log(data);
});

setTimeout / setInterval

setTimeout(() => {
    console.log('After 1s');
}, 1000);

setInterval(() => {
    console.log('Every 2s');
}, 2000);

Express.js

Basic Setup

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

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

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

Routing

// GET
app.get('/', (req, res) => res.send('GET request'));

// POST
app.post('/users', (req, res) => res.send('POST request'));

// PUT
app.put('/users/:id', (req, res) => {
    const id = req.params.id;
    res.send(`PUT request for user ${id}`);
});

// DELETE
app.delete('/users/:id', (req, res) => {
    const id = req.params.id;
    res.send(`DELETE request for user ${id}`);
});

// Route parameters
app.get('/users/:userId/books/:bookId', (req, res) => {
    const { userId, bookId } = req.params;
    res.json({ userId, bookId });
});

// Query parameters
app.get('/search', (req, res) => {
    const { q, limit } = req.query;
    res.json({ q, limit });
});

Middleware

// Application‑level middleware
app.use(express.json());       // parse JSON bodies
app.use(express.urlencoded({ extended: true })); // parse URL‑encoded
app.use(express.static('public')); // serve static files

// Custom middleware
app.use((req, res, next) => {
    console.log(`${req.method} ${req.url}`);
    next();
});

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

// Router‑level middleware
const router = express.Router();
router.use((req, res, next) => {
    console.log('Router middleware');
    next();
});

Request & Response

// Request properties
req.params       // URL parameters
req.query        // query string
req.body         // request body (parsed)
req.headers      // headers
req.ip           // client IP
req.path         // URL path

// Response methods
res.send('Hello');          // send string/object
res.json({ key: 'value' }); // send JSON
res.status(404).send('Not Found'); // set status
res.redirect('/new');       // redirect
res.render('index');        // render view template
res.download('file.pdf');   // download file

Templating (EJS)

// Install: npm install ejs

// Setup
app.set('view engine', 'ejs');
app.set('views', './views');

// views/index.ejs
<h1>Hello <%= name %></h1>

// Route
app.get('/', (req, res) => {
    res.render('index', { name: 'Alice' });
});

Error Handling

// Sync error – caught automatically
app.get('/error', (req, res) => {
    throw new Error('Something went wrong');
});

// Async error – use try/catch + next
app.get('/async', async (req, res, next) => {
    try {
        const data = await fetchData();
        res.json(data);
    } catch (err) {
        next(err);
    }
});

// Better: wrap with asyncHandler
const asyncHandler = (fn) => (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
};

app.get('/async', asyncHandler(async (req, res) => {
    const data = await fetchData();
    res.json(data);
}));

Express Generator

npx express-generator --view=ejs my-app
cd my-app
npm install
npm start

Environment Variables (dotenv)

// Install: npm install dotenv
require('dotenv').config();

const PORT = process.env.PORT || 3000;
const DB_URL = process.env.DATABASE_URL;

// .env file
PORT=3000
DATABASE_URL=mongodb://localhost:27017/mydb

Common Middleware

Example: CORS & Helmet

const cors = require('cors');
const helmet = require('helmet');

app.use(helmet());
app.use(cors({
    origin: 'http://example.com',
    methods: ['GET', 'POST'],
    credentials: true
}));

Example: Morgan

const morgan = require('morgan');
app.use(morgan('dev'));   // combined, common, dev, tiny

Example: Rate Limiting

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100                 // 100 requests per window
});

app.use('/api/', limiter);

Database Integration

MongoDB (Mongoose)

// Install: npm install mongoose
const mongoose = require('mongoose');
mongoose.connect(process.env.MONGO_URI);

const UserSchema = new mongoose.Schema({
    name: String,
    email: { type: String, unique: true },
    age: Number
});

const User = mongoose.model('User', UserSchema);

// CRUD
const user = new User({ name: 'Alice', email: 'alice@example.com' });
await user.save();

const users = await User.find({ age: { $gte: 18 } });
const user = await User.findOne({ email: 'alice@example.com' });
await user.deleteOne();

SQL (PostgreSQL/MySQL)

// Install: npm install pg
const { Pool } = require('pg');
const pool = new Pool({ connectionString: process.env.DATABASE_URL });

// Query
const result = await pool.query('SELECT * FROM users WHERE age >= $1', [18]);

Common Patterns

REST API Structure

// routes/users.js
const express = require('express');
const router = express.Router();

router.get('/', async (req, res) => {
    const users = await User.find();
    res.json(users);
});

router.post('/', async (req, res) => {
    const user = new User(req.body);
    await user.save();
    res.status(201).json(user);
});

router.get('/:id', async (req, res) => {
    const user = await User.findById(req.params.id);
    if (!user) return res.status(404).json({ error: 'User not found' });
    res.json(user);
});

router.put('/:id', async (req, res) => {
    const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
    res.json(user);
});

router.delete('/:id', async (req, res) => {
    await User.findByIdAndDelete(req.params.id);
    res.status(204).send();
});

module.exports = router;

// app.js
app.use('/api/users', require('./routes/users'));

Controller Pattern

// controllers/userController.js
exports.getUsers = async (req, res) => {
    const users = await User.find();
    res.json(users);
};

exports.createUser = async (req, res) => {
    const user = new User(req.body);
    await user.save();
    res.status(201).json(user);
};

Service Pattern

// services/userService.js
exports.getAllUsers = async () => {
    return await User.find();
};

exports.createUser = async (userData) => {
    const user = new User(userData);
    return await user.save();
};