Általános típusú metódusok és tulajdonságok használata
Amikor típusváltozókat használ az általános összetevők létrehozásához, csak az összes típushoz elérhető objektumok tulajdonságait és metódusait használhatja. Ez megakadályozza, hogy hibák lépjenek fel, amikor olyan paraméterértéken próbál műveletet végrehajtani, amely nem kompatibilis a neki átadott típussal.
Ha hozzáadja az utasítást let result: T = value + value
a függvényhez, a identity
TypeScript hibát jelez . Az aritmetikai művelet bal oldalán "any", "number", "bigint" vagy enum típusúnak kell lennie, mert nem tudja, hogy futásidőben milyen értéket ad át. Ha nem numerikus értéket adna át, a kifejezés hibát okozna, ezért a TypeScript a fordításkor tudatja a problémával.
function identity<T, U> (value: T, message: U) : T {
let result: T = value + value; // Error
console.log(message);
return result
}
Általános korlátozások használata a típusok korlátozásához
A identity
függvény bármilyen típust elfogadhat, amelyet át szeretne adni a típusváltozóknak. Ebben az esetben azonban korlátoznia kell azokat a típusokat, amelyeket a value
paraméter elfogadhat egy olyan típustartományban, amelyen bármilyen lehetséges típus elfogadása helyett hozzáadhat műveletet. Ezt általános kényszernek nevezzük.
Ezt többféleképpen is megteheti a típusváltozótól függően. Az egyik módszer az egyéni type
típus deklarálása rekordként, majd extend
a típusváltozó az egyéni típussal. Az alábbi példa egy és number
egy rekordot string
tartalmazó rekordként deklarálValidTypes
. Ezután az új típussal bővül T
. Most már csak a típusváltozónak adhat át number
vagy string
típusok.
type ValidTypes = string | number;
function identity<T extends ValidTypes, U> (value: T, message: U) : T {
let result: T = value + value; // Error
console.log(message);
return result
}
let returnNumber = identity<number, string>(100, 'Hello!'); // OK
let returnString = identity<string, string>('100', 'Hola!'); // OK
let returnBoolean = identity<boolean, string>(true, 'Bonjour!'); // Error: Type 'boolean' does not satisfy the constraint 'ValidTypes'.
A típust egy másik objektum tulajdonságához is korlátozhatja. Ez a példa az keyof
operátort használjaextends
, amely egy objektumtípust használ, és a kulcsok sztring- vagy numerikus literális egyesítését hozza létre. Itt gondoskodjon arról, K extends keyof T
hogy a kulcsparaméter a megfelelő típusú legyen a hozzárendelt típushoz pet
.
function getPets<T, K extends keyof T>(pet: T, key: K) {
return pet[key];
}
let pets1 = { cats: 4, dogs: 3, parrots: 1, fish: 6 };
let pets2 = { 1: "cats", 2: "dogs", 3: "parrots", 4: "fish"}
console.log(getPets(pets1, "fish")); // Returns 6
console.log(getPets(pets2, "3")); // Error
A modul későbbi részében többet is megtudhat az általános korlátozások osztályokkal való használatáról.
Típusvédők használata általános eszközökkel
Megfigyelheti, hogy a TypeScript továbbra is problémát jelent a value + value
függvényben lévő identity
kifejezéssel kapcsolatban. Most azonban már tudja, hogy csak number
és string
típusok továbbíthatók a függvénynek.
typeof
A blokk típusőrével if
ellenőrizheti a paraméter típusát a value
művelet végrehajtása előtt, ahogyan az az alábbi példában látható. A TypeScript az if
utasításból meghatározhatja, hogy a művelet működik-e a blokkban megadott értékekkel.
type ValidTypes = string | number;
function identity<T extends ValidTypes, U> (value: T, message: U) { // Return type is inferred
let result: ValidTypes = '';
let typeValue: string = typeof value;
if (typeof value === 'number') { // Is it a number?
result = value + value; // OK
} else if (typeof value === 'string') { // Is it a string?
result = value + value; // OK
}
console.log(`The message is ${message} and the function returns a ${typeValue} value of ${result}`);
return result
}
let numberValue = identity<number, string>(100, 'Hello');
let stringValue = identity<string, string>('100', 'Hello');
console.log(numberValue); // Returns 200
console.log(stringValue); // Returns 100100
Megjegyzés:
A primitív , function
object
bigint
symbol
number
boolean
és nem definiált típusokat string
csak típusőrrel typeof
ellenőrizheti. Az osztály típusának ellenőrzéséhez használjon típusvédőt instanceof
.