TypeScript Academy · Lektion

Narrowing mit typeof und Truthiness

Verwenden Sie typeof-Prüfungen, um primitive Typen einzugrenzen.

Lektion 1 von 413 Schritte

Narrowing mit typeof und Truthiness ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

TypeScript grenzt Union-Typen innerhalb von Bedingungsblöcken ein. `typeof`-Prüfungen und Truthiness-Prüfungen sind die häufigsten Techniken zur Eingrenzung.

Eingrenzung mit typeof

Verwenden Sie `typeof`, um primitive Typen zu prüfen. TypeScript erkennt typeof-Prüfungen und grenzt den Typ innerhalb des Blocks ein.
function process(val: string | number) {
  if (typeof val === 'string') {
    return val.toUpperCase(); // val: string
  }
  return val.toFixed(2); // val: number
}

Rückgabewerte von typeof

typeof gibt 'string', 'number', 'boolean', 'bigint', 'symbol', 'undefined', 'object' oder 'function' zurück. Hinweis: typeof null === 'object' – eine Besonderheit von JavaScript.
typeof 'hello'    // 'string'
typeof 42         // 'number'
typeof true       // 'boolean'
typeof null       // 'object' (quirk!)
typeof undefined  // 'undefined'

Eingrenzung per Truthiness

JavaScript-Werte sind truthy oder falsy. TypeScript grenzt `T | null | undefined` innerhalb einer Truthiness-Prüfung auf `T` ein.
function greet(name: string | null) {
  if (name) {
    console.log('Hello, ' + name); // name: string
  } else {
    console.log('Hello, stranger');
  }
}

Falsy-Werte

Falsy-Werte in JavaScript sind: false, 0, '', null, undefined, 0n und NaN. Bei erfolgreicher Prüfung entfernt die Truthiness-Eingrenzung diese Werte aus dem Typ.

Eingrenzung durch boolesche Umwandlung

Auch die Verwendung von `Boolean(val)` oder `!!val` grenzt null und undefined aus.
const items: (string | null)[] = ['a', null, 'b', null];
const strings = items.filter((x): x is string => x !== null);

Negierte Bedingungen

TypeScript grenzt Typen auch in else-Zweigen und nach vorzeitigen Rückgaben ein.
function getLength(val: string | null): number {
  if (!val) return 0; // early return narrows
  return val.length;  // val: string here
}

typeof mit Gleichheitsprüfung kombinieren

Ein strikter Gleichheitsvergleich (===) in Kombination mit typeof ermöglicht eine präzise Eingrenzung.
function accept(x: string | number | boolean) {
  if (typeof x === 'string' || typeof x === 'number') {
    console.log(x); // x: string | number
  }
}

typeof kann nicht auf null eingrenzen

Um auf null einzugrenzen, verwenden Sie den strikten Vergleich `=== null`. Truthiness kann nicht zwischen null und anderen falsy-Werten unterscheiden.
function check(x: string | null | 0) {
  if (x === null) { /* x: null */ }
  else if (x === 0) { /* x: 0 */ }
  else { /* x: string */ }
}

Eingrenzung in Schleifen

TypeScript wendet die Eingrenzung auch innerhalb von Schleifenkörpern an, nicht nur in if-Anweisungen.

Kontrollflussanalyse

TypeScript verfolgt mithilfe der Kontrollflussanalyse den Typ an jeder Stelle Ihres Codes. Auch Zuweisungen aktualisieren den Typ.
let x: string | number = 'hello';
// x: string
x = 42;
// x: number

Kurzer Test

Welchen Typ hat `val` innerhalb von `if (typeof val === 'string')`, wenn der ursprüngliche Typ `string | number` war?

Zusammenfassung

`typeof`-Prüfungen und Truthiness-Bedingungen grenzen Union-Typen in TypeScript ein. TypeScript verwendet die Kontrollflussanalyse, um Typen an jeder Stelle zu verfolgen. Verwenden Sie strikte Gleichheitsvergleiche für Prüfungen auf null und undefined.
Kostenlos starten

Lerne TypeScript mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
101
Lektionen
352

Häufig gestellte Fragen

Ist die Lektion „Narrowing mit typeof und Truthiness“ kostenlos?

Ja — der vollständige Text von „Narrowing mit typeof und Truthiness“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Narrowing mit typeof und Truthiness“?

Verwenden Sie typeof-Prüfungen, um primitive Typen einzugrenzen. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Narrowing mit typeof und Truthiness“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Narrowing mit typeof und Truthiness
  2. Narrowing mit instanceof und in
  3. Benutzerdefinierte Type-Guard-Funktionen
  4. Vollständigkeitsprüfung mit never
← Zurück zu TypeScript Academy