useUnknownInCatchVariables în TypeScript

"compilerOptions": { "useUnknownInCatchVariables": true }

tsc --useUnknownInCatchVariables

Ce face useUnknownInCatchVariables

În JavaScript se poate arunca orice cu throw: un Error, un text, un număr. Variabila din catch (e) poate fi deci orice. Fără opțiune, are tipul any și poți scrie e.message fără verificare, chiar dacă s-a aruncat un text.

Cu useUnknownInCatchVariables, e are tipul unknown. Înainte de e.message trebuie să verifici, de obicei cu e instanceof Error. Poți scrie și explicit catch (e: unknown) fără opțiune; catch (e: any) este de asemenea permis.

Implicit este false, dar devine true când strict este true.

Parametri

Parametru	Descriere
true	Activează verificarea.
false	Dezactivează verificarea, chiar dacă "strict": true.
(lipsă)	Ia valoarea lui strict: activă dacă strict este true, altfel inactivă.

Exemple

Exemplul 1: e.message fără verificare

e este unknown, deci TypeScript nu permite accesul la message.

// tsconfig.json
{
  "compilerOptions": {
    "useUnknownInCatchVariables": true
  }
}

// index.ts
try {
  JSON.parse("{nume: Ana}");
} catch (e) {
  console.log(e.message);
}

Rezultat (tsc 5.9)

$ npx tsc --noEmit
index.ts(4,17): error TS2339: Property 'message' does not exist on type 'unknown'.

Exemplul 2: Verificarea cu instanceof

După e instanceof Error, e are tipul Error. Ramura else tratează valorile aruncate care nu sunt erori.

function citeste(text: string): unknown {
  try {
    return JSON.parse(text);
  } catch (e) {
    if (e instanceof Error) {
      console.log("JSON greșit:", e.name);
    } else {
      console.log("Altceva aruncat:", String(e));
    }
    return null;
  }
}

console.log(citeste('{"nume": "Ana"}'));
console.log(citeste("{nume: Ana}"));

try {
  throw "stoc epuizat";
} catch (e) {
  console.log(e instanceof Error ? e.message : `text aruncat: ${String(e)}`);
}

Rezultat

{ nume: 'Ana' }
JSON greșit: SyntaxError
null
text aruncat: stoc epuizat

Greșeli frecvente

• Să scrii (e as Error).message. Dacă s-a aruncat un text, rezultatul este undefined; verifică cu instanceof.
• Să crezi că poți scrie catch (e: Error). TypeScript permite doar any sau unknown ca tip pentru variabila din catch.

Comenzi înrudite

• strict: Pornește dintr-o singură mișcare toate verificările stricte de tipuri (strictNullChecks, noImplicitAny și celelalte).
• noImplicitAny: Dă eroare când TypeScript nu poate deduce un tip și ar folosi în tăcere any (de obicei la parametrii fără tip).
• strictNullChecks: Face din null și undefined tipuri separate: o valoare care poate lipsi trebuie verificată înainte de folosire.