0Pricing
TypeScript Academy · Leçon

Typage des erreurs (unknown), réduction dans catch

Typez les paramètres de catch comme unknown, puis réduisez-les avec instanceof/typeof ou des gardes personnalisés pour gérer les erreurs en toute sécurité.

Typage des erreurs (unknown), réduction dans catch est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 3 leçons au total.

Introduction

Objectif : intercepter les erreurs en tant que unknown et les affiner de manière sûre. Vous utiliserez instanceof, typeof et des gardes de type personnalisées pour lire les données d’erreur sans mauvaise surprise.

unknown + instanceof

Commencez avec unknown. Affinez avec instanceof Error pour accéder à message, stack, etc.

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 pour les types primitifs

Certains codes lèvent des chaînes ou d’autres valeurs primitives. Utilisez typeof pour affiner le type et gérer ces cas correctement.

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);
  }
}

Garde personnalisée

Créez une garde de type définie par l’utilisateur pour reconnaître des structures « semblables à des erreurs » provenant de différentes couches.

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);
  }
}

Journalisation sûre

Centralisez la gestion des erreurs. Un petit utilitaire affine le type et journalise les informations de manière sûre, en évitant que la journalisation elle-même ne provoque des plantages.

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) }

Conseils

Conseils :

  • Préférez unknown dans catch.
  • Affinez avec instanceof, typeof ou des gardes.
  • Évitez de supposer qu’il s’agit d’une Error : du code tiers peut lever n’importe quelle valeur.

Vérification du typage des erreurs

Vérification rapide : pourquoi préférer unknown dans catch ?

Récapitulatif

Récapitulatif : interceptez les erreurs en tant que unknown, affinez-les avec instanceof/typeof ou des gardes personnalisées, et centralisez une journalisation sûre.

Questions Fréquemment Posées

La leçon « Typage des erreurs (unknown), réduction dans catch » est-elle gratuite ?

Oui — le texte complet de « Typage des erreurs (unknown), réduction dans catch » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Typage des erreurs (unknown), réduction dans catch » ?

Typez les paramètres de catch comme unknown, puis réduisez-les avec instanceof/typeof ou des gardes personnalisés pour gérer les erreurs en toute sécurité. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Typage des erreurs (unknown), réduction dans catch » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Promise , typage de async/await
  2. Typage des erreurs (unknown), réduction dans catch
  3. Motifs de concurrence (all/settled/race) et types
← Retour à TypeScript Academy