TypeScript Academy · Lektion

Typning av fel (unknown) och förfining i catch

Typa catch-parametrar som unknown och förfina dem sedan med instanceof/typeof eller anpassade typvakter för säker felhantering.

Lektion 2 av 38 steg

Typning av fel (unknown) och förfining i catch är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 2 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 3 lektioner.

Introduktion

Mål: Fånga fel som unknown och begränsa typen säkert. Ni kommer att använda instanceof, typeof och anpassade type guards för att läsa feldata utan överraskningar.

unknown + instanceof

Börja med unknown. Begränsa typen med instanceof Error för att komma åt message, stack och så vidare.

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 primitiva värden

Viss kod kastar strängar eller andra primitiva värden. Använd typeof för att begränsa typen och hantera dem på ett robust sätt.

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

Anpassad type guard

Skapa en user-defined type guard för att känna igen fel-liknande strukturer från olika lager.

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

Säker loggning

Centralisera felhanteringen. En liten hjälpfunktion begränsar typen och loggar säkert, så att inte själva loggningen orsakar krascher.

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

Tips

Tips:

  • Föredra unknown i catch.
  • Begränsa typen med instanceof, typeof eller guards.
  • Utgå inte från Error – kod från tredje part kan kasta vad som helst.

Kontroll av feltypning

Snabbkontroll: Varför bör Ni föredra unknown i catch?

Sammanfattning

Sammanfattning: Fånga som unknown, begränsa typen med instanceof/typeof eller anpassade guards och centralisera säker loggning.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
101
Lektioner
352

Vanliga frågor

Är lektionen ”Typning av fel (unknown) och förfining i catch” gratis?

Ja – hela texten till ”Typning av fel (unknown) och förfining i catch” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 3 lektioner.

Vad lär jag mig i ”Typning av fel (unknown) och förfining i catch”?

Typa catch-parametrar som unknown och förfina dem sedan med instanceof/typeof eller anpassade typvakter för säker felhantering. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 3.

Hur lång tid tar lektionen ”Typning av fel (unknown) och förfining i catch”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Promise och typning av async/await
  2. Typning av fel (unknown) och förfining i catch
  3. Mönster för samtidighet (all/settled/race) och typer
← Tillbaka till TypeScript Academy