TypeScript Academy · Lezione

Capire unknown e any

Scopra perché unknown è l’alternativa type-safe a any.

Capire unknown e any è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 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.

I due tipi apicali

TypeScript dispone di due tipi che possono contenere qualsiasi valore: any e unknown. Sembrano simili, ma si comportano in modo molto diverso. Scegliere quello giusto è una competenza fondamentale per scrivere codice con tipi sicuri.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any disabilita il controllo dei tipi

any è una via di fuga che disattiva il controllo dei tipi per quel valore. Può accedere a qualsiasi proprietà o chiamarlo come una funzione: il compilatore rimane in silenzio, anche quando il codice andrebbe in errore a runtime.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown obbliga a verificare il tipo

unknown accetta anch'esso qualsiasi valore, ma non può usarlo finché non dimostra di che tipo si tratta. Il compilatore blocca l'accesso alle proprietà e le chiamate finché non restringe il tipo.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

Restringere unknown con typeof

Un controllo con typeof restringe unknown a un tipo concreto all'interno del blocco. Dopo il restringimento, tutti i metodi di quel tipo diventano disponibili in sicurezza.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Perché unknown è più sicuro

unknown rappresenta un'incertezza reale: «Non so ancora di cosa si tratti». La spinge a convalidare il valore prima di usarlo, rilevando gli errori in fase di compilazione. any nasconde soltanto l'incertezza e gli errori.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

Assegnazioni da e verso unknown

Qualsiasi valore è assegnabile a unknown. Tuttavia, unknown è assegnabile solo a unknown o any, non a tipi specifici senza restringere il tipo. È questa asimmetria a mantenerlo sicuro.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any si propaga nel codice

Una caratteristica pericolosa di any è che si propaga. Quando un valore è any, tutto ciò che deriva da esso diventa anch'esso any, erodendo silenziosamente la sicurezza dei tipi in tutto il programma.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown contiene il rischio

Con unknown, l'incertezza rimane circoscritta. Deve restringere esplicitamente il tipo a ogni confine, così le operazioni non sicure non possono propagarsi altrove. Il rischio rimane dove deve essere.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

Tipizzare i confini di API e JSON

I dati esterni — JSON, risposte di rete, input dell'utente — non offrono garanzie. Tipizzarli come unknown invece che come any obbliga a convalidarli prima di considerarli attendibili: è l'impostazione predefinita più sicura.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Quando any è accettabile

any può essere pragmatico in alcuni casi: prototipi rapidi, migrazioni graduali da JavaScript o interoperabilità con librerie non tipizzate. Lo consideri però un indicatore temporaneo, non un'abitudine. Quando possibile, preferisca unknown.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Un confronto pratico

A confronto: la versione con any viene compilata, ma può causare un errore a runtime; la versione con unknown rifiuta di compilare l'accesso non sicuro. Il compilatore sta facendo il suo lavoro: proteggerLa.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Verifica rapida

Verifichi la Sua comprensione della differenza tra unknown e any.

Riepilogo: unknown e any

Punti chiave:

any disabilita il controllo dei tipi e si propaga nei valori derivati.
unknown accetta qualsiasi valore, ma ne blocca l'uso finché non lo restringe.
Usi unknown per i dati esterni, come JSON, API e input dell'utente, per obbligare alla convalida.
Riservi any alle migrazioni o all'interoperabilità non tipizzata, come indicatore temporaneo.

Ora esploreremo il tipo vuoto: never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Domande Frequenti

La lezione «Capire unknown e any» è gratuita?

Sì — il testo completo di «Capire unknown e any» è 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 «Capire unknown e any»?

Scopra perché unknown è l’alternativa type-safe a any. 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 1 di 4.

Quanto tempo richiede la lezione «Capire unknown e any»?

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