Előző

Következő

Általános típusú metódusok és tulajdonságok használata

Befejeződött

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 numberegy 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 Thogy 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 , functionobjectbigintsymbolnumberbooleanés nem definiált típusokat stringcsak típusőrrel typeof ellenőrizheti. Az osztály típusának ellenőrzéséhez használjon típusvédőt instanceof .

Folytatás