Hogyan kezelhetjük a paramétereket és argumentumokat JavaScriptben?

A JavaScriptben az argumentumok és paraméterek kezelése alapvető szerepet játszik a funkciók működésében, és az ES2015 (más néven ES6) szabvány bevezetése új lehetőségeket kínált ezzel kapcsolatban. Az új funkciók, mint a "rest" (maradék) és az alapértelmezett paraméterek, jelentős mértékben leegyszerűsítették a kódot, és lehetővé tették a hatékonyabb programozást.

A régebbi JavaScript verziókban a paraméterek és argumentumok kezelésére különféle trükköket kellett alkalmazni, de az ES6 lehetőséget biztosít arra, hogy egyszerűbben és érthetőbben dolgozhassunk velük. A "rest" paraméterek és az alapértelmezett paraméterek mind új megoldásokat kínálnak erre.

Rest paraméterek

A "rest" paraméterek (azaz maradék paraméterek) lehetővé teszik számunkra, hogy a függvényekhez több argumentumot rendeljünk, anélkül hogy külön paramétereket kellene hozzájuk rendelni. Az új verziókban a maradék paraméterekhez az ellipszis (...) szimbólumot használjuk, ami egy tömbbe gyűjti a maradék argumentumokat. Az alábbi példában egy egyszerű függvényt készítünk, amely megszorozza az első paramétert a többi paraméter közül a legnagyobbal.

javascript
Copy code
function multiMax(first, ...remainingNumbers) {

   const sorted = remainingNumbers.sort((a, b) => b - a);
   return first * sorted[0];
}

Fontos megjegyezni, hogy csak az utolsó paraméter lehet maradék paraméter, és ha próbálunk nem az utolsó paraméter előtt ellipszist használni, akkor szintaktikai hibát kapunk.

Alapértelmezett paraméterek

A másik új lehetőség az alapértelmezett paraméterek használata, amelyek egyszerűsítik a kódot, amikor az argumentumok hiányoznak. Az alapértelmezett értékek akkor kerülnek alkalmazásra, ha egy paraméter értéke nincs megadva a függvényhívásban. Ez a funkcionalitás különösen hasznos akkor, ha a felhasználó számára kényelmes és rugalmas alapértelmezett viselkedést szeretnénk biztosítani.

Például egy egyszerű performAction függvény esetén, ha az action paraméter nincs megadva, az alapértelmezett értéke a "skulking" lesz:

javascript
Copy code
function performAction(ninja, action = "skulking") {

   return ninja + " " + action;
}

Ebben az esetben, ha az action argumentum nem szerepel a hívásban, akkor a "skulking" értéket fogja használni a program. Ha megadjuk az értéket, az alapértelmezett viselkedés felülíródik:

javascript
Copy code
console.assert(performAction("Fuma") === "Fuma skulking", "The default value is used for Fuma");
console.assert(performAction("Yagyu", "sneaking") === "Yagyu sneaking", "Yagyu can do whatever he pleases, even sneak!");

Fontos megjegyezni, hogy az alapértelmezett értékek a balról jobbra értékelődés szabálya szerint működnek, így egy paraméter alapértelmezett értéke az előző paraméterek értékeitól függhet. Azonban ezt a megoldást óvatosan kell alkalmazni, mivel túlzott használat esetén csökkentheti a kód olvashatóságát.

Az alapértelmezett paraméterek segítenek elkerülni a null vagy undefined értékeket, és egyszerűsíthetik a különféle beállításokat, amelyek befolyásolják a funkciók működését. A modera használatuk egyszerűbbé és elegánsabbá teheti a kódot.

Hogyan kezelhetjük a JavaScript típusokat és javíthatjuk a kód teljesítményét?

A JavaScript világában gyakran találkozunk olyan eredményekkel, amelyek első ránézésre ellentmondásosnak tűnhetnek. Például, ha egy üres tömböt és egy üres objektumot összeadunk, az eredmény egy "[object Object]" string lesz, míg egy üres tömb és egy üres string összeadásakor üres stringet kapunk! Ahhoz, hogy JavaScript ninja legyél, nem szükséges az összes típuskonverziós szabályt kívülről tudnod, hanem inkább azt kell tudnod, hogyan kerülheted el őket. Az ilyen váratlan típusok gyakran okoznak hibákat a JavaScript kódban, és bárki, aki már látta az "undefined" szót egy weboldalon, tanúsíthatja, hogy meglehetősen frusztrálóak.

typescript
Copy code
const addOne = (x: number) => x + 1;    
addOne("10");

A TypeScript népszerűsége az elmúlt években ugrásszerűen megnövekedett. A 2023-as JavaScript állapotfelmérés (https://2023.stateofjs.com) szerint a fejlesztők több időt töltenek TypeScript kód írásával, mint JavaScript-tel. Minél népszerűbbé vált a TypeScript, annál inkább előnyös lett annak használata, mivel egyre több nyílt forrású könyvtár biztosít beépített típusinformációkat. A következő fejezetekben megmutatjuk, hogyan használhatod a TypeScript-et.

Egy egyszerű linter szabály, amely segíthet a hibák elkerülésében, az "no-shadow" szabály, amely megakadályozza, hogy ugyanazt a változónevet használjuk egy olyan változó deklarálásakor, amely már létezik a külső scope-ban. Egy hiba például így nézne ki:

javascript
Copy code
let username = "Zork";
function logInAs(username) {
  username = username;
}
logInAs("Grue");

A linterekhez hasonló eszköz a kódformázó, amely javítja a kód olvashatóságát azáltal, hogy a hosszú kódsorokat több sorra tördel, és egységes behúzási szabályokat alkalmaz. A legnépszerűbb kódformázó a Prettier (https://prettier.io), amely hatalmas időmegtakarítást jelent a fejlesztők számára. Ahelyett, hogy időt töltenél a kód kézi formázásával, vagy, ami még rosszabb, vitatkozva a kollégákkal a formázás mikéntjéről, a Prettier azonnal elvégzi a munkát. A következő fejezetekben bemutatjuk, hogyan használhatók az ESLint és Prettier.

A típusellenőrzés és a kódformázás rengeteg hibát kiszűrhet, de nem helyettesítik a tényleges kód futtatását. A tesztelési keretrendszerek segítenek annak biztosításában, hogy a kód úgy viselkedjen, ahogyan elvárnánk. A legfontosabb tesztek, amelyeket egy alkalmazásnak tartalmaznia kell, az egység tesztek és az end-to-end tesztek. Az egység teszt a kód viselkedését teszteli elszigetelten, míg az end-to-end teszt a rendszeren belüli interakciókat is figyelembe veszi, így segítve a valódi környezetekben felmerülő problémák felderítését.

A JavaScript fejlesztők számára a legnagyobb kihívások között nemcsak a kódolás, hanem az alkalmazások teljesítménye is szerepel. Bár a JavaScript motorok idővel egyre gyorsabbak lettek, a JavaScript alapú weboldalak gyakran lassabbak, mint korábban. A lassú weboldalak negatívan befolyásolják a felhasználói élményt és a vállalatok bevételeit, hiszen a lassú oldalak hátrébb kerülnek a keresőmotorok rangsorában, és a felhasználók türelmetlenek lesznek, ha az oldal betöltése több másodpercet vesz igénybe.

A teljesítmény optimalizálása érdekében elengedhetetlen a kód bloat csökkentése, amely akkor keletkezik, ha túl sok JavaScript kódot küldünk a böngészőbe. A kód bloat problémája abban rejlik, hogy a fejlesztők hajlamosak a könnyebb megoldásokat választani, például külső könyvtárak hozzáadását, ahelyett hogy maguk írnák meg a szükséges kódot. Az ilyen gyakorlatok túlzott kódot generálhatnak, ami csökkenti az alkalmazás teljesítményét.