TypeScript Academy · Lezione

Asserzioni doppie e relativi rischi

Scopra quando serve as unknown as T e perché è pericoloso.

Asserzioni doppie e relativi rischi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Che cos'è una doppia asserzione

Una doppia asserzione concatena due cast as, solitamente passando per unknown: value as unknown as T. In questo modo forza una conversione che il compilatore rifiuterebbe altrimenti.

const s = 'hello';
const n = s as unknown as number; // forced
console.log(typeof n); // still 'string' at runtime!

Perché TS blocca i cast diretti

TypeScript blocca s as number quando string e number non hanno alcuna sovrapposizione, perché si tratta quasi certamente di un errore. L'errore protegge da asserzioni prive di senso.

const s = 'text';
// const n = s as number; // Error: types do not sufficiently overlap
console.log('Direct unrelated assertion is rejected');

Come unknown sblocca il cast

Ogni tipo può essere assegnato a unknown e unknown può essere asserito come qualsiasi tipo. Passare da unknown soddisfa la regola della sovrapposizione in due passaggi, aggirando completamente il controllo di sicurezza.

const s = 'text';
const step1 = s as unknown; // always allowed
const step2 = step1 as number; // allowed from unknown
console.log(typeof step2);

La doppia asserzione inganna il compilatore

Il risultato viene compilato, ma il valore a runtime resta invariato. Ha comunicato al sistema dei tipi qualcosa di falso. Qualsiasi codice successivo che si fidi del tipo asserito potrebbe interrompersi in modo imprevedibile.

const fake = 'oops' as unknown as number;
console.log(fake + 1); // 'oops1' — string concatenation at runtime

Un uso improprio realistico

A volte gli sviluppatori usano una doppia asserzione per silenziare gli errori quando le strutture non corrispondono. In questo modo nascondono bug reali: il valore non ha mai avuto le proprietà dichiarate.

type User = { id: number; name: string };
const partial = { id: 1 };
const user = partial as unknown as User;
console.log(user.name); // undefined at runtime

Quando serve una doppia asserzione

In alcuni casi è legittima, per esempio per collegare tipi incompatibili di librerie che sa essere strutturalmente compatibili a runtime, oppure nel codice di basso livello quando conosce davvero la disposizione in memoria. Si tratta di casi rari.

// Bridging a known-compatible external type:
type LibA = { value: number };
type LibB = { value: number };
const a: LibA = { value: 5 };
const b = a as unknown as LibB; // structurally identical
console.log(b.value);

Perché è un code smell

Una doppia asserzione indica che sta forzando il sistema dei tipi invece di collaborare con esso. Ogni doppia asserzione è un punto in cui il compilatore non può più proteggerla, quindi chi esamina il codice dovrebbe analizzare attentamente ogni occorrenza.

// Treat 'as unknown as' as a red flag in code review.
const data: unknown = JSON.parse('{}');
// Better: validate with a type guard instead of forcing.
console.log('Prefer validation over double assertion');

Preferisca la validazione

Anziché forzare un tipo, convalidi i dati e ne restringa il tipo. Un type guard dimostra la struttura a runtime, fornendo lo stesso risultato tipizzato senza ingannare il compilatore.

type User = { id: number; name: string };
function isUser(v: unknown): v is User {
  return typeof v === 'object' && v !== null &&
    'id' in v && 'name' in v;
}
const raw: unknown = { id: 1, name: 'Sam' };
if (isUser(raw)) console.log(raw.name);

Preferisca una conversione corretta

Se ha realmente bisogno di un tipo diverso a runtime, converta il valore invece di asserirlo. La conversione modifica i dati; l'asserzione modifica solo l'etichetta.

const s = '42';
const n = Number(s); // real conversion
console.log(n + 1, typeof n);

Documenti il raro caso valido

Quando una doppia asserzione è davvero giustificata, aggiunga un commento che spieghi perché è sicura. Chi manterrà il codice in futuro deve conoscere la garanzia a runtime che rende valido il cast.

type Raw = { ts: number };
type Event = { ts: number };
const raw: Raw = { ts: 100 };
// Safe: Raw and Event are structurally identical.
const ev = raw as unknown as Event;
console.log(ev.ts);

Riepilogo delle linee guida

Regola generale: se sta scrivendo as unknown as, si fermi e si chieda se la validazione o la conversione sarebbero più sicure. Nove volte su dieci, la risposta è sì.

// Decision: validate? convert? or genuinely bridge identical types?
const input = '7';
const parsed = Number.parseInt(input, 10); // convert, don't force
console.log(parsed);

Verifica rapida

Verifichi la sua comprensione delle doppie asserzioni.

Riepilogo: doppie asserzioni

Ha imparato che:

value as unknown as T forza un cast che TypeScript rifiuterebbe altrimenti.
Funziona perché unknown ha una sovrapposizione con ogni tipo, ma a runtime non modifica nulla.
È un code smell: sta forzando il sistema dei tipi e rinunciando alla sua protezione.
È preferibile usare la validazione (type guard) o una vera conversione.

Ora confronteremo direttamente asserzioni e type guard.

// Validate, don't force:
const raw: unknown = '99';
const n = typeof raw === 'string' ? Number(raw) : 0;
console.log(n);

Domande Frequenti

La lezione «Asserzioni doppie e relativi rischi» è gratuita?

Sì — il testo completo di «Asserzioni doppie e relativi rischi» è 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 doppie e relativi rischi»?

Scopra quando serve as unknown as T e perché è pericoloso. 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 3 di 4.

Quanto tempo richiede la lezione «Asserzioni doppie e relativi rischi»?

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