🗺️ Basic Routing and Request Handling

What Is a Route?

A route is a rule that pairs an HTTP method and a URL path with a handler function. When a request arrives, Express finds the first route whose method and path match and runs its handler. Every route follows the same shape:

app.METHOD(PATH, HANDLER);

• app — your Express application object
• METHOD — an HTTP method in lowercase: get, post, put, delete
• PATH — the URL path to match, like / or /users/:id
• HANDLER — (req, res) => { ... }, the function that answers the request

💡 A useful analogy: Routing is a mail sorting room. Each letter (request) carries an address (path) and a type of delivery (method). The sorter reads both and drops the letter into exactly the right clerk's tray (handler). Get the address or delivery type wrong and it lands in the "return to sender" bin — a 404.

HTTP Methods as Routes

The same path can behave differently depending on the method. By convention, the four core methods map to the four things you do with data — often called CRUD (Create, Read, Update, Delete).

// The same path, four different behaviors by method
app.get('/tasks', (req, res) => {
  res.send('List all tasks');
});

app.post('/tasks', (req, res) => {
  res.send('Create a new task');
});

app.put('/tasks/:id', (req, res) => {
  res.send(`Replace task ${req.params.id}`);
});

app.delete('/tasks/:id', (req, res) => {
  res.send(`Delete task ${req.params.id}`);
});

Route Parameters

A path segment starting with a colon is a route parameter — a placeholder that captures whatever appears in that position. Express puts captured values on req.params.

// :id captures the segment after /tasks/
app.get('/tasks/:id', (req, res) => {
  res.send(`You asked for task ${req.params.id}`);
});
// GET /tasks/42  ->  "You asked for task 42"

// Multiple parameters
app.get('/users/:userId/tasks/:taskId', (req, res) => {
  const { userId, taskId } = req.params;
  res.send(`Task ${taskId} belonging to user ${userId}`);
});

Query Parameters

Everything after the ? in a URL is the query string. Unlike route params (which identify a resource), query params carry options like filtering, sorting, and pagination. Express parses them onto req.query.

// URL: /tasks?status=done&limit=5
app.get('/tasks', (req, res) => {
  const { status, limit } = req.query;
  res.json({
    status: status || 'all',
    limit: Number(limit) || 10
  });
});
// -> { "status": "done", "limit": 5 }

💡 Params vs. query: The route parameter is like the street address on an envelope — it decides where the letter goes. The query string is like handling notes scrawled on the outside — "fragile", "deliver by noon" — extra instructions that don't change the destination.

Reading the Request Body

GET requests carry data in the URL, but POST and PUT usually send it in the request body as JSON. Express doesn't parse bodies by default — you must enable the built-in express.json() middleware once, near the top of your app. Then the parsed object appears on req.body.

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

// Enable JSON body parsing for every route (do this once, early)
app.use(express.json());

app.post('/tasks', (req, res) => {
  // req.body is now the parsed JSON object
  const { title } = req.body;
  res.status(201).json({ id: 1, title });
});

Shaping Responses

The res object is how you reply. Pick the method that fits the payload, and always send an appropriate HTTP status code so clients know what happened.

res.send('Plain text or HTML');       // auto-detects content type
res.json({ message: 'Structured' });   // sends JSON + correct header
res.status(201).json({ id: 1 });       // set a status, then send
res.status(404).json({ error: 'Not found' });
res.sendStatus(204);                   // status code with no body

Worked Example: A Tasks API

Let's tie every concept together into a small, complete API that stores tasks in memory (an array — no database yet). It uses all four methods, route params, the request body, and proper status codes.

const express = require('express');
const app = express();
app.use(express.json());

// In-memory "database"
let tasks = [
  { id: 1, title: 'Learn routing', done: false },
  { id: 2, title: 'Build an API', done: false }
];
let nextId = 3;

// READ all (with optional ?done=true filter)
app.get('/tasks', (req, res) => {
  let result = tasks;
  if (req.query.done !== undefined) {
    const wantDone = req.query.done === 'true';
    result = tasks.filter(t => t.done === wantDone);
  }
  res.json(result);
});

// READ one
app.get('/tasks/:id', (req, res) => {
  const task = tasks.find(t => t.id === Number(req.params.id));
  if (!task) {
    return res.status(404).json({ error: 'Task not found' });
  }
  res.json(task);
});

// CREATE
app.post('/tasks', (req, res) => {
  const { title } = req.body;
  if (!title) {
    return res.status(400).json({ error: 'title is required' });
  }
  const task = { id: nextId++, title, done: false };
  tasks.push(task);
  res.status(201).json(task);
});

// UPDATE
app.put('/tasks/:id', (req, res) => {
  const task = tasks.find(t => t.id === Number(req.params.id));
  if (!task) {
    return res.status(404).json({ error: 'Task not found' });
  }
  if (req.body.title !== undefined) task.title = req.body.title;
  if (req.body.done !== undefined) task.done = req.body.done;
  res.json(task);
});

// DELETE
app.delete('/tasks/:id', (req, res) => {
  const id = Number(req.params.id);
  const exists = tasks.some(t => t.id === id);
  if (!exists) {
    return res.status(404).json({ error: 'Task not found' });
  }
  tasks = tasks.filter(t => t.id !== id);
  res.sendStatus(204); // success, no body
});

app.listen(3000, () => console.log('Tasks API on http://localhost:3000'));

$ curl http://localhost:3000/tasks
[{"id":1,"title":"Learn routing","done":false}, ...]

$ curl -X POST http://localhost:3000/tasks \
    -H "Content-Type: application/json" \
    -d '{"title":"Write tests"}'
{"id":3,"title":"Write tests","done":false}

Notice the pattern in every handler: find or validate, return an error status early if something's wrong, otherwise do the work and respond. That "guard clause first" shape keeps handlers flat and readable.

Hands-on Exercise

const express = require('express');
const app = express();
app.use(express.json());

let books = [
  { id: 1, title: 'The Hobbit', author: 'Tolkien' },
  { id: 2, title: 'Dune', author: 'Herbert' }
];
let nextId = 3;

app.get('/books', (req, res) => {
  let result = books;
  if (req.query.author) {
    result = books.filter(b => b.author === req.query.author);
  }
  res.json(result);
});

app.get('/books/:id', (req, res) => {
  const book = books.find(b => b.id === Number(req.params.id));
  if (!book) return res.status(404).json({ error: 'Book not found' });
  res.json(book);
});

app.post('/books', (req, res) => {
  const { title, author } = req.body;
  if (!title) return res.status(400).json({ error: 'title is required' });
  const book = { id: nextId++, title, author };
  books.push(book);
  res.status(201).json(book);
});

app.delete('/books/:id', (req, res) => {
  const id = Number(req.params.id);
  if (!books.some(b => b.id === id)) {
    return res.status(404).json({ error: 'Book not found' });
  }
  books = books.filter(b => b.id !== id);
  res.sendStatus(204);
});

app.listen(3000, () => console.log('Books API on http://localhost:3000'));

Quiz

Summary

📚 Further Reading

• Express — Basic Routing
• Express — Routing Guide (params, patterns)
• MDN — HTTP status codes

🚀 What's Next?

You've been quietly using middleware already (express.json()). Next, Middleware Architecture and Flow unpacks how the middleware pipeline really works — the key to logging, authentication, and clean error handling.