TypeScript - Enumerazioni: Una Guida per Principianti

Ciao, futuri programmatori! Oggi ci immergeremo nel meraviglioso mondo delle enumerazioni di TypeScript. Non preoccupatevi se non avete mai programmato prima - sarò il vostro guida amichevole in questo viaggio, proprio come ho fatto per innumerevoli studenti negli anni della mia insegnanza. Allora, iniziamo!

Cos'è un'Enum?

Prima di tuffarci nei diversi tipi di Enumerazioni, capiremo cosa sono. Immagina di organizzare il tuo armadio. Potresti avere diverse categorie per i tuoi vestiti: magliette, pantaloni, scarpe, ecc. Le Enumerazioni in TypeScript sono come queste categorie - ci aiutano a raggruppare valori correlati e a dare loro nomi significativi.

Enumerazioni Numeriche

Le Enumerazioni Numeriche sono il tipo più comune di Enumerazioni in TypeScript. Sono come assegnare numeri ai tuoi supereroi preferiti.

enum Supereroi {
Superman,
Batman,
WonderWoman,
Flash
}

console.log(Supereroi.Superman);  // Output: 0
console.log(Supereroi.Batman);    // Output: 1
console.log(Supereroi.WonderWoman);  // Output: 2
console.log(Supereroi.Flash);     // Output: 3

In questo esempio, TypeScript assegna automaticamente numeri a partire da 0. Superman ottiene 0, Batman ottiene 1, e così via. È come se stessero facendo la coda per una foto di gruppo, e noi stiamo dando loro numeri in base alla loro posizione!

Ma cosa succede se vogliamo iniziare con un numero diverso? Nessun problema! Possiamo farlo anche:

enum Cattivi {
Joker = 1,
LexLuthor,
Cheetah,
ReverseFlash
}

console.log(Cattivi.Joker);        // Output: 1
console.log(Cattivi.LexLuthor);    // Output: 2
console.log(Cattivi.Cheetah);      // Output: 3
console.log(Cattivi.ReverseFlash); // Output: 4

Qui, abbiamo detto a TypeScript di iniziare a contare da 1 per Joker, e ha automaticamente continuato per il resto.

Enumerazioni Stringhe

Ora, immagina di non essere un fan dei numeri e di preferire le parole. È qui che le Enumerazioni Stringhe diventano utili. Sono come dare ai tuoi animali domestici soprannomi!

enum NomiAnimali {
Dog = "BUDDY",
Cat = "WHISKERS",
Fish = "BUBBLES",
Bird = "TWEETY"
}

console.log(NomiAnimali.Dog);   // Output: "BUDDY"
console.log(NomiAnimali.Cat);   // Output: "WHISKERS"
console.log(NomiAnimali.Fish);  // Output: "BUBBLES"
console.log(NomiAnimali.Bird);  // Output: "TWEETY"

Con le Enumerazioni Stringhe, dobbiamo assegnare un valore a ciascun membro. È come assicurarsi che ciascuno dei tuoi animali domestici conosca il loro soprannome speciale!

Enumerazioni Eterogenee

A volte, la vita non è solo numeri o solo stringhe - è un mix! Le Enumerazioni Eterogenee sono come una scatola di cioccolatini assortiti - ottieni un po' di tutto.

enum MixedBag {
Number = 1,
String = "STRING",
AnotherNumber = 2
}

console.log(MixedBag.Number);        // Output: 1
console.log(MixedBag.String);        // Output: "STRING"
console.log(MixedBag.AnotherNumber); // Output: 2

Sebbene questo sia possibile, è generalmente consigliato stickare a numeri o stringhe per mantenere la coerenza in un'Enum.

Enumerazioni a Run Time

Una cosa fantastica delle Enumerazioni è che esistono a run time. Questo significa che puoi usarle nel tuo codice proprio come faresti con qualsiasi altro oggetto!

enum Frutti {
Apple,
Banana,
Orange
}

function getFruitName(fruit: Frutti): string {
return Frutti[fruit];
}

console.log(getFruitName(Frutti.Apple));  // Output: "Apple"
console.log(getFruitName(Frutti.Banana)); // Output: "Banana"

Qui, stiamo usando l'Enum come se fosse un oggetto JavaScript regolare. È come avere un dizionario magico che può tradurre numeri in nomi di frutti!

Enumerazioni a Tempo di Compilazione

Le Enumerazioni brillano anche a tempo di compilazione. Aiutano TypeScript a catturare errori prima che il codice venga eseguito!

enum GiorniSettimana {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}

let day: GiorniSettimana = GiorniSettimana.Monday;
day = GiorniSettimana.Friday;  // Questo va bene

// day = "Monday";  // Errore: Type '"Monday"' is not assignable to type 'GiorniSettimana'.

TypeScript ti darà un errore se provi ad assegnare un valore che non fa parte dell'Enum. È come avere un bouncer severo in un club che lascia entrare solo i giorni della settimana!

Enumerazioni Ambienti

Le Enumerazioni Ambienti sono un po' speciali. Si usano quando stai dicendo a TypeScript delle Enumerazioni che esistono da qualche altra parte nel tuo codice o in una libreria che stai utilizzando.

declare enum EnumEsterno {
A = 1,
B,
C = 2
}

La parola chiave declare è come dire, "Ehi TypeScript, fidati di me, questa Enum esiste da qualche altra parte nel codice." È utile quando stai lavorando con codice che non è scritto in TypeScript.

Oggetti vs. Enumerazioni

Potresti chiederti, "Perché non usare semplicemente oggetti?" Beh, le Enumerazioni hanno alcuni vantaggi:

// Utilizzando un oggetto
const ColorObject = {
Red: 'RED',
Green: 'GREEN',
Blue: 'BLUE'
} as const;

// Utilizzando un'Enum
enum ColorEnum {
Red = 'RED',
Green = 'GREEN',
Blue = 'BLUE'
}

// Con gli oggetti, hai bisogno di type assertions
let objColor: keyof typeof ColorObject = 'Red';

// Con le Enumerazioni, è più diretto
let enumColor: ColorEnum = ColorEnum.Red;

Le Enumerazioni forniscono una migliore sicurezza dei tipi e sono più concise in molti casi.

Utilizzo delle Enumerazioni come Parametri di Funzione

Le Enumerazioni sono fantastiche per i parametri delle funzioni. Rendono il tuo codice più leggibile e prevengono errori:

enum Dimensioni {
Small,
Medium,
Large
}

function orderCoffee(size: Dimensioni): string {
switch(size) {
case Dimensioni.Small:
return "Here's your small coffee!";
case Dimensioni.Medium:
return "One medium coffee coming right up!";
case Dimensioni.Large:
return "Large coffee, extra caffeine!";
default:
return "We don't have that size!";
}
}

console.log(orderCoffee(Dimensioni.Medium));  // Output: "One medium coffee coming right up!"
// console.log(orderCoffee("Venti"));    // Errore: Argument of type '"Venti"' is not assignable to parameter of type 'Dimensioni'.

Utilizzando un'Enum per il parametro di dimensione, assicuriamo che solo le dimensioni valide possano essere passate alla funzione. È come avere un menu con opzioni fisse - senza confusione su quali dimensioni sono disponibili!

Metodi delle Enumerazioni

Ecco una tabella di metodi utili per lavorare con le Enumerazioni:

Metodo	Descrizione	Esempio
Object.keys()	Ottieni tutte le chiavi di un'Enum	Object.keys(Dimensioni)
Object.values()	Ottieni tutti i valori di un'Enum	Object.values(Dimensioni)
Object.entries()	Ottieni le coppie chiave-valore di un'Enum	Object.entries(Dimensioni)
Enum[key]	Ottieni il valore per una chiave	Dimensioni[Dimensioni.Small]
Enum[value]	Ottieni la chiave per un valore (per Enumerazioni numeriche)	Dimensioni[0]

Questi metodi ti aiutano a lavorare con le Enumerazioni in diversi modi, come ottenere tutte le dimensioni disponibili o trovare il nome di una dimensione dal suo valore.

Ecco fatto! Hai appena fatto i tuoi primi passi nel mondo delle Enumerazioni di TypeScript. Ricorda, programmare è come imparare una nuova lingua - richiede pratica, ma presto sarai fluente in Enum-speak! Continua a programmare, rimani curioso e non dimenticare di divertirti lungo il percorso. Chi lo sa, magari creerai un'Enum per i tuoi gusti di gelato preferiti prossimamente!

Credits: Image by storyset