TypeScript - Never: Verständnis der untersten Art

Hallo, angehende Programmierer! Heute tauchen wir in einen der geheimnisvolleren Typen von TypeScript ein: den never-Typ. Keine Sorge, wenn du neu im Programmieren bist – ich werde dich durch dieses Konzept Schritt für Schritt führen, genau wie ich es in meinen Jahren des Unterrichtens für unzählige Schüler getan habe. Also hole dir dein lieblingsGetränk und lassen uns auf diese aufregende Reise in die Welt von TypeScript machen!

Was ist der never-Typ?

Der never-Typ in TypeScript wird oft als "unterster Typ" oder "leerer Typ" bezeichnet. Er repräsentiert einen Typ, der niemals auftreten sollte. Jetzt könntest du denken: "Warum brauchen wir einen Typ, der niemals passiert?" Nun, meine neugierigen Freunde, nützlicher als du vielleicht denkst!

Wann wird never verwendet?

1. Zur Darstellung unmöglicher Szenarien
2. Zum Umgang mit erschöpfenden Überprüfungen
3. In Funktionen, die niemals zurückkehren

Lassen wir uns einige Beispiele ansehen, um diese Konzepte klarer zu machen.

Beispiel 1: Darstellung unmöglicher Szenarien

function throwError(message: string): never {
throw new Error(message);
}

let result = throwError("Oops! Something went wrong!");
console.log(result); // Diese Zeile wird niemals erreicht

In diesem Beispiel ist die throwError-Funktion dazu verpflichtet, einen Fehler zu werfen und niemals normal zurückzukehren. Daher ist ihr Rückgabetyپ never.

Denke daran wie folgt: Wenn du einen Kuchen backst und das Rezept sagt "backe bis niemals", weißt du, dass der Kuchen nicht aus dem Ofen kommt!

Beispiel 2: Erschöpfende Überprüfungen

type Shape = "circle" | "square" | "triangle";

function getArea(shape: Shape): number {
switch (shape) {
case "circle":
return Math.PI * Math.pow(5, 2);
case "square":
return 10 * 10;
case "triangle":
return (10 * 5) / 2;
default:
const _exhaustiveCheck: never = shape;
return _exhaustiveCheck;
}
}

Hier hilft never, sicherzustellen, dass wir alle möglichen Formen abgedeckt haben. Wenn wir eine neue Form zum Shape-Typ hinzufügen, aber vergessen, eine entsprechende Bedingung in getArea hinzuzufügen, gibt TypeScript uns einen Fehler. Es ist wie ein hilfreicher Assistent, der dich daran erinnert, wenn du etwas vergessen hast!

Beispiel 3: Funktionen, die niemals zurückkehren

function infiniteLoop(): never {
while (true) {
console.log("This loop never ends!");
}
}

Diese Funktion wird für immer (oder bis dein Computer den Speicher aufbraucht) laufen. Da sie niemals beendet wird, ist ihr Rückgabetyپ never. Es ist wie zu deinem Freund zu sagen, du wirst aufhören zu sprechen "niemals" – sie wissen, dass sie sich auf eine lange Unterhaltung einlassen!

Der never-Typ vs. void

Nun könntest du dich fragen: "Wie unterscheidet sich never von void?" Tolle Frage! Lassen wir es auseinanderdividieren.

void

Der void-Typ wird verwendet, wenn eine Funktion keinen Wert zurückgibt, aber ihre Ausführung beendet.

function logMessage(message: string): void {
console.log(message);
}

logMessage("Hello, TypeScript!"); // Diese Funktion gibt `undefined` zurück

never

Der never-Typ hingegen wird verwendet, wenn eine Funktion niemals ihre Ausführung beendet oder immer einen Fehler wirft.

function failwithError(message: string): never {
throw new Error(message);
}

failwithError("This function never returns!");

Denke daran wie folgt: void ist wie in einen Laden zu gehen und mit leeren Händen zurückzukommen, während never wie eine Reise ohne Ziel ist – du kommst nie zurück!

Praktische Anwendungen von never

Lassen uns einige mehr praktische Beispiele anschauen, in denen never nützlich sein kann.

Beispiel 4: Typ Guards

type Square = { kind: "square", size: number };
type Circle = { kind: "circle", radius: number };
type Shape = Square | Circle;

function assertNever(x: never): never {
throw new Error("Unexpected object: " + x);
}

function getArea(shape: Shape) {
switch (shape.kind) {
case "square": return shape.size * shape.size;
case "circle": return Math.PI * shape.radius ** 2;
default: return assertNever(shape); // Fehler, wenn shape weder Square noch Circle ist
}
}

In diesem Beispiel hilft assertNever, jeden Fall zu fangen, den wir möglicherweise verpasst haben. Es ist wie ein Sicherheitsnetz, wenn du Typen jonglierst!

Beispiel 5: Erkennung von unerreichbarem Code

function neverReaches(): never {
while (true) {
// Eine Operation
}
console.log("This line will never be reached");  // TypeScript-Fehler
}

TypeScript ist intelligent genug, um zu wissen, dass der console.log-Aufruf niemals erreicht wird, und gibt dir einen Fehler. Es ist wie ein Navigationsgerät, das dir sagt, dass du versuchst, an einen nicht-existenten Ort zu fahren!

Methoden und Eigenschaften von never

Nun könntest du dich fragen, ob never irgendwelche Methoden oder Eigenschaften hat. Die Wahrheit ist, never hat keine eigenen Methoden oder Eigenschaften, da es einen Typ darstellt, der niemals auftreten sollte. Es ist jedoch immer noch ein wichtiger Bestandteil des TypeScript-Typensystems.

Hier ist eine Tabelle, die zusammenfasst, was du (oder nicht) mit never tun kannst:

Operation	Ergebnis	Erklärung
Zuweisen an never	✅ Erlaubt	Jeder Typ kann an never zugewiesen werden
Zuweisen von never zu anderen Typen	❌ Nicht erlaubt	never kann nicht an jeden anderen Typ zugewiesen werden
Methodenaufrufe auf never	❌ Nicht erlaubt	Da never niemals auftreten sollte, kannst du keine Methoden darauf aufrufen
Verwenden von never in Verbindungen	✅ Erlaubt, aber hat keine Wirkung	never wird in Verbindungstypen ignoriert
Verwenden von never in Schnittpunkten	✅ Erlaubt und ergibt never	Jeder Typ, der mit never geschnitten wird, ergibt never

Schlussfolgerung

Und da hast du es, meine lieben Schüler! Wir haben die Welt von never bereist und ihre Geheimnisse erforscht. Denke daran, never ist wie ein Freund, der immer absagt – sie zeigen sich nie, aber sie sind immer noch wichtig, daran zu denken!

Das Verständnis von never mag am Anfang verwirrend erscheinen, aber mit Übung wirst du feststellen, dass es ein unentbehrliches Werkzeug in deinem TypeScript-Werkzeugkasten ist. Es hilft, deinen Code robuster zu machen, potenzielle Fehler zu fangen und sogar tiefer über das Verhalten deiner Funktionen nachzudenken.

Weiterschreiben, weiterlernen und niemals die Gelegenheit versäumen, neue Dinge in TypeScript auszuprobieren! Bis zum nächsten Mal, mögen deine Kompilierungsfehler wenige sein und deine Typinferenzen stark sein!

Credits: Image by storyset