TypeScript - Never: Comprendere il Tipo di Fondo

Ciao, aspiranti programmatori! Oggi andremo a esplorare uno dei tipi più enigmatici di TypeScript: il tipo never. Non preoccupatevi se siete nuovi alla programmazione - vi guiderò attraverso questo concetto passo dopo passo, proprio come ho fatto per centinaia di studenti negli anni della mia insegnamento. Quindi, prendete la vostra bevanda preferita e preparatevi per questa emozionante avventura nel mondo di TypeScript!

TypeScript - Never

Cos'è il tipo never?

Il tipo never in TypeScript è spesso chiamato il "tipo di fondo" o il "tipo vuoto". Rappresenta un tipo che non dovrebbe mai verificarsi. Ora, potreste essere pensando: "Perché avremmo bisogno di un tipo che non accade mai?" Beh, miei curiosi amici, è più utile di quanto possiate pensare!

Quando si usa never?

Per rappresentare scenari impossibili
Per gestire controlli esaustivi
In funzioni che non restituiscono mai un valore

Analizziamo alcuni esempi per rendere questi concetti più chiari.

Esempio 1: Rappresentare Scenari Impossibili

function throwError(message: string): never {
throw new Error(message);
}

let result = throwError("Oops! Something went wrong!");
console.log(result); // Questa riga non verrà mai raggiunta

In questo esempio, la funzione throwError è garantita per sollevare un errore e non restituire mai normalmente. Pertanto, il suo tipo di ritorno è never.

Pensateci così: se state cuocendo un cake e la ricetta dice "cuocete fino a never", sapete che quel cake non uscirà mai dal forno!

Esempio 2: Controlli Esaustivi

type Shape = "circle" | "square" | "triangle";

function getArea(shape: Shape): number {
switch (shape) {
case "circle":
return Math.PI * Math.pow(5, 2);
case "square":
return 10 * 10;
case "triangle":
return (10 * 5) / 2;
default:
const _exhaustiveCheck: never = shape;
return _exhaustiveCheck;
}
}

Qui, never ci aiuta a garantire che abbiamo coperto tutti i possibili形状. Se aggiungiamo una nuova forma al tipo Shape ma dimentichiamo di aggiungere un caso per essa in getArea, TypeScript ci darà un errore. È come avere un assistente utile che ci ricorda quando abbiamo dimenticato qualcosa!

Esempio 3: Funzioni Che Non Restituiscono Mai

function infiniteLoop(): never {
while (true) {
console.log("This loop never ends!");
}
}

Questa funzione funzionerà per sempre (o fino a quando il vostro computer esaurisce la memoria). Poiché non termina mai l'esecuzione, il suo tipo di ritorno è never. È come dire al vostro amico che smetterete di parlare "mai" - sanno che sono in per un conversazione lunga!

Il tipo never vs. void

Ora, potreste essere meravigliati, "Come è diverso never da void?" Ottima domanda! Analizziamo.

void

Il tipo void è usato quando una funzione non restituisce alcun valore, ma completa comunque l'esecuzione.

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

logMessage("Hello, TypeScript!"); // Questa funzione restituisce undefined

never

Il tipo never, d'altra parte, è usato quando una funzione non completa mai la sua esecuzione o sempre solleva un errore.

function failwithError(message: string): never {
throw new Error(message);
}

failwithError("This function never returns!");

Pensateci così: void è come andare in un negozio e tornare a mani vuote, mentre never è come intraprendere un viaggio senza destinazione - non torni mai indietro!

Usi Pratici di never

Analizziamo alcuni esempi più pratici dove never può essere utile.

Esempio 4: Type Guards

type Square = { kind: "square", size: number };
type Circle = { kind: "circle", radius: number };
type Shape = Square | Circle;

function assertNever(x: never): never {
throw new Error("Unexpected object: " + x);
}

function getArea(shape: Shape) {
switch (shape.kind) {
case "square": return shape.size * shape.size;
case "circle": return Math.PI * shape.radius ** 2;
default: return assertNever(shape); // Errore se shape non è né Square né Circle
}
}

In questo esempio, assertNever ci aiuta a catturare ogni caso che potremmo aver perso. È come avere una rete di sicurezza quando si impara a gjuggare i tipi!

Esempio 5: Rilevamento del Codice Irraggiungibile

function neverReaches(): never {
while (true) {
// Some operation
}
console.log("This line will never be reached");  // Errore di TypeScript
}

TypeScript è abbastanza intelligente da sapere che l'istruzione console.log non verrà mai raggiunta, e vi darà un errore. È come avere un GPS che vi dice quando state cercando di guidare in un luogo che non esiste!

Metodi e Proprietà di never

Ora, potreste essere meravigliati se never ha qualche metodo o proprietà. La verità è che never non ha metodi o proprietà propri perché rappresenta un tipo che non dovrebbe mai verificarsi. Tuttavia, è comunque una parte importante del sistema di tipi di TypeScript.

Ecco una tabella che riassume cosa potete (o non potete) fare con never:

Operazione	Risultato	Spiegazione
Assegnare a `never`	✅ Consentito	Qualsiasi tipo può essere assegnato a `never`
Assegnare `never` ad altri tipi	❌ Non Consentito	`never` non può essere assegnato ad alcun altro tipo
Chiamare metodi su `never`	❌ Non Consentito	Poiché `never` non dovrebbe mai verificarsi, non si possono chiamare metodi su di esso
Usare `never` in unioni	✅ Consentito ma ha nessun effetto	`never` è ignorato nei tipi di unione
Usare `never` in intersezioni	✅ Consentito e risultati in `never`	Qualsiasi tipo intersecato con `never` risulta in `never`

Conclusione

Eccoci qui, miei cari studenti! Abbiamo viaggiato attraverso il paese del never, esplorandone i meandri. Ricordate, never è come quell'amico che sempre annulla i piani - non si presenta mai, ma è comunque importante tenerlo a mente!

Comprendere never potrebbe sembrare complicato all'inizio, ma con la pratica, scoprirete che è uno strumento inestimabile nel vostro arsenale di TypeScript. Aiuta a rendere il vostro codice più robusto, cattura potenziali errori e vi fa pensare più a fondo al comportamento delle vostre funzioni.

Continuate a programmare, continuate a imparare, e non dite mai di no a provare nuove cose in TypeScript! Fino alla prossima volta, che i vostri errori di compilazione siano pochi e le vostre inferenze di tipo siano forti!

Credits: Image by storyset