A(z) Típusellenőrzés fogalomról
Gyakran nagyon fontos tudni, hogy egy adat milyen típusú, ha azt akarjuk, hogy a kód gördülékenyen és hibák nélkül fusson.
A JavaScriptben többféle módon is ellenőrizhetjük egy érték vagy objektum típusát.
A JavaScript típusellenőrző mechanizmusai némileg megbízhatatlanok lehetnek.
A jobb típusbiztonság és az erősebb típusok érdekében érdemes inkább a TypeScriptet használnod, amely a JavaScriptre épül, de egy statikusan típusos nyelv típusszintaxisát használja.
A typeof operátor
A typeof operátor az operandusa típusát adja vissza.
Az eredmény egy olyan string, amely megegyezik az egyik primitív adattípus nevével, kivéve a "null" esetét.
Emellett "function" vagy "object" is lehet.
typeof undefined;
// => "undefined"
typeof true;
// => "boolean"
typeof 42;
// => "number"
typeof 'Hello, World!';
// => "string"
typeof function () {
return 'Hello, World';
};
// => "function"
typeof [1, 2, 3, 4];
// => "object"
typeof { city: 'Stockholm', country: 'Sweden' };
// => "object"
Ez [történelmi okokból][typeof null is "object"] van így.
Az instanceof operátor
Egy objektum típusának ellenőrzéséhez az instanceof operátort használhatod.
Az eredmény egy boolean érték attól függően, hogy a második operandus benne van-e az első operandus prototípusláncában.
Pontosabban: az instanceof azt adja vissza, hogy az első operandus a második operandusnak vagy annak valamelyik leszármazott osztályának a példánya-e.
Az instanceof csak objektumokon működik.
class Beverage {
// ...
}
// The Coffee class is a child of the Beverage class.
class Coffee extends Beverage {
// ...
}
const java = new Coffee();
java instanceof Coffee;
// => true
java instanceof Beverage;
// => true
Az Array osztálynak van egy Array.isArray() nevű metódusa, amely ellenőrzi, hogy az argumentuma tömb-e.
Míg az instanceof Array nem működik egy másik realmben létrehozott tömbbel, például egy weboldal iframe-jében lévővel, addig az Array.isArray() igen.
Ennek az az oka, hogy az Array osztálynak minden realmben más a konstruktora, és minden iframe-nek saját realmje van, ami azt jelenti, hogy a prototípusláncban lévő függvény is más lesz, emiatt az instanceof Array hibára fut.
Az Array.isArray() képes ezt figyelmen kívül hagyni, és lehetőség szerint mindig ezt érdemes használni.
Arra is képes, hogy kiszűrje azokat a téves pozitívokat, amikor egy objektum valójában nem Array, csupán az Array szerepel a prototípusláncában.
({ __proto__: Array.prototype }) instanceof Array
// => true
Array.isArray({ __proto__: Array.prototype })
// => false
Az in operátor
Az in operátor azt adja vissza, hogy az első operandus tulajdonsága-e a második operandusnak.
Nem ellenőrzi, hogy a tulajdonságnak van-e definiált értéke.
Az undefined-ra állított tulajdonságot is észleli az in.
class Coffee {
constructor() {
this.temperature = 'hot';
this.isDarkMatter = undefined;
}
coolDown() {
this.temperature = 'warm';
}
}
const espresso = new Coffee();
'temperature' in espresso;
// => true
'color' in espresso;
// => false
'isDarkMatter' in espresso;
// => true
Az in true értéket ad vissza az örökölt tulajdonságokra és metódusokra is.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Ezt elkerülendő használd helyette az Object.hasOwn() metódust.
Az Object.hasOwn() függvény
Az Object.hasOwn() metódus azt adja vissza, hogy a megadott objektum saját tulajdonságaként tartalmazza-e az adott tulajdonságot (vagyis az nem örökölt, és nem metódus).
class Coffee {
constructor() {
this.temperature = 'hot';
}
coolDown() {
this.temperature = 'warm';
}
}
const cappuccino = new Coffee();
Object.hasOwn(cappucino, 'temperature');
// => true
Object.hasOwn(cappucino, 'constructor');
// => false
Object.hasOwn(cappucino, 'coolDown');
// => false
1 feladat
Tanuld meg a(z) Típusellenőrzés fogalmat