TypeScript-Typwächter

Typwächter sind eine leistungsstarke Funktion in TypeScript, mit der Entwickler Laufzeitprüfungen durchführen können, um den Typ einer Variablen einzugrenzen. Dies gewährleistet präzisere Typinformationen und führt zu sichererem und vorhersehbarerem Code. In diesem Artikel wird erläutert, was Typwächter sind und wie sie effektiv eingesetzt werden.

Was sind Typwächter?

Typwächter sind Ausdrücke, die Laufzeitprüfungen durchführen und es TypeScript ermöglichen, einen spezifischeren Typ für eine Variable abzuleiten. Sie helfen bei der Unterscheidung zwischen verschiedenen Typen, insbesondere beim Umgang mit Union-Typen. Typwächter können mithilfe verschiedener Techniken implementiert werden, darunter:

• Benutzerdefinierte Typprädikate
• Typzusicherungen
• Instanzprüfungen
• Verwenden des Operators typeof
• Verwenden des Operators in

Benutzerdefinierte Typprädikate

Benutzerdefinierte Typprädikate sind Funktionen, die einen booleschen Wert zurückgeben und einen speziellen Rückgabetyp haben, der den Typ der überprüften Variable angibt. So erstellen und verwenden Sie sie:

function isString(value: any): value is string {
  return typeof value === 'string';
}

function printString(value: any) {
  if (isString(value)) {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log('Not a string');
  }
}

Im obigen Beispiel ist isString ein benutzerdefiniertes Typprädikat, das TypeScript hilft zu verstehen, dass value ein String innerhalb des Blocks if ist.

Typzusicherungen

Typbehauptungen weisen TypeScript an, eine Variable als einen bestimmten Typ zu behandeln. Diese Methode führt keine Laufzeitprüfung durch, sondern informiert den TypeScript-Compiler über den Typ. Beispiel:

function printLength(value: any) {
  console.log((value as string).length); // Assert value is a string
}

In diesem Beispiel weist value as string TypeScript an, davon auszugehen, dass value ein String ist, ohne eine Laufzeitprüfung durchzuführen.

Instanzprüfungen

Mithilfe von Instanzprüfungen lässt sich feststellen, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Dies ist bei der Arbeit mit Klassen hilfreich, um die Typen einzugrenzen:

class Dog {
  bark() { console.log('Woof'); }
}

class Cat {
  meow() { console.log('Meow'); }
}

function speak(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript knows animal is a Dog here
  } else {
    animal.meow(); // TypeScript knows animal is a Cat here
  }
}

In diesem Beispiel hilft der Operator instanceof TypeScript dabei, den Typ von animal basierend auf seiner Klasse abzuleiten.

Verwenden des Operators typeof

Mit dem Operator typeof können primitive Typen wie string, number und boolean überprüft werden:

function processValue(value: string | number) {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log(value.toFixed(2)); // TypeScript knows value is a number here
  }
}

Hier wird typeof verwendet, um zu prüfen, ob value ein string oder eine number ist, und der Typ wird entsprechend eingegrenzt.

Verwenden des Operators in

Der Operator in prüft, ob eine Eigenschaft in einem Objekt vorhanden ist. Dies ist nützlich, um zwischen Typen zu unterscheiden, die gemeinsame Eigenschaften haben:

interface Bird {
  fly: () => void;
}

interface Fish {
  swim: () => void;
}

function move(creature: Bird | Fish) {
  if ('fly' in creature) {
    creature.fly(); // TypeScript knows creature is a Bird here
  } else {
    creature.swim(); // TypeScript knows creature is a Fish here
  }
}

In diesem Beispiel hilft der Operator in TypeScript dabei, anhand des Vorhandenseins einer Methode zu bestimmen, ob creature ein Bird oder ein Fish ist.

Abschluss

TypeScript-Typwächter sind wichtige Tools für die flexible und sichere Arbeit mit Typen. Sie ermöglichen eine genauere Typprüfung und können Laufzeitfehler verhindern, indem sie sicherstellen, dass in verschiedenen Szenarien der richtige Typ verwendet wird. Das Verstehen und effektive Verwenden von Typwächtern kann zu robusterem und wartungsfreundlicherem TypeScript-Code führen.