Annotazioni e dichiarazioni in Typescript

Affinché il type checker possa fare il suo lavoro, dovremo combinare in modo rigorosamente consistente le dichiarazioni di tipo e le annotazioni di tipo nel nostro codice. Poiché TypeScript è, essenzialmente, linguaggio JavaScript più qualcosa, la parte di codice che effettua calcoli e operazioni la conosciamo già (hai bisogno di una rispolveratina? Tranquillo: ecco a te la nostra guida Javascript in italiano), e non subisce variazioni. 

Si aggiungeranno, però, al nostro codice nuove parole chiave e sintassi che attengono esclusivamente al mondo dei tipi; vediamo qualche esempio: 

// 'type' introduce un alias per il tipo 'number' 
type State = number; 
// 'interface' definisce un'interfaccia per classi e oggetti 
interface Stack<T> { 
 push(item: T): void; 
 pop(): T 
} 
// 'enum' definisce un elenco finito di valori possibili 
enum RGBColor { 
 Red, 
 Green, 
 Blue 
}
// 'implements' attribuisce a una classe le proprietà 
// descritte da un'interfaccia (da implementare) 
class NumberArrayStack implements Stack<number> { ... } 
// i due punti assegnano un tipo a funzioni, variabili, ecc 
const modelId: number = 42; 
// il tipo identificato dai due punti può anche non avere un nome 
function rollDice(): 1 | 2 | 3 | 4 | 5 | 6 { ... }

L’elenco completo delle sintassi TypeScript è vastissimo e in continua evoluzione, ed è ottimamente documentato dal manuale TypeScript ufficiale. In questa guida vedremo la maggior parte di esse, e ci soffermeremo su come e quando utilizzarle per trarne il meglio in ogni occasione. 

Per il momento, possiamo fissare la seguente distinzione: 

• le dichiarazioni (o definizioni) di tipo sono quelle istruzioni in cui diamo un nome e una descrizione ai tipi che intendiamo utilizzare nella codebase; 
• le annotazioni di tipo sono tutte quelle note aggiunte al codice JavaScript introdotte dai due punti, dove riportiamo il tipo atteso per un dato elemento del codice. 

Come abbiamo detto, il type checker verificherà che i dati che vengono passati nel nostro codice (ad esempio valori assegnati a variabili o passati a funzioni o restituiti da espressioni) siano compatibili con le annotazioni che abbiamo scritto per quei dati. 

TypeScript contempla anche l’assenza di annotazioni di tipo, ed è in grado di assegnare implicitamente un tipo adeguato in base all’uso e al contesto di una variabile o funzione. Questa qualità è detta type inference, cioè deduzione (o inferenza) di tipo, ed è una caratteristica che favorisce la transizione graduale da JavaScript a TypeScript, oltre a privilegiare la sintesi quando il tipo di una variabile o il valore di ritorno di una funzione è deducibile dal corpo. 

Di seguito qualche esempio di type inference (nei commenti le definizioni con tipo assegnato da TypeScript): 

let num = 1; // num: number 
let greeting = "hello"; // greeting: string 
function doNothing() {} // doNothing(): void 
function getNumber() { return 4; } // getNumber(): number 

Finora abbiamo introdotto concetti ed esempi di tipizzazione senza esserci realmente addentrati nel type system. Questo è stato fatto volontariamente per iniziare a familiarizzare con la sintassi e introdurre alcuni concetti fondamentali, ma in questo momento non è importante che sia tutto chiaro al 100%. Intanto, abbiamo da subito qualche strumento per iniziare a giocare con TypeScript in Visual Studio Code, e man mano che andremo avanti, tutto sarà più chiaro.