Salta al contenuto principale

Strict Mode non Basta: 100 Breach di Tipo in un Monorepo TypeScript al 100% Strict

Misurato il 31 ottobre 2026: 54 cast as any, di cui 50 nei test e uno falso positivo. In produzione restano tre cast, e solo uno va corretto.

Cosa ne pensi di questo articolo?

Strict Mode non Basta: 100 Breach di Tipo in un Monorepo TypeScript al 100% Strict
TypeScript Avanzatofedericocalo.dev

In Breve

Misurato il 31 ottobre 2026: 54 cast as any, di cui 50 nei test e uno falso positivo. In produzione restano tre cast, e solo uno va corretto.

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 inferire any quando non riesce a dedurre un tipo, e lo trasforma in un errore.
  • strictNullChecks: toglie null e undefined dal 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 tramite bind, call e apply.
  • useUnknownInCatchVariables: tipizza la variabile di catch come unknown invece di any, che è il motivo per cui su un errore si scrive err instanceof Error.
  • noImplicitThis, alwaysStrict e strictBuiltinIteratorReturn: rispettivamente il this non 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-any come 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 echarts in questo progetto ce l'ha, e per questo è stato il più facile dei tre da valutare.
  • Preferisci @ts-expect-error a @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-ignore sono 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.

Fonti e approfondimenti

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Discuti questo articolo nella community

Unisciti al gruppo Telegram per discutere con altri sviluppatori, fare domande e condividere le tue esperienze.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti