Any vs unknown in Typescript

Più indietro in questa guida, in un esempio abbiamo parlato della funzione JSON.parse e del suo tipo di ritorno any; riprendiamo l’esempio: 

const data = JSON.parse('{ "name": "John" }'); // const data: any 
console.log(data.name);

Abbiamo già visto come dire a TypeScript di assumere che data sia di un certo tipo, e abbiamo anche visto come verificarlo senza asserzioni con una type guard. 

Tuttavia, quello che ci dovrebbe allarmare è che, in presenza di any, siamo sì di fronte a un tipo sconosciuto, ma siamo anche scoperti dalla protezione del type checker. 

Se solo esistesse un tipo analogo a any ma ancora soggetto a verifiche di tipo… 

Introduciamo unknown, il tipo sconosciuto! 

Il tipo unknown funziona come any in quanto può essere ristretto a qualunque tipo con un’asserzione o una guardia, ma non sopprime il type checker in fase di accesso. 

Vediamo come l’uso di unknown modifica il nostro esempio:

const data: unknown = JSON.parse('{ "name": "John" }'); 
console.log(data.name); // -> Property 'name' does not exist on type 'unknown'

A questo punto, possiamo tranquillizzare il compilatore in uno dei seguenti modi:

const data: unknown = JSON.parse('{ "name": "John" }'); 
// type assertion, da usare se siamo certi di quello che facciamo 
console.log((data as { name: string }).name); 
// type guard, se non conosciamo la provenienza del dato 
function hasName(x: unknown): x is { name: string } { 
 return typeof x === "object" && x !== null && "name" in x; 
} 
if (hasName(data)) { 
 console.log(data.name); 
} 
// type narrowing, che ci vincola però alla notazione 'oggetto[chiave]'

if (typeof x === "object" && x !== null && "name" in x) { 
 console.log(data["name"]); 
}

I tipi any e unknown servono chiaramente propositi molto simili, ma hanno una storia molto diversa. any esiste sin dalla nascita di TypeScript, mentre unknown è stato introdotto solo di recente appositamente per aumentare il rigore del type checker sui valori di tipo ignoto. Al momento esiste una proposta nella community per trasformare tutti i valori di ritorno any in unknown nelle librerie che TypeScript usa per descrivere la tipizzazione delle funzioni JavaScript standard (ad esempio la DOM API, ma anche JSON.parse). 

In generale, possiamo considerare unknown come la versione type safe di any. In generale, dovremmo sempre preferire unknown a meno che non sappiamo quello che facciamo. Esistono dei casi in cui, in porzioni molto isolate del codice, siamo oggettivamente non interessati alla supervisione del type checker, per questo molto spesso nei progetti grandi si impone come regola generale quella di non usare mai any e di indicare con un commento eventuali deroghe a questa regola.