Risposta diretta
In questo monorepo il file tsconfig ha strict, strictTemplates e strictInjectionParameters tutti attivi, e il 31 ottobre 2026 sopravvivono 60 occorrenze di ': any' e 54 di 'as any' su 4293 file TypeScript. Il dato interessante non è il totale: 50 dei 54 cast stanno nei file di test, e dei 4 rimasti uno è un falso positivo del grep. In produzione i cast veri sono tre. Strict mode chiude gli errori accidentali, non le vie di fuga deliberate.
«Ho strict: true, quindi il mio codice è a prova di tipo» è una frase che si sente
spesso e che si verifica raramente su un progetto di dimensioni reali. Se la stai dicendo del tuo,
questo articolo ti propone di smettere di discuterne e di contarlo, con quattro comandi che puoi
lanciare adesso sul tuo repository. Io li ho lanciati sul mio, e il risultato mi ha fatto cambiare
idea su quale sia il problema.
Strict mode è necessario e non è sufficiente, e fin qui è un luogo comune. La parte che si salta sempre è la seconda domanda: se le vie di fuga restano, dove finiscono? La risposta misurata su questo progetto non è quella che mi aspettavo, e cambia completamente il tipo di intervento che ha senso fare.
Che cosa chiude strict, e che cosa resta aperto
Il flag strict non è un controllo: è un interruttore che ne accende altri. Quanti,
non serve ricordarlo, perché il compilatore lo dice: npx tsc -p tsconfig.app.json
--showConfig stampa la configurazione con tutti i valori impliciti risolti. Su questo
progetto, con TypeScript 5.9, i sotto-flag attivati sono nove, e vale la pena
leggerli perché ognuno chiude una categoria diversa di guaio.
noImplicitAny: vieta al compilatore di inferireanyquando non riesce a dedurre un tipo, e lo trasforma in un errore.strictNullChecks: toglienulleundefineddal dominio di ogni tipo, obbligandoti a dichiararli dove sono possibili.strictFunctionTypes: verifica la compatibilità dei parametri delle funzioni in modo controvariante, cioè nel verso che è davvero sicuro.strictPropertyInitialization: pretende che ogni proprietà di classe non facoltativa venga assegnata nel costruttore.strictBindCallApply: controlla i tipi degli argomenti passati tramitebind,calleapply.useUnknownInCatchVariables: tipizza la variabile dicatchcomeunknowninvece diany, che è il motivo per cui su un errore si scriveerr instanceof Error.noImplicitThis,alwaysStrictestrictBuiltinIteratorReturn: rispettivamente ilthisnon tipizzato, la modalità strict di JavaScript sempre attiva, e i tipi di ritorno degli iteratori nativi.
A questi nove il progetto aggiunge due controlli che vengono dal compilatore di Angular:
strictTemplates, che estende la verifica dei tipi dentro i template HTML, e
strictInjectionParameters, che la estende ai parametri iniettati nei costruttori.
Tutto quello che questo pacchetto intercetta ha una proprietà in comune: nessuno lo ha scritto di
proposito. Una variabile che diventa any perché il compilatore non sa dedurla, un
accesso a una proprietà di un oggetto che può essere nullo, un parametro dimenticato in una
sottoclasse. Sono guasti che nascono dall'assenza di un vincolo, e un vincolo li elimina.
Resta fuori tutto ciò che è deliberato, e le forme sono tre, in ordine di quanto sono difficili da
trovare. La prima è any scritto a mano, che è onesto perché si vede. La seconda è il
cast as, che è peggiore perché afferma un tipo che il compilatore accetta senza
verificare. La terza è il commento @ts-expect-error, che spegne il controllo su una
riga sola. Nessun flag può chiudere queste tre strade, perché sono esattamente le valvole di sfogo
che rendono TypeScript adottabile su codice che esiste già.
Il conteggio, con i comandi per rifarlo
I numeri che seguono vengono da quattro comandi eseguiti dalla cartella frontend/ il
31 ottobre 2026. Non sono una stima e non vengono da uno strumento di analisi: sono conteggi di
occorrenze testuali, con tutti i limiti che questo comporta e che fra poco diventano il punto
centrale dell'articolo.
Vie di fuga dai tipi, misurate il 31 ottobre 2026 su src/app
| Comando | Esito | Nei file di test | Fuori dai test |
|---|---|---|---|
grep -ro ': any\b' src/app | wc -l |
60 | 27 righe | 32 righe |
grep -ro 'as any\b' src/app | wc -l |
54 | 50 righe | 4 righe |
grep -rn '@ts-expect-error' src | wc -l |
6 | 6 righe | 0 |
find src/app -name '*.ts' | wc -l |
4293 | 1941 file | 2352 file |
La riga che conta è la seconda. Cinquanta cast su cinquantaquattro stanno dentro file che finiscono
per .spec.ts, cioè dentro i test. E tutti e sei i @ts-expect-error del
progetto stanno là. La distribuzione non è uniforme: è concentrata in un posto, e quel posto ha
regole diverse.
Il grep che mente, e perché è il pezzo più utile di questo articolo
Prima di spiegare i quattro cast fuori dai test, vale la pena guardarli davvero, perché contarli non basta. Eseguendo il comando e leggendo le quattro righe una per una, la quarta è questa:
La quarta occorrenza, letta invece che contata
src/app/data/learning-paths-sections-ai-security.ts:175 contiene il testo
«Generated text ending up in a page, a query, a shell command or an HTTP call: the same rules
as any external input, from escaping to parameterisation.»
Non è un cast. È prosa inglese dentro una stringa, in cui as any significa «come
qualunque». Il mio comando l'ha contata perché cerca due parole, non un costrutto del linguaggio.
Quindi i cast reali nel codice di produzione sono tre, non quattro, e il titolo che avevo in mente
per questo articolo era sbagliato del 25 per cento su una base di quattro.
La lezione non riguarda any: riguarda il metodo. Un conteggio ottenuto cercando un
token nudo misura il token, non il significato, e la differenza cresce con la dimensione del
progetto. Se un numero del genere deve finire in una decisione, in una revisione o in un articolo,
le occorrenze si leggono una per una finché sono poche, e si usa uno strumento che capisce la
sintassi quando diventano tante. La regola pratica che ne ho ricavato è che un grep va bene per
sapere se vale la pena guardare, e non va bene per dire quanti.
I tre cast veri, uno per uno
Tre casi in duemilatrecentocinquantadue file non sono un allarme. Sono però un campione perfetto, perché sono tre cast scritti per tre motivi diversi, e meritano tre verdetti diversi.
Il cast che dichiara un buco noto
In progetto-dashboard.ts una riga legge una libreria di grafici da una variabile
globale, con (window as any)['echarts'], e sopra ha un commento che spiega che la
libreria è caricata in modo differito e si registra da sé sull'oggetto globale. Questo cast è
difendibile: dice una cosa vera, cioè che in quel punto il tipo non è noto, e lo dice ad alta voce.
È difendibile e si può fare meglio, perché il tipo non è ignoto: è solo non dichiarato. Quello che serve non è la tipizzazione completa della libreria, ma il pezzettino che si usa davvero.
// Il minimo che serve davvero di echarts, non la sua tipizzazione completa.
interface EchartsGlobale {
init(
contenitore: HTMLElement,
tema?: string,
opzioni?: { renderer: 'canvas' | 'svg'; locale: string },
): { setOption(opzioni: unknown): void };
}
declare global {
interface Window {
echarts?: EchartsGlobale;
}
}
export function prendiEcharts(): EchartsGlobale | undefined {
// Nessun cast: 'echarts' ora esiste nel tipo di Window, e può essere assente.
return window.echarts;
}
Qui vanno spiegate due cose, perché sono le due che userai. declare global apre una
dichiarazione nello spazio dei nomi globale da dentro un modulo: senza di esso, l'interfaccia
Window che scrivi resterebbe locale al file e non si fonderebbe con quella della
libreria standard. La fusione funziona perché le interfacce di TypeScript sono aperte, cioè due
dichiarazioni con lo stesso nome si sommano invece di darsi conflitto. Il punto di domanda in
echarts? è l'altra metà: dichiara la proprietà come eventualmente assente, e con
strictNullChecks attivo questo obbliga chi la legge a gestire il caso in cui la
libreria non sia ancora arrivata. Ometterlo produce un tipo che promette una presenza che il
caricamento differito non garantisce, e sposta il guasto da un controllo del compilatore a un
errore a schermo nero.
Questo blocco compila con i flag di questo progetto, verificato con il compilatore del repository.
Il prezzo di questa strada è che l'interfaccia che hai scritto è una tua affermazione: se la
libreria cambia la firma di init, il compilatore continuerà a essere d'accordo con te
e sbagliato. Si chiama tipizzazione per sentito dire, ed è comunque meglio di any,
perché un'affermazione scritta si può rileggere e correggere, mentre any non afferma
nulla.
Il cast dell'interoperabilità
In qr-code-generator-page.ts il cast serve a risolvere un problema vecchio: un modulo
importato in modo dinamico può esporre la propria funzione come default oppure
direttamente, a seconda di come è stato confezionato, e la riga
(mod as any).default || mod copre i due casi. Sembra il cast con la giustificazione più
solida dei tre, perché la forma del valore dipende dal confezionamento del pacchetto e non dal
codice che lo usa.
La strada pulita non è un tipo migliore: è una opzione del compilatore.
esModuleInterop normalizza proprio questa differenza fra i due confezionamenti e
rende la riga inutile. E qui la verifica dà un esito che non mi aspettavo: lo stesso comando
--showConfig di prima riporta esModuleInterop: true su questo progetto,
perché l'opzione module: preserve la implica. L'opzione era già attiva prima che il
cast venisse scritto.
Quindi il verdetto su questo secondo caso cambia mentre lo si guarda: non è il cast con la giustificazione più solida, è un cast che non serve. Difendeva da un problema che la configurazione aveva già risolto, e nessuno lo ha più riaperto perché un cast non produce nessun segnale quando diventa superfluo. È il motivo per cui conviene scrivere accanto a ogni via di fuga non solo il perché, ma anche la condizione che la renderebbe eliminabile.
Il cast che afferma il falso
Il terzo è l'unico che considero un difetto, e si trova in audit-page.ts. La chiamata
dichiara al compilatore che la risposta ha due campi, e poi il codice ne legge un terzo.
// Il contratto dichiarato alla chiamata: due campi, nessun errore.
interface AvvioAudit {
runId: string;
status: string;
}
declare function post<T>(url: string, body: unknown): Promise<{ data: T | null }>;
export async function avvia(url: string): Promise<string> {
const risposta = await post<AvvioAudit>('/audit/run', { url });
if (risposta.data?.runId) {
return risposta.data.runId;
}
// 'error' non esiste in AvvioAudit: il cast lo fa esistere per finta.
throw new Error((risposta.data as any)?.error ?? 'Errore avvio audit');
}
Togliendo il cast, il compilatore del repository dice esattamente questo:
03-senza-cast.ts(13,34): error TS2339: Property 'error' does not exist on type 'AvvioAudit'.
L'errore è corretto e il cast lo mette a tacere senza rispondergli. Il punto non è stilistico:
quel cast afferma che il campo esiste, e se il server smette di mandarlo la riga produce
undefined, l'operatore di scorta restituisce il messaggio generico, e il motivo vero
dell'errore sparisce proprio nel punto in cui serviva. Il tipo dichiarato e il contratto reale non
coincidono, e il cast serve a non accorgersene.
La correzione non è sostituire any con unknown: è dire la verità sul
contratto. Una risposta che può essere un successo o un errore non è un oggetto con campi
facoltativi, sono due forme alternative, e il tipo che le esprime è una unione discriminata.
// Il contratto vero ha due forme alternative, e il tipo lo dice.
type EsitoAudit =
| { ok: true; runId: string; status: string }
| { ok: false; error: string };
declare function post<T>(url: string, body: unknown): Promise<{ data: T | null }>;
export async function avvia(url: string): Promise<string> {
const risposta = await post<EsitoAudit>('/audit/run', { url });
const esito = risposta.data;
if (esito === null) {
throw new Error('Risposta vuota dal server');
}
if (esito.ok) {
return esito.runId;
}
// Qui il compilatore sa che esiste 'error', senza nessun cast.
throw new Error(esito.error);
}
Il campo ok è il discriminante: un valore letterale, diverso nei due rami, che il
compilatore usa per capire in quale ramo si trova. Dopo if (esito.ok) il tipo di
esito nel blocco è solo il primo ramo, quindi runId è leggibile e
error non esiste; nel ramo else vale l'opposto. Non c'è nessun cast,
e nessuno dei due accessi può sbagliare. Il controllo su null separato all'inizio
serve perché il tipo della risposta ammette l'assenza di corpo, che è un terzo caso e non va
confuso con l'errore applicativo.
Anche questa versione ha un prezzo, e va detto: il tipo deve corrispondere a ciò che il server manda davvero. Se lo scrivi guardando il codice del client invece del contratto, hai spostato la bugia dal cast al tipo, che è un posto dove si vede meno. La differenza l'ha fatta, nel mio caso, aprire il controller che risponde a quella chiamata e leggere le due forme che produce.
Cinquanta cast nei test: lo stesso costrutto, un'altra regola
Resta la concentrazione che il conteggio ha fatto emergere, e che è la parte che davvero vale la pena portarsi via. Nei test il cast serve quasi sempre a una cosa sola: raggiungere un membro privato o sostituire una dipendenza con un oggetto finto che non implementa l'interfaccia intera. È un uso diverso, con un rischio diverso.
Un cast nel codice di produzione nasconde un contratto sbagliato, e il prezzo lo paga un utente. Un cast in un test nasconde al massimo un test fragile, e il prezzo lo paga chi fa il prossimo rinominamento, scoprendo che il test continua a passare mentre verifica un metodo che non esiste più. Il danno è reale ma di un ordine di grandezza diverso, e per questo una regola di lint che tratta i due casi allo stesso modo viene disattivata nel giro di una settimana.
La conseguenza pratica è che l'intervento sensato su questo progetto non è una campagna per
azzerare any. Tre cast di produzione non giustificano una campagna, e ne ho corretto
uno solo perché era l'unico che diceva il falso. Quello che serve è una regola che distingue i due
contesti: severa dove il codice va in esercizio, tollerante dove sta un doppio di prova.
Che cosa farei adesso, in ordine di resa
Queste quattro cose si possono fare in modo indipendente, in qualunque ordine, e ognuna si verifica da sé.
- Attiva
@typescript-eslint/no-explicit-anycome avviso e non come errore, con una configurazione separata per i file*.spec.ts: la severità va dove il codice viene eseguito dagli utenti. - Pretendi un commento su ogni via di fuga che resta, con il motivo e la data: il cast di
echartsin questo progetto ce l'ha, e per questo è stato il più facile dei tre da valutare. - Preferisci
@ts-expect-errora@ts-ignore: il primo diventa a sua volta un errore quando la riga sottostante smette di sbagliare, quindi si pulisce da sé. Qui gli@ts-ignoresono zero, ed è l'unico numero di questa misura che mi ha fatto piacere. - Conta periodicamente, e leggi le occorrenze finché sono poche: il numero da solo avrebbe tenuto nell'articolo un falso positivo e tre casi indistinguibili.
Chiusura
Adesso hai quattro comandi per misurare le vie di fuga dai tipi sul tuo progetto, e un motivo per non fidarti del totale che restituiscono: su quattro occorrenze fuori dai test, una era prosa inglese. Sai distinguere i tre casi che contano, cioè il cast che dichiara un buco noto, quello che copre una differenza di confezionamento e quello che afferma un campo inesistente, e sai che solo il terzo va corretto.
Sai anche come si corregge, perché il blocco con l'unione discriminata qui sopra compila con gli
stessi flag di questo repository, e l'errore che il compilatore emette senza il cast è riportato
per intero. Il prossimo articolo della serie parte da dove questo si ferma: il confine in cui i
dati entrano nel programma, e la differenza fra any e unknown quando non
sai ancora che forma hanno.
Domande frequenti
Che cosa attiva davvero il flag strict di TypeScript?
Nella versione 5.9 attiva otto controlli distinti, fra cui noImplicitAny, che vieta al compilatore di inferire any quando non riesce a dedurre un tipo, e strictNullChecks, che toglie null e undefined dal dominio dei tipi. Eliminano gli errori accidentali, non le vie di fuga scritte di proposito.
Un cast 'as' è peggio di un any dichiarato?
Di solito sì, perché afferma un tipo che il compilatore accetta senza verificare, mentre any non afferma niente. Un cast che dichiara un campo che la risposta non ha è una bugia che il prossimo lettore leggerà come una garanzia.
Quanti any ci sono davvero in questo progetto?
Il 31 ottobre 2026, su src/app: 60 occorrenze di : any e 54 di as any su 4293 file TypeScript. Dei 54 cast, 50 stanno nei file di test e 4 fuori, ma uno dei quattro è un falso positivo del grep, perché è prosa inglese in cui as any significa «come qualunque». I cast reali in produzione sono tre.
Perché contare con grep non basta?
Perché cerca un token e non un costrutto del linguaggio, quindi conta anche le occorrenze dentro stringhe e commenti. Su una base di quattro casi, un solo falso positivo sposta il risultato del 25 per cento. Un grep va bene per decidere se vale la pena guardare, non per dire quanti.
Conviene azzerare tutti gli any residui?
No, e non per pigrizia: conviene distinguere il contesto. Un cast in produzione nasconde un contratto sbagliato e lo paga un utente; un cast in un test nasconde al massimo un test fragile. Una regola che tratta i due casi allo stesso modo viene disattivata in una settimana.
Commenti
Caricamento commenti...
Accedi per commentare