Bevezetés
Gyakran nagyon fontos tudni, hogy egy adat milyen típusú, hogy a kód gördülékenyen és hibák nélkül fusson.
A JavaScriptben többféleképpen is ellenőrizheted 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 valószínűleg a TypeScriptet érdemes használnod; ez egy olyan nyelv, amely a JavaScriptre épül, de egy statikusan típusos nyelv típusszintaxisával.
A typeof operátor
A typeof operátor visszaadja az operandusa típusát.
A kimenet egy 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"
[Történelmi okokból][typeof null is "object"].
Az instanceof operátor
Egy objektum típusának ellenőrzésére az instanceof operátort használhatod.
Az eredménye egy boolean érték attól függően, hogy a második operandus szerepel-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 azt ellenőrzi, hogy az argumentuma tömb-e.
Bár az instanceof Array nem működik egy másik realmben létrehozott tömbbel, például egy weboldal iframe-jével, az Array.isArray() igen.
Ez azért van, mert 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, és emiatt az instanceof Array nem fog működni.
Az Array.isArray() képes ezt figyelmen kívül hagyni, és lehetőség szerint mindig ezt érdemes használni.
Az olyan téves pozitívokat is kiszűri, 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 a második operandus tulajdonsága-e.
Nem ellenőrzi, hogy a tulajdonságnak van-e definiált értéke.
Egy undefined értékre állított tulajdonságot az in így is észlel.
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-t ad vissza az örökölt tulajdonságokra és metódusokra is.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Ennek elkerülésére használd inkább az Object.hasOwn() függvényt
Az Object.hasOwn() függvény
Az Object.hasOwn() metódus azt adja vissza, hogy a megadott objektum rendelkezik-e a megadott tulajdonsággal (azaz a tulajdonság 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
Utasítások
Utasítások
Egy újrahasznosító központ vett fel téged dolgozni.
A hely szűke miatt minden termék ugyanarra a futószalagra kerül, ez viszont odavezetett, hogy a különböző anyagok összekeveredtek, és használhatatlanná váltak.
Hogy ezt helyrehozd, az a feladatod, hogy függvényeket írj, amelyek megállapítják egy termék típusát.
1. Ellenőrizd, hogy egy érték boolean-e
Valósítsd meg az isBoolean függvényt, amely ellenőrzi, hogy egy érték boolean-e.
isBoolean(true);
// => true
isBoolean(null);
// => false
2. Ellenőrizd, hogy egy érték szám-e
Valósítsd meg az isNumber függvényt, amely ellenőrzi, hogy egy érték véges number vagy bigint, azaz nem NaN és nem Infinity.
Néha előfordul, hogy az azonosítók beolvasására szolgáló eszköz hibázik, és egy nem numerikus értéket NaN-ként (Not a Number) vagy Infinity-ként olvas be.
A függvényednek ezt is helyesen kell kezelnie.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Ellenőrizd, hogy egy érték objektum-e
Valósítsd meg az isObject függvényt, amelynek ellenőriznie kell, hogy az érték objektum-e.
A futószalagon a null a semmit jelenti, és nem számít objektumnak.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Ellenőrizd, hogy egy string numerikus-e
Valósítsd meg az isNumericString függvényt, amelynek ellenőriznie kell, hogy az érték olyan string-e, amely csak számjegyekből áll, vagy egy mínuszjelből, amelyet számjegyek követnek, és negatív számot jelöl.
Csak az egész számokat vesszük figyelembe, a tizedes törteket az újrahasznosító robot ez az ellenőrzése nem tekinti numerikusnak.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Ellenőrizd, hogy egy objektum elektronikus-e
Valósítsd meg az isElectronic függvényt, amely ellenőrzi, hogy egy objektum a megadott ElectronicDevice osztály vagy annak valamelyik gyermekosztálya példánya-e.
class Duck {
//...
}
class WashingMachine extends ElectronicDevice {
//...
}
isElectronic(new Duck());
// => false
isElectronic(new WashingMachine());
// => true
6. Ellenőrizd, hogy egy érték nem üres tömb-e
Valósítsd meg az isNonEmptyArray függvényt, amely ellenőrzi, hogy egy érték nem üres tömb-e.
isNonEmptyArray([1, 2, 3]);
// => true
isNonEmptyArray([]);
// => false
7. Ellenőrizd, hogy egy érték üres tömb-e
Valósítsd meg az isEmptyArray függvényt, amely ellenőrzi, hogy egy érték üres tömb-e.
isEmptyArray([1, 2, 3]);
// => false
isEmptyArray([]);
// => true
8. Ellenőrizd, hogy egy objektumnak van type tulajdonsága vagy metódusa
Valósítsd meg a hasType függvényt, amely ellenőrzi, hogy egy objektumnak van-e type tulajdonsága vagy metódusa.
class Keyboard(){
type(){
// ...
}
}
hasType({ type:"car", color:"red" })
// => true
hasType({ color:"green" })
// => false
hasType(new Keyboard())
// => true
9. Dobj hibát, ha egy objektumnak nincs id tulajdonsága vagy metódusa
Valósítsd meg az assertHasId függvényt, amely Error-t dob, ha egy objektumból hiányzik az id tulajdonság.
Ha egy objektumnak van id tulajdonsága, akkor nem szabad semmit visszaadnia.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Ellenőrizd, hogy egy objektumnak van id tulajdonsága
Valósítsd meg a hasIdProperty függvényt, amely ellenőrzi, hogy egy objektumnak van-e id tulajdonsága.
class SimpleData {
constructor() {
this.number = '42';
this.id = 'BC269327FE1D9B95';
}
}
class StealingData extends SimpleData {}
class MethodData {
constructor() {
this.number = '42';
this._id = 'BC269327FE1D9B95';
}
get id() {
return this._id;
}
}
hasIdProperty(new SimpleData());
// => true
hasIdProperty(new MethodData());
// => false
hasIdProperty(new StealingData());
// => false
11. Ellenőrizd, hogy egy objektumnak van definiált type tulajdonsága
Valósítsd meg a hasDefinedType függvényt, amely ellenőrzi, hogy egy objektumnak van-e olyan type tulajdonsága, amely nem undefined.
hasDefinedType({ type: undefined, color: 'red' });
// => false
hasDefinedType({ type: 'car', color: 'green' });
// => true
Tanulófeladat
