TypeScript - Typengewähr: Ein Leitfaden für Anfänger

Hallo da draußen, zukünftiger Codingsuperstar! ? Ich freue mich sehr, dein Guide auf dieser aufregenden Reise in die Welt von TypeScript und Typengewährungen zu sein. Als jemand, der seit vielen Jahren Informatik unterrichtet, kann ich dir sagen, dass das Verständnis von Typengewährungen wie eine Superkraft im TypeScript-Universum ist. Also tauchen wir ein und entsperren wir diese Kraft gemeinsam!

Was sind Typengewährungen?

Bevor wir uns den Details zuwenden, lassen Sie uns verstehen, was Typengewährungen sind. Stell dir vor, du bist ein Security-Mitarbeiter auf einer schicken Party. Deine Aufgabe ist es, die Einladungen jedes Gastes zu überprüfen und sicherzustellen, dass sie in den richtigen Bereichen erlaubt sind. Typengewährungen in TypeScript erledigen eine ähnliche Aufgabe - sie helfen dem Compiler, den Typ einer Variablen in einem bestimmten Codeblock zu überprüfen und zu eingrenzen.

Nun, lassen Sie uns die drei Hauptarten von Gewährungen, die wir heute lernen werden, erkunden:

Typengewähr	Beschreibung
typeof	Überprüft den Typ einer Variablen
in	Überprüft, ob eine Eigenschaft in einem Objekt existiert
instanceof	Überprüft, ob ein Objekt eine Instanz einer Klasse ist

Die 'typeof' Typengewähr in TypeScript

Die 'typeof' Typengewähr ist so, als würde man fragen: "Was für ein Ding bist du?" Es wird verwendet, um den Typ einer Variablen zu überprüfen. Sehen wir uns ein Beispiel an:

function printAll(strs: string | string[] | null) {
if (typeof strs === "object") {
for (const s of strs) {
console.log(s);
}
} else if (typeof strs === "string") {
console.log(strs);
} else {
// tue nichts
}
}

In diesem Beispiel verwenden wir typeof, um zu überprüfen, ob strs ein Objekt (das auch Arrays umfasst) oder eine Zeichenkette ist. Wenn es ein Objekt ist, durchlaufen wir es. Wenn es eine Zeichenkette ist, geben wir sie direkt aus.

Hier ist eine spaßige Methode, um es sich zu merken: Stell dir vor, du bist in einem Tierladen und möchtest wissen, ob ein Tier ein Hund oder eine Katze ist. Du könntest fragen: "Was für ein Tier bist du?" Das ist genau, was typeof in TypeScript macht!

Die 'in' Typengewähr in TypeScript

Die 'in' Typengewähr ist so, als würde man fragen: "Hast du diese Eigenschaft?" Sie überprüft, ob eine Eigenschaft in einem Objekt existiert. Sehen wir uns ein Beispiel an:

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
if ("swim" in animal) {
animal.swim();
} else {
animal.fly();
}
}

In diesem Code überprüfen wir, ob das animal eine swim Eigenschaft hat. Wenn ja, gehen wir davon aus, dass es ein Fish ist und rufen die swim Methode auf. Wenn nicht, gehen wir davon aus, dass es ein Bird ist und rufen die fly Methode auf.

Denke daran so: Wenn du versuchst herauszufinden, ob dein neues Haustier ein Fisch oder ein Vogel ist, könntest du überprüfen, ob es Flossen hat. Das ist, was die 'in' Typengewähr macht - sie überprüft eine charakteristische Eigenschaft.

Die 'instanceof' Typengewähr in TypeScript

Die 'instanceof' Typengewähr ist so, als würde man fragen: "Bist du ein Mitglied dieser Familie?" Sie überprüft, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Hier ist ein Beispiel:

class Bird {
fly() {
console.log("Fliegend...");
}
}

class Fish {
swim() {
console.log("Schwimmend...");
}
}

function move(pet: Bird | Fish) {
if (pet instanceof Bird) {
pet.fly();
} else {
pet.swim();
}
}

let myBird = new Bird();
move(myBird); // Ausgabe: Fliegend...

In diesem Beispiel überprüfen wir, ob pet eine Instanz der Bird Klasse ist. Wenn ja, rufen wir die fly Methode auf. Wenn nicht, gehen wir davon aus, dass es ein Fish ist und rufen die swim Methode auf.

Stell dir vor, du bist auf einer Familientreffen und versuchst herauszufinden, ob jemand zur Johnson-Familie gehört. Du könntest fragen: "Bist du ein Johnson?" Das ist genau, was instanceof in TypeScript macht!

Alles zusammenbringen

Nun, da wir diese drei Typengewährungen gelernt haben, sehen wir, wie wir sie alle zusammen verwenden könnten:

class Car {
drive() { console.log("Brummk!"); }
}

class Bicycle {
ride() { console.log("Pedalierend!"); }
}

type Vehicle = Car | Bicycle | string;

function useVehicle(vehicle: Vehicle) {
if (typeof vehicle === "string") {
console.log(`Das Fahrzeug ist: ${vehicle}`);
} else if (vehicle instanceof Car) {
vehicle.drive();
} else if ("ride" in vehicle) {
vehicle.ride();
} else {
console.log("Unbekanntes Fahrzeugtyp");
}
}

useVehicle("Skateboard");  // Ausgabe: Das Fahrzeug ist: Skateboard
useVehicle(new Car());     // Ausgabe: Brummk!
useVehicle(new Bicycle()); // Ausgabe: Pedalierend!

In diesem Beispiel verwenden wir alle drei Typengewährungen:

1. Wir verwenden typeof, um zu überprüfen, ob das Fahrzeug eine Zeichenkette ist.
2. Wir verwenden instanceof, um zu überprüfen, ob es ein Auto ist.
3. Wir verwenden in, um zu überprüfen, ob es eine ride Methode hat (was darauf hinweist, dass es ein Fahrrad ist).

Das ist wie ein Superdetektiv zu sein, der alle seine Fähigkeiten einsetzt, um genau herauszufinden, mit welchem Fahrzeug er es zu tun hat!

Schlussfolgerung

Und hier hast du es, meine codenden Lehrlinge! Wir haben die Welt der TypeScript-Typengewährungen bereist und die typeof, in und instanceof Gewährungen erkundet. Diese mächtigen Werkzeuge werden dir helfen, sicherere und vorhersehbarere Code zu schreiben, indem TypeScript deine Absichten besser versteht.

Erinnere dich daran, Typengewährungen zu verwenden, ist wie ein freundliches Gespräch mit deinem Code. Du stellst einfach Fragen, um ihn besser zu verstehen. Also sei nicht schüchtern - fange mit diesen Typengewährungen ein Gespräch mit deinen Variablen an!

Weiter üben, bleibe neugierig, und bevor du es weißt, wirst du Typengewährungen wie ein Profi handhaben. Bis zum nächsten Mal, fröhliches Coden! ??

Credits: Image by storyset