Útvonalak (routing)

1Mi az útvonal?

Egy útvonal (route) három részből áll:

Az Express minden beérkező kérésnél végigmegy a regisztrált útvonalakon, és megkeresi az elsőt, amelyiknél a metódus is és az útvonal is illeszkedik. Ha talál ilyet, meghívja a kezelőfüggvényt. Ha nem talál, a beépített 404-es válasz megy vissza.

Metódusonként egy függvény

A webshop végponttérképe így néz ki:

app.get("/api/products", …);         // összes termék
app.get("/api/products/:id", …);     // egy termék
app.post("/api/products", …);        // új termék
app.put("/api/products/:id", …);     // teljes felülírás
app.patch("/api/products/:id", …);   // részleges módosítás
app.delete("/api/products/:id", …);  // törlés

Figyeld meg: kétféle útvonalminta van összesen (/api/products és /api/products/:id), de hat végpont — mert a metódus is a végpont része.

2Az útvonalak sorrendje számít

Az Express fentről lefelé haladva keresi az első illeszkedő útvonalat, és megáll az elsőnél. Ez a legtöbb kezdő hiba forrása.

Nézd meg ezt a kódot, és tippelj: mit ad vissza a GET /api/products/uj kérés?

app.get("/api/products/:id", (req, res) => {
  res.json({ talalat: "egy termék", id: req.params.id });
});

app.get("/api/products/uj", (req, res) => {
  res.json({ talalat: "űrlap új termékhez" });
});

Kipróbálva (Express 5.2.1):

GET /api/products/uj  →  200  {"talalat":"egy termék","id":"uj"}

A második útvonal soha nem fut le. A :id minta ugyanis az uj szóra is illeszkedik — a paraméter értéke egyszerűen "uj" lesz. Nincs hibaüzenet, nincs figyelmeztetés: a végpont csendben halott.

A megoldás: a konkrét minta kerüljön a rugalmas elé.

app.get("/api/products/uj", …);     // ✅ előbb a konkrét
app.get("/api/products/:id", …);    // ✅ utána a paraméteres

Ugyanez metódussal

A metódus is része az illeszkedésnek, ezért ez a két sor nem ütközik:

app.get("/api/products/:id", …);      // lekérdezés
app.delete("/api/products/:id", …);   // törlés

Ugyanaz a minta, más metódus — más végpont.

3Útvonalparaméterek — :id

A kettősponttal kezdődő szakasz paraméter: bármire illeszkedik, ami nem tartalmaz perjelet, és az értéke a req.params objektumba kerül.

app.get("/api/products/:id", (req, res) => {
  console.log(req.params);          // { id: "42" }
  res.json({ kert: req.params.id });
});

Több paraméter egy útvonalban

app.get("/api/categories/:catId/products/:prodId", (req, res) => {
  res.json(req.params);
});

GET /api/categories/3/products/9   →   {"catId":"3","prodId":"9"}

A paraméter nevét te választod meg — a req.params kulcsai ezek a nevek lesznek. Írd őket beszédesen: :id egyértelmű, ha csak egy van, de két azonosítónál :catId és :prodId sokkal olvashatóbb.

Veszély — a paraméter mindig szöveg

Ez a fejezet legfontosabb buktatója:

app.get("/api/products/:id", (req, res) => {
  const id = req.params.id;                    // "42" — SZÖVEG!

  const termek = termekek.find(t => t.id === id);   // ❌ soha nem talál semmit
});

A tömbben az id szám (42), a paraméterben szöveg ("42"), és a === a típust is nézi: "42" === 42 → false.

A helyes megoldás:

app.get("/api/products/:id", (req, res) => {
  const id = Number(req.params.id);

  if (Number.isNaN(id)) {
    return res.status(400).json({ error: { message: "Az azonosító csak szám lehet." } });
  }

  const termek = termekek.find(t => t.id === id);

  if (!termek) {
    return res.status(404).json({ error: { message: "Nincs ilyen termék." } });
  }

  res.json(termek);
});

4Query paraméterek — ?page=2

Amíg az útvonalparaméter azt mondja meg, melyik erőforrásról van szó, a query string azt, hogy hogyan kérjük: szűrés, rendezés, lapozás.

app.get("/api/products", (req, res) => {
  console.log(req.query);
  res.json(termekek);
});

GET /api/products?page=2&limit=10   →   req.query = { page: "2", limit: "10" }

Amit tudni kell róla

Ez a négy sor mind valódi, kipróbált eredmény Express 5.2.1-en. A harmadik és a negyedik sor az, ami meglepetést szokott okozni.

Alapértékek és típuskonverzió

Mivel minden szövegként érkezik, és bármelyik hiányozhat, a gyakorlatban így dolgozunk vele:

app.get("/api/products", (req, res) => {
  const oldal = Number(req.query.page) || 1;      // hiányzik vagy nem szám → 1
  const meret = Number(req.query.limit) || 20;    // hiányzik vagy nem szám → 20
  const kereses = req.query.q ?? "";              // hiányzik → üres szöveg

  // …szűrés és lapozás…
});

Kapcsolók kezelése

Mivel a ?akcio üres szöveget ad, logikai kapcsolót így vizsgálunk:

const csakAkcios = req.query.akcio === "true" || req.query.akcio === "";

Vagy — tisztább, ha megköveteljük az értéket (?akcio=true):

const csakAkcios = req.query.akcio === "true";

5req.params vs. req.query — mikor melyik?

Ökölszabály: ha az adat nélkül a végpontnak nincs értelme, útvonalparaméter. Ha csak finomítja az eredményt, query paraméter.

GET /api/products/42            ✅  a 42 nélkül nincs mit visszaadni  → útvonalparaméter
GET /api/products?categoryId=3  ✅  nélküle is van válasz (minden termék) → query
GET /api/products/42?mezok=nev  ✅  a kettő egyszerre is használható

6Útvonalminták Express 5-ben

Itt tér el leglátványosabban az Express 5 a 4-estől. A minták feldolgozását végző könyvtár (path-to-regexp) nagyot változott, és több régi írásmód hibát dob indításkor.

Ami már NEM működik

A hibaüzenetek (valódi, kipróbált kimenet):

PathError [TypeError]: Missing parameter name at index 1: *; visit https://git.new/pathToRegexpError for info
PathError [TypeError]: Unexpected ? at index 10: /users/:id?; visit https://git.new/pathToRegexpError for info
PathError [TypeError]: Unexpected ( at index 4: /:id(\d+); visit https://git.new/pathToRegexpError for info

Ami helyette van

A nevesített joker (*splat)

app.get("/files/*splat", (req, res) => {
  res.json({ params: req.params });
});

Kipróbálva:

GET /files/kepek/2026/logo.png
→ {"params":{"splat":["kepek","2026","logo.png"]}}

A splat név nem kötelező, csak szokás — /*utvonal esetén a kulcs utvonal lesz.

Az opcionális szakasz ({…})

app.get("/users{/:id}", (req, res) => {
  res.json({ params: req.params });
});

GET /users      →   {"params":{}}          — a req.params.id itt undefined
GET /users/7    →   {"params":{"id":"7"}}

Figyeld meg, hogy a perjel is a kapcsos zárójelen belül van: {/:id}, nem /{:id}. Így a /users (perjel nélkül) is illeszkedik.

Ami továbbra is működik

app.get(["/api/products", "/api/termekek"], …);   // ✅ több minta tömbben
app.get(/^\/x\d+$/, …);                            // ✅ reguláris kifejezés

Reguláris kifejezést csak akkor használj, ha tényleg nincs más — nehezen olvasható, és a paraméterek nevesítése is körülményes.

Kis- és nagybetű, záró perjel

Az Express alapból elnéző:

Mindkét viselkedés átállítható (app.set("case sensitive routing", true), app.set("strict routing", true)), de az alapbeállítás a barátságosabb — hagyd békén.

7express.Router() — végpontok külön fájlba

Eddig minden útvonal az app.js-ben volt. Egy valódi API-nál ez néhány száz sor után áttekinthetetlen — ráadásul minden útvonal elején ott az ismétlődő /api/products előtag.

A Router egy önálló, mini alkalmazás: ugyanúgy vesz fel útvonalakat, de nem indít szervert. Kész állapotban „felakasztjuk” az alkalmazásra egy előtag alá.

import express from "express";

const router = express.Router();

router.get("/", (req, res) => {
  res.json(termekek);
});

router.get("/:id", (req, res) => {
  res.json({ id: Number(req.params.id) });
});

router.post("/", (req, res) => {
  res.status(201).json({ letrehozva: true });
});

export default router;

import express from "express";
import termekRouter from "./routes/products.js";

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

// ide akasztjuk fel:
app.use("/api/products", termekRouter);

export default app;

Mit nyerünk vele?

Hova kerülnek a fájlok?

webshop-api/
  app.js                  ← az alkalmazás felépítése, a routerek felakasztása
  index.js                ← a szerver indítása
  routes/
    products.js           ← /api/products végpontjai
    categories.js         ← /api/categories végpontjai
    orders.js             ← /api/orders végpontjai

Ez a szerkezet a 7. fejezetben bővül tovább (controller- és service-réteggel) — most elég annyi, hogy a végpontok erőforrásonként külön fájlba kerülnek.

Mit tudunk meg a kérésből egy routerben?

router.get("/", (req, res) => {
  res.json({ baseUrl: req.baseUrl, url: req.url, originalUrl: req.originalUrl });
});

GET /api/orders esetén az eredmény:

{ "baseUrl": "/api/orders", "url": "/", "originalUrl": "/api/orders" }

Naplózáshoz szinte mindig az originalUrl kell — az url a routerben félrevezető lenne.

Egymásba ágyazott routerek: mergeParams

Ha a routert paraméteres előtag alá akasztod, a paraméter alapból nem látszik a belső routerben. Ezért kell a mergeParams:

const tetelekRouter = express.Router({ mergeParams: true });

tetelekRouter.get("/", (req, res) => {
  res.json(req.params);        // { shopId: "12" }
});

const boltRouter = express.Router();
boltRouter.use("/:shopId/items", tetelekRouter);

app.use("/shops", boltRouter);

GET /shops/12/items   →   {"shopId":"12"}

mergeParams: true nélkül a req.params üres objektum lenne. Ez ritkábban kell, de amikor igen, órákat lehet vele elveszíteni.

8Kényelmi eszközök

app.route() — ugyanaz az útvonal, több metódus

app.route("/api/products/:id")
  .get((req, res) => res.json({ muvelet: "lekérés" }))
  .put((req, res) => res.json({ muvelet: "felülírás" }))
  .delete((req, res) => res.sendStatus(204));

Az útvonalminta egyszer szerepel — kevesebb az elgépelés esélye. A működés azonos azzal, mintha három külön app.get / app.put / app.delete hívást írnál.

Amit nem regisztráltál, arra 404 jön: a fenti kódnál a PATCH /api/products/42 kérésre 404-et kapsz.

app.all() — minden metódus

app.all("/mind", (req, res) => {
  res.json({ metodus: req.method });
});

GET /mind      →   {"metodus":"GET"}
POST /mind     →   {"metodus":"POST"}
DELETE /mind   →   {"metodus":"DELETE"}

Ritkán kell — jellemzően közös előfeldolgozásra (naplózás, hitelesítés-ellenőrzés) egy adott útvonalon. Erre viszont a 6. fejezetben tanult middleware általában jobb eszköz.

Amit az Express magától elintéz

Az 1. blokk 2. fejezetében volt szó a HEAD és az OPTIONS metódusról. Az Express ezeket automatikusan kezeli a regisztrált útvonalaid alapján:

OPTIONS /api/lanc   →   200,  Allow: GET, HEAD, POST

Ez is kipróbált eredmény: a .get() és .post() regisztrációból az Express kitalálta, mit írjon az Allow fejlécbe — és a HEAD-et magától hozzátette a GET mellé.

Több kezelőfüggvény egy útvonalon

Egy útvonalhoz több függvényt is megadhatsz, vesszővel elválasztva:

function bejelentkezveKell(req, res, next) {
  // …ellenőrzés…
  next();                       // ← továbbadjuk a következőnek
}

app.delete("/api/products/:id", bejelentkezveKell, (req, res) => {
  res.sendStatus(204);
});

A next() hívás adja tovább a vezérlést a láncban következő függvénynek. Ez már middleware — a 6. fejezet erről szól részletesen. Itt csak annyit jegyezz meg, hogy az útvonal kezelőfüggvénye nem feltétlenül egyetlen függvény.

9Gyakori hibák

A végpont „nem létezik”, pedig megírtad

app.get("/api/products/:id", …);
app.get("/api/products/uj", …);   // ❌ soha nem fut le

Tünet: a /api/products/uj a :id ágra fut, id: "uj" értékkel.
Megoldás: a konkrét minta a paraméteres elé.

Az összehasonlítás mindig hamis

const termek = termekek.find(t => t.id === req.params.id);   // ❌ "42" === 42

Tünet: mindig 404, pedig a termék létezik.
Megoldás: Number(req.params.id).

A régi joker-szintaxis

app.get("*", (req, res) => res.status(404).json({ error: "Nincs ilyen végpont." }));

Tünet: a szerver el sem indul:

PathError [TypeError]: Missing parameter name at index 1: *; visit https://git.new/pathToRegexpError for info

Megoldás: mintát meg sem adunk, csak app.use()-t használunk a lánc végén:

app.use((req, res) => {
  res.status(404).json({ error: { message: "Nincs ilyen végpont." } });
});

Erről a 8. fejezetben (hibakezelés) lesz szó részletesen — ott az is kiderül, miért a legvégén.

Az előtag kétszer szerepel

// app.js
app.use("/api/products", termekRouter);

// routes/products.js
router.get("/api/products", …);        // ❌

Tünet: a végpont csak a /api/products/api/products címen érhető el.
Megoldás: a routerben relatív útvonal: router.get("/", ...).

Elmarad a return a korai válasz után

if (!termek) {
  res.status(404).json({ error: "Nincs ilyen termék." });   // ❌ nincs return
}
res.json(termek);                                            // lefut ez is

Tünet: ERR_HTTP_HEADERS_SENT a terminálban. A 2. fejezetben már láttuk — Expressben is ugyanez a szabály: egy kérésre egy válasz.

10Feladatok

app.get("/api/products/:id", A);
app.get("/api/products/akcios", B);
app.get("/api/products", C);

app.get("/api/products/:id", (req, res) => {
  const termek = termekek.find(t => t.id === req.params.id);
  if (!termek) return res.status(404).json({ error: "Nincs ilyen." });
  res.json(termek);
});

app.get("*", …);
app.get("/kepek/*", …);
app.get("/users/:id?", …);
app.get("/:id(\d+)", …);

11Önellenőrző kvíz

12Összegzés

13Fogalomtár