Routing

Mapping URLs and HTTP methods to handler functions - route parameters, query strings, route chaining, and the Router class for organizing larger apps.

What it is, in plain English: Routing in Express means defining which function runs for a given combination of HTTP method (GET, POST, PUT, DELETE...) and URL path. Routes are defined with app.get(), app.post(), etc, each taking a path pattern and a handler function. Dynamic segments in the path (like /users/:id) become available as req.params. The Router class lets you group related routes into separate, mountable modules -- essential for any app with more than a handful of routes.

Mapping URLs to handler functions

The basic pattern -- method + path + handler

app.get("/products", (req, res) => {
  res.json(["Apple", "Banana", "Cherry"]);
});

app.post("/products", (req, res) => {
  // handle creating a new product
  res.status(201).json({ created: true });
});

app.put("/products/:id", (req, res) => { /* update */ });
app.delete("/products/:id", (req, res) => { /* delete */ });

// One method per HTTP verb: app.get, app.post, app.put, app.patch, app.delete
// app.all() matches ANY method (rarely needed)

Route parameters -- capturing parts of the URL

// :id is a named parameter -- matches anything in that position:
app.get("/users/:id", (req, res) => {
  console.log(req.params.id);   // whatever was in the URL
  res.send(`User: ${req.params.id}`);
});

// GET /users/42        --> req.params = { id: "42" }
// GET /users/abc        --> req.params = { id: "abc" }

// Multiple parameters in one route:
app.get("/users/:userId/posts/:postId", (req, res) => {
  const { userId, postId } = req.params;
  res.json({ userId, postId });
});
// GET /users/42/posts/7  --> { userId: "42", postId: "7" }

Query strings -- the part after ?

// Query strings are NOT part of the route pattern -- read via req.query:
app.get("/search", (req, res) => {
  const { q, sort } = req.query;
  res.json({ searchTerm: q, sortBy: sort });
});

// GET /search?q=shoes&sort=price
// --> req.query = { q: "shoes", sort: "price" }

// Always provide defaults for optional query params:
app.get("/products", (req, res) => {
  const page = req.query.page ?? 1;
  const limit = req.query.limit ?? 20;
  res.json({ page, limit });
});

Route order matters

// Express matches routes top-to-bottom, FIRST match wins:
app.get("/users/me", (req, res) => res.send("Current user"));   // must come FIRST
app.get("/users/:id", (req, res) => res.send(`User ${req.params.id}`));

// If /users/:id were defined first, a request to /users/me would
// match :id="me" instead of ever reaching the specific /users/me route.
// Rule: more SPECIFIC routes go before more GENERAL ones.

Try It Yourself (Node.js logic)

// Express routing patterns -- shown as code structure
// (run with real Express + node server.js to see live behaviour)

const ROUTING_EXAMPLES = `
import express from "express";
const app = express();

// Basic routes by HTTP method:
app.get("/products", (req, res) => res.json(products));
app.post("/products", (req, res) => res.json(createProduct(req.body)));
app.put("/products/:id", (req, res) => res.json(updateProduct(req.params.id, req.body)));
app.delete("/products/:id", (req, res) => res.sendStatus(204));

// Route parameters -- :name captures a URL segment:
app.get("/users/:userId/posts/:postId", (req, res) => {
  const { userId, postId } = req.params;
  res.json({ userId, postId });
});
// GET /users/42/posts/7  -->  req.params = { userId: "42", postId: "7" }

// Query strings -- ?key=value pairs (not part of the path pattern):
app.get("/search", (req, res) => {
  const { q, page = 1 } = req.query;
  res.json({ query: q, page });
});
// GET /search?q=shoes&page=2  -->  req.query = { q: "shoes", page: "2" }

// Multiple handlers for one route (chaining):
app.get("/admin", checkAuth, checkAdminRole, (req, res) => {
  res.send("Welcome, admin");
});
`;

console.log(ROUTING_EXAMPLES.trim());

// Demonstrating the route-matching CONCEPT with plain JS (what Express does internally):
function matchPath(pattern, actualPath) {
  const patternParts = pattern.split("/").filter(Boolean);
  const pathParts = actualPath.split("/").filter(Boolean);
  if (patternParts.length !== pathParts.length) return null;

console.log("\nRoute matching logic (simplified):");
console.log(matchPath("/users/:id", "/users/42"));            // { id: "42" }
console.log(matchPath("/users/:id/posts/:postId", "/users/42/posts/7"));
console.log(matchPath("/users/:id", "/products/42"));         // null -- doesn't match

express.Router for organizing larger apps

Splitting routes into modules

// routes/users.js
import { Router } from "express";
const router = Router();

router.get("/", (req, res) => res.json(getAllUsers()));
router.get("/:id", (req, res) => res.json(getUser(req.params.id)));
router.post("/", (req, res) => res.json(createUser(req.body)));

export default router;

// app.js -- mount the router under a path prefix:
import usersRouter from "./routes/users.js";
import postsRouter from "./routes/posts.js";

app.use("/api/users", usersRouter);   // router.get("/") becomes GET /api/users
app.use("/api/posts", postsRouter);   // router.get("/:id") becomes GET /api/posts/:id

// This keeps each resource's routes in its own file, instead of one
// giant app.js with hundreds of app.get/post/put/delete calls.

Router-level middleware

// routes/admin.js
import { Router } from "express";
const router = Router();

// Applies to EVERY route defined below it in this router:
router.use((req, res, next) => {
  if (!req.user?.isAdmin) return res.status(403).send("Forbidden");
  next();
});

router.get("/stats",  (req, res) => res.json(getStats()));
router.get("/users",  (req, res) => res.json(getAllUsersAdmin()));
// Both routes above automatically require admin -- no need to repeat the check

Route chaining with app.route()

// Instead of repeating the path for each method:
app.get("/products/:id", getProduct);
app.put("/products/:id", updateProduct);
app.delete("/products/:id", deleteProduct);

// Chain them on the same path:
app.route("/products/:id")
  .get(getProduct)
  .put(updateProduct)
  .delete(deleteProduct);

path-to-regexp internals and route matching algorithm

// Express uses the path-to-regexp library to compile route strings into
// regular expressions. Understanding this explains advanced patterns:

// Optional parameter:
app.get("/users/:id?", handler);   // matches both /users and /users/42

// Wildcard (Express 5 syntax differs from Express 4 -- check your version):
app.get("/files/*splat", handler);   // Express 5: named wildcard
// app.get("/files/*", handler);     // Express 4: positional wildcard

// Regex constraint on a parameter:
app.get("/users/:id(\\d+)", handler);   // :id must be all digits

// What path-to-regexp actually compiles "/users/:id" into (simplified):
// /^\/users\/([^\/]+?)\/?$/i
// The captured group becomes req.params.id

Why route order is a regex-matching consequence, not arbitrary

Express maintains an ordered array of route definitions internally. For each incoming request, it walks this array and tests each route's compiled regex against the URL, stopping at the FIRST match. This is why route order matters — it's not a special rule Express enforces, it's a direct consequence of linear array iteration with early exit. Middleware mounted with app.use() follows the identical mechanism: each middleware function is just another entry in this same ordered chain, called via next() to advance to the following entry.

Official Sources

The Codex links only to official documentation. No third-party tutorials.