Risposta.

Storia della domanda

Nei linguaggi come Java o C#, l'overload delle funzioni e dei metodi è una possibilità standard: si possono dichiarare più funzioni con lo stesso nome ma con parametri diversi. Questo non è presente in JavaScript, il che aggiunge potenziali errori. TypeScript risolve questo problema a livello di tipi.

Problema

In TypeScript non esiste un vero overload (più implementazioni). Si possono dichiarare più firme di una funzione, ma realizzare solo una funzione. Gli errori sorgono quando ci sono disallineamenti tra le firme dichiarate e l'implementazione, oppure quando le firme sono posizionate in modo errato.

Soluzione

TypeScript supporta l'overload delle funzioni dichiarando più firme consecutive e una sola implementazione reale che è compatibile con tutte le varianti di overload.

Esempio di codice:

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

const a = sum(1, 2); // 3
const b = sum('foo', 'bar'); // "foobar"

Caratteristiche chiave:

Sempre una sola implementazione dopo tutte le firme
L'implementazione deve essere compatibile con tutte le varianti di overload
TypeScript verifica la correttezza della chiamata quando si utilizza una funzione sovraccaricata

Domande insidiose.

È possibile definire l'implementazione della funzione prima di dichiarare tutte le firme di overload?

No, prima devono esserci tutte le firme di overload e poi l'implementazione. Errore:

// Errore! Prima le firme, poi l'implementazione
function foo(a: number): number { return a } // errore
function foo(a: string): string { return a } // errore

TypeScript verifica i valori di ritorno in tutte le firme di overload?

TypeScript garantisce il ritorno dei tipi secondo le firme dichiarate solo al momento della compilazione; nessun controllo dei tipi avviene durante l'esecuzione.

È obbligatorio coprire tutte le varianti di input in un'unica implementazione?

La funzione di implementazione deve gestire correttamente tutte le varianti di input secondo le firme di overload:

function parse(a: number): string;
function parse(a: string): string;
function parse(a: number | string): string {
  return String(a);
}

Errori tipici e anti-pattern

Disallineamento tra implementazione e firme di overload
Ordine errato delle firme e implementazione
Gestione implicita/ignoranza delle combinazioni di tipi

Esempio dalla vita reale

Caso negativo

Sono state dichiarate più overload di una funzione con diversi tipi di input, ma l'implementazione non gestisce tutti i casi e genera un errore in runtime per input rari.

Vantaggi:

API flessibile per gli utenti della funzione

Svantaggi:

I tipi si compilano, ma il funzionamento della funzione è scorretto senza controlli aggiuntivi all'interno del corpo

Caso positivo

Ogni overload della funzione è coperta da una condizione sui tipi all'interno dell'implementazione, vengono utilizzati controlli di tipo (typeof/instanceof).