Funzioni in Typescript

Veniamo, ora, ad un altro tassello fondamentale di ogni linguaggio di programmazione: le funzioni. In TypeScript esistono diversi modi per tipizzare una funzione, ricalcando i diversi modi con cui una funzione può essere implementata in JavaScript. 

Iniziamo con la definizione più comune, quella introdotta dalla parola chiave function

 function: function sum(a: number, b: number): number { return a + b; }

Negli esempi precedenti, abbiamo già incontrato più volte questa definizione; qui la definizione JavaScript e le annotazioni TypeScript sono estremamente integrate fra loro: le annotazioni poste dopo i parametri ne indicano il tipo, mentre quella posta tra i parametri e il corpo della funzione, indica il tipo del valore di ritorno.

Il tipo void sta a rappresentare il tipo di ritorno di una funzione che non ritorna nessun valore:

 function log(message: string): void { console.log(message); }

Esiste anche un tipo molto particolare per rappresentare funzioni da cui non si esce né con un valore né con void; prendiamo, ad esempio, una funzione che scatena un’eccezione, oppure una che prevede un loop infinito: tali funzioni hanno il tipo di ritorno never:

// ciclo infinito 
function loop(): never { 
 while (true) { 
 console.log("I'm going to print this forever."); 
 } 
} 
// throw error 
function error(): never { 
 throw new Error("Questa funzione non tornerà al chiamante."); 
}

In un certo senso, il tipo never è l’opposto del tipo any, rappresenta cioè un dato che non solo non esiste, ma che non può mai essere letto. 

Può essere che una funzione ritorni diversi tipi di dato in base alle condizioni in cui viene chiamata. In questo caso, abbiamo diversi modi per tipizzarla: possiamo, generalmente, indicare un tipo composto come tipo di ritorno, oppure possiamo effettuare l’overload della sua firma. 

Prendiamo ad esempio una funzione che scambi una coppia di valori contenente un numero e una stringa:

type Value = number | string; 
function swap(t: [number, string]): [string, number]; 
function swap(t: [string, number]): [number, string];
function swap(t: [Value, Value]): [Value, Value] { 
 return [t[1], t[0]]; 
} 
const a = swap([1, "hello"]); // a: [string, number] 
const b = swap(["hello", 1]); // a: [number, string]

Grazie all’implementazione sovraccaricata (overloaded), TypeScript è in grado di inferire correttamente il tipo di a e b a partire dalle coppie di partenza. 

Possiamo tipizzare parametri e valori di ritorno anche per le arrow function: 

const sum = (a: number, b: number): number => a + b; 
const log = (message: string): void => console.log(message);

Tutte le notazioni viste finora legano le annotazioni di tipo alla definizione della funzione, ma non ci permettono di definire un tipo che possiamo applicare alla variabile che fa riferimento alla funzione. 

Ridefiniamo, dunque, le due funzioni di sopra con una notazione più generale, che descrive la funzione in astratto anziché tipizzarne la definzione:

const sum: (a: number, b: number) => number = (a, b) => a + b; 
const log: (message: string) => void = message => console.log(message);

La notazione è appena differente dalla precedente, persino più ripetitiva, ma è totalmente indipendente dalla dichiarazione JavaScript. Per questo, può essere identificata da un type alias e riutilizzata per definire molte funzioni diverse con la stessa firma:

type BinaryOperator = (a: number, b: number) => number; 
const sum: BinaryOperator = (a, b) => a + b; 
const subtract: BinaryOperator = (a, b) => a - b; 
const multiply: BinaryOperator = (a, b) => a * b; 
const divide: BinaryOperator = (a, b) => a / b;

Con le notazioni precedenti, questo sarebbe stato impossibile! 

Prima di proseguire, visto che le funzioni in JavaScript sono oggetti, vediamo come possiamo definire un’interfaccia per lo stesso tipo BinaryOperator:

interface BinaryOperator { 
 (a: number, b: number): number; 
}

Anche in questo caso le due definizioni type e interface sono del tutto equivalenti da un punto di vista pratico, ma vengono considerate in modo leggermente diverso da TypeScript: nel primo caso si sta dando un nomignolo a un tipo anonimo senza collocarlo nel type system; nel secondo si sta registrando un nuovo tipo a tutti gli effetti. Possiamo accorgerci di questa differenza formale in Visual Studio Code passando sopra al nome del tipo: nel caso del type alias TypeScript ci mostra l’intera definizione del tipo, mentre nel caso dell’interfaccia si limita a mostrarci il suo nome.