Modulok és záró feladatsor

1Miért daraboljuk fájlokra?

Egy 300 soros fájlban még elboldogulsz. Egy 3000 sorosban már nem találod, hol van a kosár összegzése, és ha két ember dolgozik rajta, folyton egymás sorait írják felül. A megoldás: egy fájl = egy jól körülhatárolt felelősség.

• Áttekinthetőség: a kosar.js-ben csak kosár-logika van; a fájlnév maga a dokumentáció.
• Újrafelhasználás: a penz.js formázóját a kosár, a rendelés és a jelentés is importálja — egyszer írtad meg.
• Elszigetelés: a modul belső változói kívülről nem látszanak, nem ütköznek más fájl neveivel — nincs véletlen felülírás.
• Tesztelhetőség: egy kis modult külön lehet kipróbálni, anélkül hogy az egész programot elindítanád.

Az ehhez szükséges nyelvi eszköz az ES-modul (ESM): két kulcsszó, export és import. Node-ban minden fájl külön modul; a modulok egymást fájlútvonallal hivatkozzák.

2export — named és default

Egy modulból alapból semmi nem látszik kifelé. Amit más fájlnak is használnia kell, azt export-tal jelölöd meg. Két fajtája van.

Named export — névvel, akárhány

// keszlet.js
export const AFA = 1.27;                        // a deklaráció elé írva…

export function keszletErtek(lista) {
  return lista.reduce((s, t) => s + t.ar * t.keszlet, 0);
}

function kifogyottak(lista) {
  return lista.filter(t => t.keszlet === 0).map(t => t.nev);
}
function segedSzamitas() { /* belső, nem exportáljuk */ }

export { kifogyottak };                           // …vagy a fájl végén, listában

Default export — egy fő dolog, név nélkül

// penz.js
export default function formazFt(osszeg) {
  return `${osszeg} Ft`;
}

// vagy egy osztály:
// export default class Kosar { ... }

A kettő keverhető is egy fájlban (egy default + több named), de a projektek többsége az egyszerűség kedvéért inkább csak named exportot használ. A lényeg: csak azt exportáld, ami kifelé kell — a többi marad a modul belügye.

3import, útvonalak és a modul hatóköre

Az import a fájl tetején áll, és megmondja, mit honnan kérsz. A négy alak:

// index.js
import { keszletErtek, kifogyottak } from "./keszlet.js";   // named: kapcsos zárójel, pontos nevek
import { AFA as afaSzorzo } from "./keszlet.js";           // alias: átnevezés as-szel
import formazFt from "./penz.js";                        // default: nincs { }, a név szabad
import * as keszlet from "./keszlet.js";                 // minden named export egy objektumba

console.log(keszlet.keszletErtek(termekek));             // a * as-nél pont-jelöléssel

A modul hatóköre

Minden modulnak saját hatóköre van: a benne deklarált const/let/function csak ott létezik, akkor is, ha nem exportálod — két fájlban nyugodtan lehet ugyanaz a termekek változó. Csak az importált nevek jönnek át, és azok csak olvashatók: az importált változónak nem adhatsz új értéket (az objektum tartalmát viszont módosíthatod). A modul kódja egyszer fut le, akárhány fájl importálja — ezért egy modulban tartott const tetelek = [] az egész program közös állapota lehet.

4CommonJS: require és module.exports

Az ES-modul 2015-ös; Node előtte már saját modulrendszert használt, a CommonJS-t (CJS). Rengeteg régi kód, példa és dokumentáció ebben íródott, ezért fel kell ismerned — írni már ESM-ben fogsz:

// keszlet.js
function keszletErtek(lista) { /* … */ }

module.exports = { keszletErtek };

// index.js
const { keszletErtek } = require("./keszlet.js");
const fs = require("fs");

// keszlet.js
export function keszletErtek(lista) { /* … */ }



// index.js
import { keszletErtek } from "./keszlet.js";
import fs from "fs";

A "type": "module" egyetlen sor a projekt package.json fájljában, amitől Node az összes .js fájlt ES-modulként olvassa. A package.json-t és az npm-et a Node-kurzus első órája részletezi — most annyit jegyezz meg, hogy ez a sor kell, vagy a .mjs kiterjesztés.

5Egy kis webshop-projekt fájlszerkezete

Így néz ki a kurzus végigfutó példája három modulra bontva. Az adat, a logika és a „főprogram" külön fájl:

$ ls
index.js   kosar.js   termekek.js   package.json      ← benne: { "type": "module" }

// ---------- termekek.js — az adat és a hozzá tartozó kis segédek ----------
export const termekek = [
  { nev: "Egér", ar: 6990, keszlet: 3 },
  { nev: "Kábel", ar: 1990, keszlet: 0 },
  { nev: "Monitor", ar: 54990, keszlet: 2 }
];

export function keres(nev) {
  return termekek.find(t => t.nev === nev);
}

// ---------- kosar.js — egy osztály, default exportként ----------
import { keres } from "./termekek.js";

export default class Kosar {
  #tetelek = [];

  hozzaad(nev, db = 1) {
    const termek = keres(nev);
    if (!termek) throw new Error(`Nincs ilyen termék: ${nev}`);
    if (termek.keszlet < db) throw new Error(`Nincs elég készlet: ${nev}`);
    this.#tetelek.push({ nev, ar: termek.ar, db });
  }
  osszeg() {
    return this.#tetelek.reduce((s, t) => s + t.ar * t.db, 0);
  }
}

// ---------- index.js — a belépési pont: összerakja a részeket ----------
import Kosar from "./kosar.js";
import { termekek } from "./termekek.js";

const kosar = new Kosar();
kosar.hozzaad("Egér", 2);
try {
  kosar.hozzaad("Kábel");
} catch (e) {
  console.error("Nem került a kosárba:", e.message);
}
console.log(`${termekek.length} termék, kosár: ${kosar.osszeg()} Ft`);

$ node index.js
Nem került a kosárba: Nincs elég készlet: Kábel
3 termék, kosár: 13980 Ft

Figyeld meg az irányt: az index.js importál a kosar.js-ből, az a termekek.js-ből — a „mélyebb" modul nem tud a felette lévőkről. Ez a rétegzés teszi a részeket külön-külön érthetővé és cserélhetővé.

6Hogyan gyakorold a modulokat?

Az itteni böngészős gyakorló egyetlen kódrészletet futtat, fájlok nélkül — import-ot és export-ot ezért nem tud végrehajtani (az élő kód chipjei egy objektummal szimulálják a modult, hogy a gondolat kipróbálható legyen). A modulos feladatok ezért kéziek: a saját gépeden oldod meg őket.

1. Hozz létre egy mappát, benne egy package.json fájlt ezzel a tartalommal: { "type": "module" }.
2. VS Code-ban írd meg a fájlokat (termekek.js, keszlet.js, index.js).
3. A terminálban a mappából: node index.js. Ha „Cannot find module"-t kapsz: hiányzik a ./ vagy a .js.

Ha nincs kéznél Node, a RunKit (runkit.com) böngészőben futtat Node-kódot — de az igazi tanulás a saját gépen történik, mert a Node-kurzuson is ott dolgozol majd.

7A záró feladatsor

A fejezet feladatai az egész kurzust összefoglalják egy webshop-készletkezelőn. Nincs új nyelvi elem — az a kérdés, hogy a tanultakat együtt tudod-e használni: destrukturálás egy reduce-ban, saját hiba egy osztály metódusában, többsoros szöveg map + join-nal. Három csoportra oszlanak:

A függvényes feladatok többsége ugyanazt a közös terméklistát kapja (név, ár, készlet, kategória). Ha elakadsz, a Tipp gomb a megfelelő fejezet eszközét nevezi meg — érdemes előbb visszalapozni, és csak utána a Megoldást megnézni.

8Élő kód — próbáld ki!

Az első két chip a modul gondolatát szimulálja (egy objektum mint „exportált felület", egy függvény-hatókör mint „modul-hatókör"); a többi a záró feladatsor építőköveit mutatja: reduce-os összegzés és csoportosítás, osztály Map-pel, validálás saját hibával, többsoros jelentés.

9Feladatok

Az első három feladat kézi: itt nincs ellenőrzés, a saját gépeden oldod meg, és ha lefutott, a Megoldottam gombbal pipálod ki. A többi a megszokott módon megy: függvényt (a 14.12-nél osztályt) írsz, az ellenőrző több bemenettel hívja, és a visszatérési értéket — vagy a dobott hiba üzenetét — hasonlítja a várttal. Figyelj a pontos formátumokra: ábécérend localeCompare-rel, egészre kerekítés, karakterre egyező szövegek.

10Összegzés — az egész kurzus egy oldalon