Bármilyen és ismeretlen típus a TypeScriptben

  • 5 perc

Vannak esetek, amikor olyan értékekkel kell dolgoznia, amelyek a kód fejlesztésekor ismeretlenek. Ezekben az esetekben a típusokat és unknown típusvédőket any használva szabályozhatja, hogy a kód milyen műveleteket hajthat végre az átadott értékekkel.

Bármilyen típus

A any típus az egyetlen típus, amely bármilyen JavaScript-értéket jelölhet megkötések nélkül. Ez a típus akkor lehet hasznos, ha egy harmadik féltől származó kódtárból vagy felhasználói bemenetből származó értéket vár, ahol az érték dinamikus, mert a any típus lehetővé teszi a különböző típusú értékek újbóli hozzárendelését. Ahogy korábban említettük, a any típus használatával fokozatosan migrálhatja a JavaScript-kódot, hogy statikus típusokat használjon a TypeScriptben.

Az alábbi példa egy típusváltozót any deklarál, és értékeket rendel hozzá:

let randomValue: any = 10;
randomValue = 'Mateo';   // OK
randomValue = true;      // OK

A példa fordítása nem okoz hibát, mert a any típus minden lehetséges típus értékeit magában foglalja. A any típus nem engedélyezi a típusellenőrzést, és nem kényszeríti arra, hogy az értékek tulajdonságainak meghívása, létrehozása vagy elérése előtt ne végezze el az ellenőrzést.

any A példában szereplő típus használatával meghívhatja a következőt:

  • Olyan tulajdonság, amely nem létezik a típushoz.
  • randomValue függvényként.
  • Olyan metódus, amely csak egy string típusra vonatkozik.

Mivel randomValue a rendszer regisztrálva anyvan, az alábbi példák mindegyike érvényes TypeScript-típus, és nem fog fordítási időt eredményezni. A futásidejű hibák azonban a változó tényleges adattípusától függően fordulhatnak elő. Az előző példában, ahol randomValue logikai értékre van állítva, a következő kódsorok problémákat okoznak futásidőben:

console.log(randomValue.name);  // Logs "undefined" to the console
randomValue();                  // Returns "randomValue is not a function" error
randomValue.toUpperCase();      // Returns "randomValue is not a function" error

Fontos

Ne feledje, hogy az összes kényelem any a típusbiztonság elvesztésének költségével jár. A TypeScript használatának egyik fő motivációja a típusbiztonság. Kerülje a használatot any , ha nincs rá szükség.

Ismeretlen típus

Bár rugalmas, a any típus váratlan hibákat okozhat. A probléma megoldásához a TypeScript bevezette a típust unknown .

A unknown típus hasonló ahhoz a any típushoz, amelyben bármely érték hozzárendelhető a típushoz unknown. Egy típus egyik tulajdonságához unknown sem férhet hozzá, és nem is hívhatja meg vagy hozhatja létre őket.

Ez a példa az any előző példában szereplő típust a következőre módosítja unknown: . Ez most típus-ellenőrzési hibákat okoz, és megakadályozza a kód összeállítását, amíg meg nem teszi a megfelelő lépéseket a megoldásukhoz.

let randomValue: unknown = 10;
randomValue = true;
randomValue = 'Mateo';

console.log(randomValue.name);  // Error: Object is of type unknown
randomValue();                  // Error: Object is of type unknown
randomValue.toUpperCase();      // Error: Object is of type unknown

Megjegyzés:

Az alapvető különbség any unknown az, hogy nem tud egy típusú unknownváltozóval kommunikálni, ezért fordítóhibát okoz. any átadja a fordítási idő ellenőrzését, és az objektum kiértékelése futásidőben történik; ha a metódus vagy tulajdonság létezik, az a várt módon fog viselkedni.

Típusmegjelenés

Ha egy változót más adattípusként kell kezelnie, használhat típusérvényesítést. A típusérvényesítés azt jelzi, hogy a TypeScript a utasítás meghívása előtt végrehajtotta a szükséges speciális ellenőrzéseket. Azt mondja a fordítónak, hogy "bízz bennem, tudom, mit csinálok." A típusmegbízatás olyan, mint egy más nyelveken leadott típus, de nem végez különleges ellenőrzést vagy adatátalakítást. Nincs futtatókörnyezeti hatása, és kizárólag a fordító használja.

A típusmegjelenések két űrlapot alkotnak. Az egyik a as-szintaxis:

(randomValue as string).toUpperCase();

A másik verzió a "szögletes zárójel" szintaxis:

(<string>randomValue).toUpperCase();

Megjegyzés:

as az előnyben részesített szintaxis. A TypeScript egyes alkalmazásai, például a JSX összezavarodhatnak a típuskonverziók használatakor < > .

Az alábbi példa elvégzi a szükséges ellenőrzést annak megállapításához, hogy randomValue a metódus meghívásához típusmegfelelőség használata előtt van-e string szükség.toUpperCase

let randomValue: unknown = 10;

randomValue = true;
randomValue = 'Mateo';

if (typeof randomValue === "string") {
    console.log((randomValue as string).toUpperCase());    //* Returns MATEO to the console.
} else {
    console.log("Error - A string was expected here.");    //* Returns an error message.
}

A TypeScript most azt feltételezi, hogy elvégezte a szükséges ellenőrzést. A típusmegjelenülés azt mondja, hogy randomValue a metódust string kezelni kell, majd a toUpperCase metódus alkalmazható.

Típusvédők

Az előző példa bemutatja, hogyan használható typeof a if blokk egy kifejezés futásidejű típusának vizsgálatára. Ezt a feltételes tesztet típusvédőnek nevezzük.

Előfordulhat, hogy a JavaScript használatával typeof és instanceof a javascript használatával teszteli ezeket a feltételeket. A TypeScript megérti ezeket a feltételeket, és ennek megfelelően módosítja a típuskövetőséget, ha egy if blokkban használják.

A változó típusának megismeréséhez a következő feltételek használhatók:

Típus Predikátum
string typeof s === "string"
number typeof n === "number"
boolean typeof b === "boolean"
undefined typeof undefined === "undefined"
function typeof f === "function"
array Array.isArray(a)