0Pricing
TypeScript Academy · Lektion

Fehlertypisierung (unknown), Eingrenzung in catch

Typisieren Sie catch-Parameter als unknown und grenzen Sie sie anschließend mit instanceof/typeof oder eigenen Guards für eine sichere Fehlerbehandlung ein.

Fehlertypisierung (unknown), Eingrenzung in catch ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. 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 3 Lektionen.

Einführung

Ziel: Fangen Sie Fehler als unknown ab und grenzen Sie sie sicher ein. Sie verwenden instanceof, typeof und benutzerdefinierte Type Guards, um Fehlerdaten ohne unerwartete Probleme auszulesen.

unknown und instanceof

Beginnen Sie mit unknown. Grenzen Sie mit instanceof Error ein, um auf message, stack usw. zuzugreifen.

async function boom(): Promise<void> { throw new Error("boom") }

async function run() {
  try {
    await boom();
  } catch (e: unknown) {
    if (e instanceof Error) {
      console.error("Handled:", e.message);
    } else {
      console.error("Non-Error thrown:", e);
    }
  }
}

run();

typeof für primitive Werte

Manche Programme werfen Zeichenketten oder andere primitive Werte. Verwenden Sie typeof, um den Typ einzugrenzen und die Werte angemessen zu behandeln.

function throwString() { throw "bad" }

try {
  throwString();
} catch (e: unknown) {
  if (typeof e === "string") {
    console.warn("string error:", e.toUpperCase());
  } else {
    console.warn("other error", e);
  }
}

Benutzerdefinierter Type Guard

Erstellen Sie einen benutzerdefinierten Type Guard, um „fehlerähnliche“ Strukturen aus verschiedenen Ebenen zu erkennen.

type ErrorLike = { message: string; code?: string };

function isErrorLike(e: unknown): e is ErrorLike {
  return !!e && typeof e === "object" && "message" in e;
}

try {
  throw { message: "oops", code: "E_BAD" };
} catch (e: unknown) {
  if (isErrorLike(e)) {
    console.error(e.message, e.code ?? "no-code");
  } else {
    console.error("unknown error", e);
  }
}

Sicheres Protokollieren

Zentralisieren Sie die Fehlerbehandlung. Ein kleiner Helfer grenzt den Typ ein und protokolliert sicher, sodass keine Abstürze durch die Protokollierung selbst entstehen.

function logErrorSafe(e: unknown): void {
  if (e instanceof Error) {
    console.error("Error:", e.message);
  } else if (typeof e === "string") {
    console.error("Error(string):", e);
  } else {
    try {
      console.error("Error(obj):", JSON.stringify(e));
    } catch {
      console.error("Error(unknown)");
    }
  }
}

try { throw { oops: true } } catch (e: unknown) { logErrorSafe(e) }

Tipps

Tipps:

  • Bevorzugen Sie unknown in catch.
  • Grenzen Sie mit instanceof, typeof oder Type Guards ein.
  • Gehen Sie nicht davon aus, dass es sich um Error handelt – Code von Drittanbietern kann alles werfen.

Prüfung zur Fehler-Typisierung

Schnellprüfung: Warum sollten Sie in catch unknown bevorzugen?

Zusammenfassung

Zusammenfassung: Fangen Sie als unknown ab, grenzen Sie mit instanceof/typeof oder benutzerdefinierten Type Guards ein und zentralisieren Sie das sichere Protokollieren.

Häufig gestellte Fragen

Ist die Lektion „Fehlertypisierung (unknown), Eingrenzung in catch“ kostenlos?

Ja — der vollständige Text von „Fehlertypisierung (unknown), Eingrenzung in catch“ 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 3 Lektionen.

Was lerne ich in „Fehlertypisierung (unknown), Eingrenzung in catch“?

Typisieren Sie catch-Parameter als unknown und grenzen Sie sie anschließend mit instanceof/typeof oder eigenen Guards für eine sichere Fehlerbehandlung ein. 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 2 von 3.

Wie lange dauert die Lektion „Fehlertypisierung (unknown), Eingrenzung in catch“?

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. Promise , Typisierung von async/await
  2. Fehlertypisierung (unknown), Eingrenzung in catch
  3. Nebenläufigkeitsmuster (all/settled/race) und Typen
← Zurück zu TypeScript Academy