Funzioni e tipizzazione

Le funzioni in JavaScript hanno sempre avuto un ruolo di primo piano. Esse hanno non solo il ruolo di individuare con un nome blocchi di codice eventualmente parametrizzati, ma consentono anche di definire costruttori di oggetti e di implementare livelli di protezione delle variabili grazie alla closure.

Anche in TypeScript le funzioni ricoprono un ruolo importante. Anche se alcune loro caratteristiche sono ricoperte dall'infrastruttura a oggetti basata sulle classi. Le funzioni TypeScript sono integrate nel type system del linguaggio e potenziate per rispecchiare alcune delle caratteristiche tipiche dei linguaggi di programmazione orientata agli oggetti.

Definire i tipi

Abbiamo visto come TypeScript preveda la possibilità di definire i tipi di dato dei parametri di una funzione. Abbiamo anche visto come dichiarare un'interfaccia che definisca il tipo di funzione, cioè un tipo di dato che stabilisce la firma (signature) di una funzione, come quella del seguente esempio:

interface FunzioneSuNumeri {
	(x: number, y: number):number
}

La definizione di questa interfaccia ci consente di definire una funzione di tipo FunzioneSuNumeri come la seguente:

var somma: FunzioneSuNumeri; 
somma = function(x:number, y:number) {
	return x + y;
};

Possiamo tuttavia evitare di definire un'interfaccia per determinare la firma di una funzione, definendo un tipo di funzione direttamente nella dichiarazione di una variabile:

var somma: (x:number, y:number) => number;

In questo modo dichiariamo che la variabile somma potrà contenere soltanto funzioni che prendono due interi come parametri e restituiscono un intero. È obbligatorio specificare il tipo di dato restituito dalla funzione. Questo vuol dire che anche quando una funzione non restituisce nulla occorre specificare il tipo di dato void, come nel seguente esempio:

var funzioneSenzaRisultato: (x:number, y:string) => void;

Naturalmente il fatto che nella dichiarazione del tipo di funzione vengano specificati i nomi dei parametri, x e y nel nostro esempio, non vuol dire che la funzione che verrà associata alla variabile dovrà utilizzare quei nomi. Essi rappresentano dei segnaposto che potranno essere rimpiazzati con qualsiasi nome di parametro valido nella dichiarazione della funzione.

Parametri opzionali, predefiniti e rest

A differenza di JavaScript per cui i parametri di una funzione sono tutti opzionali, in TypeScript siamo obbligati a passare il numero esatto di parametri previsto dalla dichiarazione di funzione. Questo vuol dire che, mentre in JavaScript possiamo scrivere il seguente codice:

function somma(x, y) {
	x = x||0;
	y = y||0; 
	return x + y;
}
console.log(somma(3, 2));     //output: 5
console.log(somma(3));        //output: 3
console.log(somma(3, 2, 4));  //output: 5

In TypeScript soltanto la chiamata con due argomenti darà un risultato, mentre le altre due genereranno un errore a tempo di compilazione. L'estrema flessibilità di JavaScript può comunque essere recuperata sfruttando alcune caratteristiche di TypeScript come ad esempio la possibilità di definire parametri opzionali.

Possiamo allora trasformare la definizione della funzione somma() vista prima nel seguente modo:

function somma(x, y?) {
	x = x||0;
	y = y||0; 
	return x + y;
}

In questo modo TypeScript accetterà come valida una chiamata alla funzione somma() che passa un solo argomento. È importante tener presente che i parametri opzionali devono necessariamente essere gli ultimi della lista dei parametri. Non è possibile definire il primo parametro come opzionale e poi definire uno o più parametri obbligatori.

Un'altra alternativa, che consente tra l'altro di semplificare il codice della funzione, consiste nella definizione di valori predefiniti per i parametri, come mostrato di seguito:

function somma(x = 0, y = 0) {
	return x + y;
}

In questo caso, se un valore non viene passato nell'invocazione della funzione, allora verrà assegnato al parametro il valore predefinito. Anche con questo accorgimento possiamo eseguire con successo la chiamata che passa un solo argomento.

Tuttavia questi accorgimenti non consentono di gestire la situazione in cui passiamo più argomenti di quelli previsti dalla dichiarazione. Per rimediare a questa mancanza possiamo sfruttare l'operatore rest, rappresentato da tre punti di sospensione (...):

function somma(x = 0, y = 0, ...z) {
	var result = x + y; 
	for (var i = 0; i < z.length; i++) {
		result = result + z[i];
	} 
	return result;
}

In questo caso, il parametro z preceduto dall'operatore rest è costituito da un array che cattura un numero indefinito di parametri dal terzo in poi. Possiamo quindi eseguire un ciclo su tale array per sommare tutti gli eventuali parametri in eccesso passati in fase di invocazione della funzione.