Kérés és válasz

1A req objektum — mit tudunk meg a kérésről?

A kezelőfüggvény első paramétere a kérés. Az Express kiegészíti a Node http moduljának kérésobjektumát — az eredeti tulajdonságok (req.method, req.url, req.headers) továbbra is megvannak, de jóval kényelmesebb eszközöket is kapunk.

app.get("/info", (req, res) => {
  res.json({
    metodus:  req.method,        // "GET"
    utvonal:  req.path,          // "/info"        — query NÉLKÜL
    teljes:   req.originalUrl,   // "/info?a=1"    — ahogy a kliens kérte
    protokoll: req.protocol,     // "http"
    hoszt:    req.hostname,      // "localhost"
    ip:       req.ip             // "::1"
  });
});

A leggyakrabban használt tulajdonságok

Fejlécek olvasása: req.get()

req.get("Content-Type");   // "application/json; charset=utf-8"
req.get("content-type");   // ugyanaz — NEM érzékeny a kis- és nagybetűre
req.get("User-Agent");     // ki küldte a kérést
req.get("Authorization");  // a token — a 4. blokkban lesz fontos

Ugyanezt megkapod a req.headers objektumból is, de ott csak kisbetűs kulccsal (req.headers["content-type"]). A req.get() ennél barátságosabb: mindkét írásmódot elfogadja.

A tartalom típusának vizsgálata: req.is()

req.is("application/json");   // "application/json"  — ha egyezik
req.is("json");               // "json"              — rövid alak is jó
req.is("html");               // false               — ha nem egyezik

2A kérés törzse: express.json()

A 2. fejezetben így olvastuk be a törzset — most nézd meg, mennyivel rövidebb Expressben:

let torzs = "";

for await (const darab of req) {
  torzs += darab;
}

const adat = JSON.parse(torzs);
// …és minden végpontnál újra

app.use(express.json());

// …ezután MINDEN végpontban:
req.body   // { nev: "Egér", ar: 4990 }

const app = express();

app.use(express.json());          // ← ez az egy sor

app.post("/api/products", (req, res) => {
  console.log(req.body);          // { nev: "Egér", ar: 4990 }
  res.status(201).json({ letrehozva: req.body });
});

Mit csinál pontosan?

Az express.json() egy middleware: minden kérés előtt lefut. Négy dolgot végez el:

Ha kihagyod: req.body az undefined

Ez a fejezet leggyakoribb hibája. express.json() nélkül:

POST /api/products
Content-Type: application/json

{"nev":"Egér","ar":4990}

app.post("/api/products", (req, res) => {
  console.log(req.body);          // undefined
  console.log(req.body.nev);      // ❌ TypeError: Cannot read properties of undefined
});

Kipróbálva: a typeof req.body értéke "undefined" — a törzs ott van a hálózaton, csak senki nem olvasta be.

Ugyanez rossz Content-Type fejléccel

Az express.json() csak akkor dolgozik, ha a kliens application/json típust jelzett. Ha a fejléc hiányzik vagy más:

Mindegyik sor kipróbált eredmény (Express 5.2.1). Vedd észre a második és a harmadik sor különbségét: az üres objektum azt jelenti, hogy a middleware dolgozott, de nem talált adatot; az undefined azt, hogy hozzá sem nyúlt a törzshöz.

Beállítási lehetőségek

Az express.json() paraméter nélkül is jól működik, de érdemes tudni, mit lehet állítani:

Példák a strict beállításra:

Az alapértékek jók — ezeket ne állítsd át, amíg nincs rá konkrét okod. A limit az egyetlen, amit fájlfeltöltésnél jellemzően emelni kell (arról a 4. blokkban lesz szó).

3Amikor a törzs hibás

Három tipikus eset, mindhárom tesztelt eredménnyel.

Hibás JSON → 400

POST /api/products
Content-Type: application/json

{"nev": hibas}

Az express.json() nem hívja meg a kezelőfüggvényt, hanem hibát dob tovább. A hibaobjektum:

{
  "name": "SyntaxError",
  "message": "Unexpected token 'h', \"{\"nev\": hibas}\" is not valid JSON",
  "status": 400,
  "type": "entity.parse.failed"
}

Túl nagy törzs → 413

Ha a törzs nagyobb, mint a limit:

{
  "name": "PayloadTooLargeError",
  "message": "request entity too large",
  "status": 413,
  "type": "entity.too.large"
}

A 413 jelentése: Payload Too Large — „túl nagy a küldött tartalom”.

Mit lát a kliens?

Ha nincs saját hibakezelőd, az Express beépített hibakezelője válaszol. Ez HTML-t küld — API-ban ez nem az, amit szeretnénk. Ezért írunk saját hibakezelőt:

// a lánc LEGVÉGÉN, minden útvonal után
app.use((err, req, res, next) => {
  res.status(err.status || 500).json({
    error: {
      message: err.message,
      type: err.type          // pl. "entity.parse.failed"
    }
  });
});

Ez a négyparaméteres függvény a központi hibakezelő. Az Express onnan ismeri fel, hogy négy paramétere van (az első az err). A teljes hibakezelés a 8. fejezet témája — itt csak annyi a lényeg, hogy a törzs-feldolgozás hibái is ide futnak be.

4Űrlapadat: express.urlencoded()

A HTML-űrlapok alapból nem JSON-t küldenek, hanem application/x-www-form-urlencoded formátumot — ugyanazt, amit a query stringben látunk:

nev=Eger&ar=4990

Ehhez másik middleware kell:

app.use(express.json());                              // JSON-hoz
app.use(express.urlencoded({ extended: false }));     // űrlaphoz

Mindkettő nyugodtan ott lehet egyszerre: mindegyik csak a saját Content-Type-jára reagál.

Az extended beállítás

A különbség az a[b]=1&c=2 törzsre:

Mi az extended: false-t használjuk, mert egy JSON API-ban az űrlapadat úgyis csak kiegészítés, és az egyszerűbb viselkedés kevesebb meglepetést okoz.

5A válasz fejlécei

A státuszkóddal és a törzzsel az előző fejezetekben már foglalkoztunk. Nézzük a harmadik részt:

app.get("/api/products/42", (req, res) => {
  res.set("X-Osszes-Talalat", "128");        // saját fejléc
  res.json(termek);
});

Mikor kell ez a gyakorlatban?

A 201-es válasz teljes, szabályos alakja:

app.post("/api/products", (req, res) => {
  const ujTermek = { id: 9, ...req.body };

  res.location(`/api/products/${ujTermek.id}`);   // hol találod meg?
  res.status(201).json(ujTermek);
});

A saját fejlécek X- előtagja

Régen minden nem szabványos fejlécet X- előtaggal illett kezdeni (X-Total-Count). Ma ezt már nem írja elő szabvány, de a gyakorlatban máig ez a legelterjedtebb szokás, és jól megkülönbözteti a saját fejléceidet a szabványosaktól. Mi is így írjuk.

6Amit a res.json() átalakít

A res.json() a háttérben JSON.stringify-t hív — és annak megvannak a maga szabályai. A tapasztalat alapján:

res.json({
  datum:    new Date(0),
  nincs:    undefined,
  semmi:    null,
  vegtelen: Infinity,
  nan:      NaN
});

{
  "datum": "1970-01-01T00:00:00.000Z",

  "semmi": null,
  "vegtelen": null,
  "nan": null
}

const atlag = Number.isFinite(szamitott) ? szamitott : 0;

A dátum ISO-szövegként megy — ez jó hír: szabványos, egyértelmű, időzónafüggetlen. A kliens oldalon a new Date("1970-01-01T00:00:00.000Z") visszaalakítja.

7Egy kérésre egy válasz

Ez a HTTP alapszabálya, és a 2. fejezetben már találkoztunk vele. Expressben így néz ki a hiba:

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

  if (!termek) {
    res.status(404).json({ error: { message: "Nincs ilyen termék." } });
    // ❌ hiányzik a return!
  }

  res.json(termek);          // lefut ez is
});

Mit lát a kliens, és mit látsz te?

Ez fontos különbség a 2. fejezethez képest, és ellenőriztük is:

A terminálban ez jelenik meg:

Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (node:_http_outgoing:684:11)
    at ServerResponse.header (…\node_modules\express\lib\response.js:686:10)
    at ServerResponse.send (…\node_modules\express\lib\response.js:163:12)
    at ServerResponse.json (…\node_modules\express\lib\response.js:252:15)

A megoldás: return

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

res.json(termek);

A return res.… írásmód azért terjedt el, mert egy sorban intézi el mindkettőt: elküldi a választ és kilép a függvényből. A res.json() visszatérési értékét nem használjuk semmire — a return itt csak a kilépés miatt van.

Védekezés: res.headersSent

if (!res.headersSent) {
  res.status(500).json({ error: { message: "Váratlan hiba." } });
}

Javaslat: a headersSent helyett használjuk inkább a return-t. A headersSent a hibakezelőben hasznos, ahol tényleg nem tudhatod, mi történt korábban.

8Átirányítás — és miért ritka az API-ban

res.redirect("/api/products");         // alapból 302
res.redirect(301, "/api/termekek");    // saját kóddal

Az eredmény a res.redirect(302, "/info") hívásra:

302  Location: /info
Content-Type: text/plain; charset=utf-8
Found. Redirecting to /info

9Egységes válaszformátum a webshophoz

Ha minden végpont máshogy formázza a hibát, a kliensoldali kód használhatatlan lesz. Rögzítsük most, és a blokk végéig tartsuk magunkat hozzá:

Sikeres válasz — maga az adat, becsomagolás nélkül:

{ "id": 42, "nev": "Billentyűzet", "ar": 12990 }

[ { "id": 42, "nev": "Billentyűzet" }, { "id": 43, "nev": "Egér" } ]

Hibás válasz — mindig ugyanaz a szerkezet:

{
  "error": {
    "message": "Nincs ilyen termék.",
    "code": "TERMEK_NEM_TALALHATO"
  }
}

Egy segédfüggvény, amit a blokk végéig használunk:

// valaszok.js
export function hiba(res, statusz, uzenet, kod) {
  return res.status(statusz).json({ error: { message: uzenet, code: kod } });
}

import { hiba } from "./valaszok.js";

app.get("/api/products/:id", (req, res) => {
  const id = Number(req.params.id);
  if (Number.isNaN(id)) return hiba(res, 400, "Az azonosító csak szám lehet.", "ERVENYTELEN_ID");

  const termek = termekek.find(t => t.id === id);
  if (!termek) return hiba(res, 404, "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");

  res.json(termek);
});

Figyeld meg, hogy a hiba() visszaadja a res.status(…).json(…) eredményét — így működik előtte a return, és nem kell két sorba írni.

10Gyakori hibák

req.body az undefined

Tünet: TypeError: Cannot read properties of undefined (reading 'nev')

Három lehetséges ok, ebben a sorrendben ellenőrizd:

A szám szövegként érkezik

app.post("/api/products", (req, res) => {
  const ar = req.body.ar;              // JSON-nál szám, űrlapnál SZÖVEG
});

JSON törzsből a {"ar":4990} valódi számot ad, űrlapadatból viszont (ar=4990) szöveget. Ha mindkettőt fogadod, alakíts át: Number(req.body.ar).

ERR_HTTP_HEADERS_SENT

Tünet: a kliens megkapja az első választ, a terminálban viszont hibaüzenet jelenik meg.
Ok: hiányzik egy return a korai válasz elől.
Megoldás: return res.status(404).json(…).

Az ékezetek elromlanak

Expressben ez ritka, mert a res.json() magától charset=utf-8 fejlécet küld. Ha mégis előfordul, akkor jellemzően res.set("Content-Type", "text/plain") volt kézzel beállítva, charset nélkül.

A mező eltűnik a válaszból

res.json({ nev: termek.nev, leiras: termek.leiras });   // ha a leiras undefined…

Ha a termek.leiras értéke undefined, a leiras kulcs egyáltalán nem jelenik meg a válaszban. Ha a kliensnek tudnia kell, hogy a mező létezik, de üres, írj oda null-t:

res.json({ nev: termek.nev, leiras: termek.leiras ?? null });

11Feladatok

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

res.json({
  id: 42,
  letrehozva: new Date("2026-03-01T10:00:00Z"),
  leiras: undefined,
  keszlet: 0,
  atlagErtekeles: 0 / 0
});

12Önellenőrző kvíz

13Összegzés

14Fogalomtár