TypeScript Academy · Lezione

Asserzioni e type guard a confronto

Preferisca i controlli a runtime alle asserzioni, quando possibile.

Asserzioni e type guard a confronto è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Due modi per convincere il compilatore

Quando il compilatore non conosce il tipo esatto di un valore, ha due possibilità: asserirlo (dichiararne il tipo) oppure usare un guard (dimostrare il tipo a runtime). I due approcci sembrano simili, ma offrono livelli di sicurezza molto diversi.

function viaAssert(v: unknown): number {
  return (v as number) + 1; // claim
}
function viaGuard(v: unknown): number {
  return typeof v === 'number' ? v + 1 : 0; // prove
}
console.log(viaAssert(5), viaGuard(5), viaGuard('x'));

Le asserzioni non verificano

Un'asserzione è una promessa senza alcun controllo. Se si sbaglia, il bug arriva fino al runtime. Le asserzioni scambiano la sicurezza con la praticità.

const v: unknown = 'hello';
const n = v as number;
console.log(n.toFixed(2)); // runtime error: toFixed is not a function

I type guard verificano a runtime

Un type guard controlla effettivamente il valore. Se il controllo ha esito positivo, sia lei sia il compilatore sapete che il tipo è corretto: il restringimento è sostenuto da una verifica reale a runtime.

function toFixed2(v: unknown): string {
  if (typeof v === 'number') return v.toFixed(2);
  return 'N/A';
}
console.log(toFixed2(3.14159), toFixed2('hi'));

Funzioni type guard personalizzate

Incapsuli i controlli complessi in un guard riutilizzabile che restituisca value is T. L'intero codice beneficia di un'unica validazione verificata accuratamente.

type Email = { address: string };
function isEmail(v: unknown): v is Email {
  return typeof v === 'object' && v !== null &&
    'address' in v && typeof (v as any).address === 'string';
}
console.log(isEmail({ address: 'a@b.com' }), isEmail(null));

I guard si combinano e si riutilizzano

Poiché i guard sono normali funzioni, può combinarli, testarli e riutilizzarli. Le asserzioni, invece, sono affermazioni sparse che non possono essere convalidate centralmente.

function isString(v: unknown): v is string { return typeof v === 'string'; }
function isNonEmpty(v: unknown): v is string {
  return isString(v) && v.length > 0;
}
console.log(isNonEmpty('hi'), isNonEmpty(''));

Funzioni di asserzione con asserts

TypeScript offre anche le funzioni di asserzione. La loro annotazione di ritorno usa la parola chiave asserts. Se la funzione restituisce normalmente il controllo, il compilatore restringe il tipo dell'argomento da quel punto in poi; se la condizione non è soddisfatta, la funzione genera un'eccezione.

function assertNumber(v: unknown): asserts v is number {
  if (typeof v !== 'number') throw new Error('not a number');
}
function use(v: unknown): number {
  assertNumber(v); // after this line, v is number
  return v * 2;
}
console.log(use(21));

asserts e value is

Un guard value is T restituisce un booleano su cui può basare un ramo condizionale. Una funzione asserts value is T genera un'eccezione in caso di errore e restringe il tipo per il resto dell'ambito. Entrambi si basano su controlli a runtime, a differenza di un semplice as.

function assertDefined<T>(v: T): asserts v is NonNullable<T> {
  if (v === null || v === undefined) throw new Error('missing');
}
const maybe: string | null = 'ok';
assertDefined(maybe);
console.log(maybe.length); // narrowed to string

Helper generici per le asserzioni

Le funzioni di asserzione sono ottimi prerequisiti riutilizzabili. Un singolo helper assert(condition) può verificare gli invarianti in tutto il codice, segnalando subito le violazioni.

function assert(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error(msg);
}
function half(n: number): number {
  assert(n % 2 === 0, 'must be even');
  return n / 2;
}
console.log(half(8));

Confronto della sicurezza

Dal più sicuro al più rischioso: i type guard e le funzioni di asserzione (verificati a runtime) sono più sicuri delle semplici asserzioni as (non verificate), che a loro volta sono più sicure delle doppie asserzioni (attivamente fuorvianti). Scelga lo strumento più sicuro adatto al caso.

// Safe: guard
function safe(v: unknown) {
  return typeof v === 'string' ? v.trim() : '';
}
console.log(safe('  hi  '));

Scelga lo strumento giusto

Usi un type guard quando deve diramare il codice in base al tipo. Usi una funzione di asserzione quando è necessario che un prerequisito sia soddisfatto o che l'esecuzione si interrompa. Usi as solo quando il restringimento è impossibile, per esempio per specializzare un elemento del DOM.

function getInput(v: unknown): asserts v is string {
  if (typeof v !== 'string') throw new Error('expected string');
}
const raw: unknown = 'name';
getInput(raw);
console.log(raw.toUpperCase());

I controlli a runtime sono superiori

Il tema ricorrente di questo corso è preferire i controlli a runtime alle asserzioni. I guard e le funzioni di asserzione offrono sia tipi in fase di compilazione sia sicurezza a runtime. Le asserzioni offrono solo un'affermazione.

function parsePort(v: unknown): number {
  if (typeof v === 'number' && Number.isInteger(v)) return v;
  throw new Error('invalid port');
}
console.log(parsePort(8080));

Verifica rapida

Verifichi la sua comprensione delle asserzioni e dei type guard.

Riepilogo: asserzioni e guard

Ha imparato che:

I type guard (value is T) dimostrano un tipo a runtime e consentono di creare rami condizionali.
Le funzioni di asserzione (asserts value is T) generano un'eccezione in caso di errore e restringono il tipo da quel punto in poi.
Le semplici asserzioni as si limitano ad affermare un tipo: non offrono sicurezza a runtime.
Preferisca gli strumenti verificati a runtime e riservi le asserzioni ai casi che non possono essere gestiti con un restringimento.

Prossimo corso: optional chaining e nullish coalescing.

function isPositive(v: unknown): v is number {
  return typeof v === 'number' && v > 0;
}
console.log(isPositive(5), isPositive(-1));

Domande Frequenti

La lezione «Asserzioni e type guard a confronto» è gratuita?

Sì — il testo completo di «Asserzioni e type guard a confronto» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Asserzioni e type guard a confronto»?

Preferisca i controlli a runtime alle asserzioni, quando possibile. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Asserzioni e type guard a confronto»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a TypeScript Academy