TypeScript - Typenkompatibilität

Hallo da draußen, zukünftige Codewizardinnen und - Wizards! Heute machen wir uns auf eine aufregende Reise in die Welt von TypeScript und erkunden das faszinierende Konzept der Typenkompatibilität. Keine Sorge, wenn du neu im Programmieren bist – ich werde dein freundlicher Guide sein, und wir werden dieses Thema Schritt für Schritt angehen. Also, holt euch eure virtuellen Zauberstäbe (Tastaturen) und lasst uns einige TypeScript-Zauber sprechen!

Wie führt TypeScript Typenkompatibilitätsprüfungen durch?

Stellt euch vor, ihr versucht verschiedene geformte Blöcke in ein Loch zu passen. TypeScript's Typenkompatibilität ist ein bisschen so – es geht darum, ob ein Typ in einen anderen passt. Aber anstelle von physischen Formen, haben wir es mit Datentypen zu tun.

Strukturelle Typisierung

TypeScript verwendet, was wir "strukturelle Typisierung" nennen. Das bedeutet, es interessiert sich mehr für die Form eines Objekts als für seinen genauen Typennamen. Sehen wir uns ein Beispiel an:

interface Pet {
name: string;
}

class Dog {
name: string;
}

let pet: Pet;
let dog = new Dog();

pet = dog; // Das ist in Ordnung!

In diesem magischen Zoo sagt TypeScript: "Hey, sowohl Pet als auch Dog haben eine name-Eigenschaft vom Typ string. Sie sehen für mich gleich aus,also sind sie kompatibel!" Es ist, als ob man sagt, ein quadratischer Keil passt in ein quadratisches Loch, auch wenn einer 'Quadrat' und der andere 'Block' genannt wird.

Enten-Typisierung

Es gibt einen spaßigen Ausdruck im Programmieren: "Wenn es wie eine Ente geht und wie eine Ente quakt, dann muss es eine Ente sein." Das ist die Essenz der Enten-Typisierung, und TypeScript begrüßt diese Philosophie. Sehen wir uns das in der Praxis an:

interface Quacker {
quack(): void;
}

class Duck {
quack() {
console.log("Quack!");
}
}

class Person {
quack() {
console.log("Ich imitiere eine Ente!");
}
}

let quacker: Quacker = new Duck(); // obviously in Ordnung
quacker = new Person(); // Das ist auch in Ordnung!

TypeScript interessiert es nicht, dass Person nicht ausdrücklich als Quacker deklariert ist. Es interessiert sich nur dafür, dass Person eine quack-Methode hat, genau wie Quacker. Daher sind sowohl Duck als auch Person mit Quacker kompatibel.

Wie nutzt man Typenkompatibilität effektiv?

Die effektive Nutzung von Typenkompatibilität ist wie das Lösen eines geschickten Puzzles. Hier sind einige Tipps:

1. Verständnis der Objektliteralprüfungen

TypeScript ist bei Objektliteralen strenger. Sehen wir uns das an:

interface Point {
x: number;
y: number;
}

let p: Point;

// Das ist in Ordnung
p = { x: 10, y: 20 };

// Das wird einen Fehler verursachen
p = { x: 10, y: 20, z: 30 };

TypeScript sagt: "Werah! Ich bat um einen Point, aber du gibst mir etwas extra (z). Das ist nicht erlaubt!" Dies hilft dabei, potenzielle Fehler zu fangen, bei denen man möglicherweise ein Objekt falsch verwendet.

2. Verwenden von optionalen Eigenschaften

Manchmal möchte man flexibler sein. Das ist, wo optionale Eigenschaften nützlich sind:

interface Options {
color?: string;
width?: number;
}

function configure(options: Options) {
// ...
}

configure({ color: "red" }); // In Ordnung
configure({ width: 100 }); // In Ordnung
configure({}); // Auch in Ordnung!

Durch das Markieren von Eigenschaften als optional (mit dem ?) sagest du TypeScript: "Es ist in Ordnung, wenn diese nicht immer vorhanden sind."

Funktionen und Typenkompatibilität

Funktionen sind wie die Schweizer Army knives der Programmierung – sie sind unglaublich vielseitig. Sehen wir uns an, wie Typenkompatibilität mit ihnen funktioniert:

Parameterkompatibilität

TypeScript ist erstaunlich nachsichtig mit FunktionspARAMETERN:

let x = (a: number) => 0;
let y = (b: number, s: string) => 0;

y = x; // In Ordnung
x = y; // Fehler

Dies mag counterintuitiv erscheinen, aber es ist sicher. TypeScript sagt: "Wenn du eine Funktion erwartest, die zwei Parameter nimmt, ist es in Ordnung, eine Funktion zu geben, die weniger Parameter nimmt. Der zusätzliche Parameter wird einfach ignoriert."

Rückgabetypkompatibilität

Rückgabetypen müssen ebenfalls kompatibel sein:

let x = () => ({name: "Alice"});
let y = () => ({name: "Alice", location: "Wonderland"});

x = y; // In Ordnung
y = x; // Fehler

Es ist in Ordnung, mehr als erwartet zurückzugeben, aber nicht weniger. Es ist wie wenn man eine Pizza bestellt und zusätzliche Toppings umsonst bekommt – das ist in Ordnung! Aber wenn man eine pizza mit Toppings bestellt und nur den Teig bekommt, wäre man enttäuscht.

Klassen und Typenkompatibilität

Klassen sind wie.Blueprints für Objekte, und sie folgen ähnlichen Kompatibilitätsregeln:

class Animal {
feet: number;
constructor(name: string, numFeet: number) { }
}

class Size {
feet: number;
}

let a: Animal;
let s: Size;

a = s; // In Ordnung
s = a; // In Ordnung

TypeScript interessiert sich nur für die Instanzmitglieder. Es sagt: "Beide haben eine feet-Eigenschaft? Das ist gut genug für mich!"

Private und geschützte Mitglieder

Allerdings wird es strenger, wenn Klassen private oder geschützte Mitglieder haben:

class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}

class Rhino extends Animal {
constructor() { super("Rhino"); }
}

class Employee {
private name: string;
constructor(theName: string) { this.name = theName; }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino; // In Ordnung
animal = employee; // Fehler: 'Animal' und 'Employee' sind nicht kompatibel

Obwohl Animal und Employee gleich aussehen, behandelt TypeScript sie als unterschiedlich, weil ihre private Mitglieder von verschiedenen Deklarationen stammen.

Fazit

Und das war's, meine codenden Lehrlinge! Wir haben die Landschaft der TypeScript-Typenkompatibilität durchquert. Denkt daran, TypeScript ist hier, um euch zu helfen, besseren, sichereren Code zu schreiben. Es ist wie ein freundlicher Zauberer, der über deine Schulter schaut und dich sanft darauf hinweist, wenn du kurz vor einem Fehler stehst.

Übt weiter, experimentiert weiter, und bald werdet ihr TypeScript-Zauber wie ein Profi zaubern! Bis zum nächsten Mal, fröhliches Coden!

Credits: Image by storyset