Interface-Typ-Prüfung in TypeScript

1. Typprüfungen in TypeScript
2. Verwendung von typeof zur Überprüfung von Typen in TypeScript
3. Verwendung von instanceof in TypeScript
4. Verwendung des in-Schlüsselworts zur Überprüfung von Typen in TypeScript

Schnittstellen sind ein wichtiger Bestandteil von TypeScript, um Typen Variablen und Elementen in TypeScript zuzuordnen, um Typsicherheit zu gewährleisten und somit Laufzeitfehler zu vermeiden. Klassen und andere Interfaces können Interfaces implementieren, und somit kann dies für dynamisches Verhalten im eigentlichen Code verwendet werden.

Daher kann es manchmal erforderlich sein, den tatsächlichen Schnittstellentyp zu kennen, um die Typsicherheit zu gewährleisten, genau wie das Schlüsselwort instanceof in Java. In diesem Tutorial wird gezeigt, wie die Typen von Schnittstellen überprüft werden können, um die Typsicherheit zu gewährleisten.

Typprüfungen in TypeScript

Ein Typwächter ist eine Überprüfung der verschiedenen in TypeScript vorhandenen Typen, um die Typsicherheit zu gewährleisten. Es ist in Form von bedingten Anweisungen.

Es wird insbesondere benötigt, wenn ein bestimmter Typ eine Zusammensetzung aus einem oder mehreren Typen ist. Es stehen verschiedene Schlüsselwörter zur Verfügung, mit denen Schnittstellen überprüft werden können, wie z. B. typeof, instanceof, in, und man kann sogar benutzerdefinierte Type Guards erstellen.

interface Animal {
    name : string;
    legs : number;
    eyes : number;
}

interface Dog extends Animal {
    bark : () => void
}

interface Cat extends Animal {
    meow : () => void;
}

function getAnimal() : Dog | Cat {
    let choice = Math.random();
    if ( choice > 0.5){
        const dog : Dog = {
            name : 'Labrador',
            legs : 4,
            eyes : 2,
            bark : () => console.log("Woof")
        }
        return dog;
    }else {
        const cat : Cat = {
            name : 'Labrador',
            legs : 4,
            eyes : 2,
            meow : () => console.log("Meow")
        }
        return cat;
    }
}

const animal = getAnimal();
// Property 'meow' does not exist on type 'Dog | Cat'.
animal.meow();
// Property 'bark' does not exist on type 'Dog | Cat'.
animal.bark();

Im obigen Beispiel können die Funktionen meow oder bark nicht aufgelöst werden, da der TypeScript-Compiler nicht sicher ist, was er ableiten soll. Die Funktion getAnimal gibt eine Vereinigung von zwei Typen zurück, Dog | Cat, was den Compiler verwirrt.

Typwächter oder Typprüfungen müssen eingeführt werden, damit der Compiler den entsprechenden Typ versteht.

if ( 'meow' in animal){
    animal.meow();
} else if ( 'bark' in animal){
    animal.bark();
}

Das Obige ist ein Beispiel dafür, wie Typprüfungen durchgesetzt werden können, um die Typsicherheit zu gewährleisten. Die Attribute meow und bell werden auf Vorhandensein im Objekt animal geprüft und entsprechend aufgerufen.

Verwendung von typeof zur Überprüfung von Typen in TypeScript

Das Schlüsselwort typeof kann verwendet werden, um die Typen von Variablen zu bestimmen; es hat jedoch einen sehr begrenzten Anwendungsbereich. Es kann zum Überprüfen primitiver Typen verwendet werden.

Die vom Schlüsselwort typeof zurückgegebenen Werte können string, number, bigint, boolean, symbol, undefined, object oder function sein.

Das Schlüsselwort typeof gibt alle komplexen Typen und null-Werte als Objekt zurück.

const displayBill = ( amount : string | number ) => {
    if ( typeof amount === 'string') {
        amount = Number(amount);
    }
    let tax = (18.5 * amount) / 100;
    console.log('Bill : '+ amount + " $");
    console.log('Tax : '+ tax + " $");
    console.log('Total Payable : '+ (amount + tax) + " $");

}

displayBill(23.5);

Ausgabe:

"String conversion being done!"
"Bill : 23.5 $"
"Tax : 4.3475 $"
"Total Payable : 27.8475 $"

So wurde im obigen Beispiel das Schlüsselwort typeof verwendet, um den Typ der Variablen amount zu prüfen, und die Konvertierung wurde nach der Prüfung durchgeführt. Diese Prüfung ist für die Berechnung der Variable Steuer notwendig, wofür der amount vom Typ number sein muss.

Verwendung von instanceof in TypeScript

Das Schlüsselwort instanceof sucht nach Variablen, die einigen Klassen entsprechen. Der folgende Typwächter wird für jene Variablen verwendet, die als Klassenobjekte instanziiert werden.

class User {
    name : string;
    amountDue : number;
    constructor( name : string, amount : number){
        this.name = name;
        this.amountDue = amount;
    }
}

class UserCredit extends User {
    constructor( user : User) {
        super(user.name, user.amountDue);
    }
    generateCredit(amount : number) {
        this.amountDue += amount;
        return this.amountDue;
    }
}

class UserDebit extends User {
    constructor( user : User) {
        super(user.name, user.amountDue);
    }
    settleDebt(){
        this.amountDue = 0;
    }
}

const TransactionSystem = () => {
    const user : User = {
        name : 'Alex',
        amountDue : 0
    }
    const option = Math.random();
    if ( option > 0.5) {
        // settle debts
        const userDebt = new UserDebit(user);
        userDebt.settleDebt();
        return userDebt;
    } else {
        // increase credit
        const userCredit = new UserCredit(user);
        userCredit.generateCredit(500);
        return userCredit;
    }
}

const UserTransaction = TransactionSystem();
if ( UserTransaction instanceof UserDebit) {
    console.log('Credit balance successfully debited');
} else if (UserTransaction instanceof UserCredit) {
    console.log("Credit limit increased")
}

Verwendung des in-Schlüsselworts zur Überprüfung von Typen in TypeScript

Das in kann verwendet werden, um zu prüfen, ob ein bestimmtes Attribut in einem Typ oder einer Schnittstelle vorhanden ist, und kann daher mit einer bedingten Anweisung wie if-else verwendet werden, um nach Typen zu suchen und so weitere Aktionen auszuführen und auszuführen. Das folgende Beispiel zeigt, wie dies erreicht werden kann.

interface Person {
    name : string;
    age : number;
}
const person : Person = {
    name : "Alex",
    age : 30
}
console.log("name" in person); // true
console.log("address" in person); // false