Alternative agli Enum in TypeScript: Const Assertions vs. Union Types

L'enum di TypeScript è una funzionalità potente per definire un insieme di costanti nominate. Tuttavia, non è sempre la scelta migliore. Questo articolo esplora alternative agli enum, in particolare le const assertions e gli union types, e fornisce indicazioni su quando utilizzare ciascuna per una qualità del codice, manutenibilità e prestazioni ottimali. Approfondiremo le sfumature di ciascun approccio, offrendo esempi pratici e affrontando preoccupazioni comuni.

Comprendere gli Enum di TypeScript

Prima di addentrarci nelle alternative, rivediamo rapidamente gli enum di TypeScript. Un enum è un modo per definire un insieme di costanti numeriche nominate. Per impostazione predefinita, al primo membro dell'enum viene assegnato il valore 0, e ai membri successivi viene incrementato di 1.

            
enum Status {
  Pending,
  InProgress,
  Completed,
  Rejected,
}

const currentStatus: Status = Status.InProgress; // currentStatus sarà 1

            

              
                Copy
              
            
          

Puoi anche assegnare esplicitamente valori ai membri dell'enum:

            
enum HTTPStatus {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  Forbidden = 403,
  NotFound = 404,
}

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse sarà 200

            

              
                Copy
              
            
          

Vantaggi degli Enum

• Leggibilità: Gli enum migliorano la leggibilità del codice fornendo nomi significativi per le costanti numeriche.
• Type Safety: Impongono la type safety limitando i valori ai membri dell'enum definiti.
• Autocompletamento: Gli IDE forniscono suggerimenti di autocompletamento per i membri dell'enum, riducendo gli errori.

Svantaggi degli Enum

• Overhead a runtime: Gli enum vengono compilati in oggetti JavaScript, il che può introdurre un overhead a runtime, specialmente in applicazioni di grandi dimensioni.
• Mutabilità: Gli enum sono mutabili per impostazione predefinita. Sebbene TypeScript fornisca const enum per prevenire la mutabilità, presenta delle limitazioni.
• Mappatura inversa: Gli enum numerici creano una mappatura inversa (ad esempio, Status[1] restituisce "InProgress"), che è spesso non necessaria e può aumentare le dimensioni del bundle.

Alternativa 1: Const Assertions

Le const assertions forniscono un modo per creare strutture dati immutabili e readonly. Possono essere utilizzate come alternativa agli enum in molti casi, specialmente quando è necessario un semplice insieme di costanti stringa o numeriche.

            
const Status = {
  Pending: 'pending',
  InProgress: 'in_progress',
  Completed: 'completed',
  Rejected: 'rejected',
} as const;

// Typescript inferisce il seguente tipo:
// {
//    readonly Pending: "pending";
//    readonly InProgress: "in_progress";
//    readonly Completed: "completed";
//    readonly Rejected: "rejected";
// }

type StatusType = typeof Status[keyof typeof Status]; // 'pending' | 'in_progress' | 'completed' | 'rejected'

function processStatus(status: StatusType) {
  console.log(`Processing status: ${status}`);
}

processStatus(Status.InProgress); // Valido
// processStatus('invalid'); // Errore: l'argomento di tipo "invalid" non è assegnabile al parametro di tipo 'StatusType'.

            

              
                Copy
              
            
          

In questo esempio, definiamo un semplice oggetto JavaScript con valori stringa. L'asserzione as const dice a TypeScript di trattare questo oggetto come readonly e di inferire i tipi più specifici per le sue proprietà. Successivamente, estraiamo un tipo di unione dalle chiavi. Questo approccio offre diversi vantaggi:

Vantaggi delle Const Assertions

• Immutabilità: Le const assertions creano strutture dati immutabili, prevenendo modifiche accidentali.
• Nessun overhead a runtime: Sono semplici oggetti JavaScript, quindi non c'è alcun overhead a runtime associato agli enum.
• Type Safety: Forniscono una forte type safety limitando i valori alle costanti definite.
• Adatte al tree-shaking: I bundler moderni possono facilmente effettuare il tree-shaking dei valori non utilizzati, riducendo le dimensioni del bundle.

Considerazioni per le Const Assertions

• Più verbose: La definizione e la tipizzazione possono essere leggermente più verbose rispetto agli enum, specialmente per casi semplici.
• Nessuna mappatura inversa: Non forniscono una mappatura inversa, ma questo è spesso un vantaggio piuttosto che uno svantaggio.

Alternativa 2: Union Types

Gli union types consentono di definire una variabile che può contenere uno tra diversi tipi possibili. Sono un modo più diretto per definire i valori consentiti senza un oggetto, il che è vantaggioso quando non si necessita della relazione chiave-valore di un enum o di una const assertion.

            
type Status = 'pending' | 'in_progress' | 'completed' | 'rejected';

function processStatus(status: Status) {
  console.log(`Processing status: ${status}`);
}

processStatus('in_progress'); // Valido
// processStatus('invalid'); // Errore: l'argomento di tipo "invalid" non è assegnabile al parametro di tipo 'Status'.

            

              
                Copy
              
            
          

Questo è un modo conciso e type-safe per definire un insieme di valori consentiti.

Vantaggi degli Union Types

• Concisinezza: Gli union types sono l'approccio più conciso, specialmente per semplici insiemi di costanti stringa o numeriche.
• Type Safety: Forniscono una forte type safety limitando i valori alle opzioni definite.
• Nessun overhead a runtime: Gli union types esistono solo a tempo di compilazione e non hanno rappresentazione a runtime.

Considerazioni per gli Union Types

• Nessuna associazione chiave-valore: Non forniscono una relazione chiave-valore come gli enum o le const assertions. Ciò significa che non è possibile recuperare facilmente un valore dal suo nome.
• Ripetizione di letterali stringa: Potrebbe essere necessario ripetere i letterali stringa se si utilizza lo stesso insieme di valori in più punti. Questo può essere mitigato con una definizione di `type` condivisa.

Quando Usare Cosa?

L'approccio migliore dipende dalle tue esigenze e priorità specifiche. Ecco una guida per aiutarti a scegliere:

• Usa gli Enum quando:
  • Hai bisogno di un semplice insieme di costanti numeriche con incremento implicito.
  • Hai bisogno di mappatura inversa (anche se questo è raramente necessario).
  • Stai lavorando con codice legacy che utilizza già ampiamente gli enum e non hai un'urgenza impellente di cambiarlo.
• Usa le Const Assertions quando:
  • Hai bisogno di un insieme di costanti stringa o numeriche che devono essere immutabili.
  • Hai bisogno di una relazione chiave-valore e vuoi evitare l'overhead a runtime.
  • Il tree-shaking e le dimensioni del bundle sono considerazioni importanti.
• Usa gli Union Types quando:
  • Hai bisogno di un modo semplice e conciso per definire un insieme di valori consentiti.
  • Non hai bisogno di una relazione chiave-valore.
  • Le prestazioni e le dimensioni del bundle sono critiche.

Scenario di Esempio: Definire Ruoli Utente

Consideriamo uno scenario in cui è necessario definire i ruoli utente in un'applicazione. Potresti avere ruoli come "Admin", "Editor" e "Viewer".

Usando gli Enum:

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Usando le Const Assertions:

            
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

function authorize(role: UserRoleType) {
  // ...
}

            

              
                Copy
              
            
          

Usando gli Union Types:

            
type UserRole = 'admin' | 'editor' | 'viewer';

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

In questo scenario, gli union types offrono la soluzione più concisa ed efficiente. Le const assertions sono una buona alternativa se si preferisce una relazione chiave-valore, magari per recuperare descrizioni di ciascun ruolo. Gli enum sono generalmente sconsigliati qui a meno che non si abbia una necessità specifica per valori numerici o mappatura inversa.

Scenario di Esempio: Definire Codici di Stato degli Endpoint API

Consideriamo uno scenario in cui è necessario definire i codici di stato degli endpoint API. Potresti avere codici come 200 (OK), 400 (Bad Request), 401 (Unauthorized) e 500 (Internal Server Error).

Usando gli Enum:

            
enum StatusCode {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  InternalServerError = 500
}

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Usando le Const Assertions:

            
const StatusCode = {
  OK: 200,
  BadRequest: 400,
  Unauthorized: 401,
  InternalServerError: 500
} as const;

type StatusCodeType = typeof StatusCode[keyof typeof StatusCode];

function processStatus(code: StatusCodeType) {
  // ...
}

            

              
                Copy
              
            
          

Usando gli Union Types:

            
type StatusCode = 200 | 400 | 401 | 500;

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Ancora una volta, gli union types offrono la soluzione più concisa ed efficiente. Le const assertions sono una solida alternativa e potrebbero essere preferite in quanto forniscono una descrizione più verbosa per un dato codice di stato. Gli enum potrebbero essere utili se librerie esterne o API si aspettano codici di stato basati su interi, e si desidera garantire un'integrazione senza problemi. I valori numerici si allineano con i codici HTTP standard, semplificando potenzialmente l'interazione con i sistemi esistenti.

Considerazioni sulle Prestazioni

Nella maggior parte dei casi, la differenza di prestazioni tra enum, const assertions e union types è trascurabile. Tuttavia, in applicazioni critiche per le prestazioni, è importante essere consapevoli delle potenziali differenze.

• Enum: Gli enum introducono un overhead a runtime dovuto alla creazione di oggetti JavaScript. Questo overhead può essere significativo in applicazioni di grandi dimensioni con molti enum.
• Const Assertions: Le const assertions non hanno overhead a runtime. Sono semplici oggetti JavaScript trattati come readonly da TypeScript.
• Union Types: Gli union types non hanno overhead a runtime. Esistono solo a tempo di compilazione e vengono eliminati durante la compilazione.

Se le prestazioni sono una preoccupazione maggiore, gli union types sono generalmente la scelta migliore. Le const assertions sono anche una buona opzione, specialmente se hai bisogno di una relazione chiave-valore. Evita di usare gli enum in sezioni del tuo codice critiche per le prestazioni a meno che tu non abbia una ragione specifica per farlo.

Implicazioni Globali e Best Practice

Quando si lavora su progetti con team internazionali o utenti globali, è fondamentale considerare la localizzazione e l'internazionalizzazione. Ecco alcune best practice per l'utilizzo degli enum e delle loro alternative in un contesto globale:

• Utilizzare nomi descrittivi: Scegli nomi di membri dell'enum (o chiavi di const assertion) che siano chiari e inequivocabili, anche per i non madrelingua inglesi. Evita slang o gergo.
• Considerare la localizzazione: Se è necessario visualizzare i nomi dei membri dell'enum agli utenti, considera l'utilizzo di una libreria di localizzazione per fornire traduzioni per diverse lingue. Ad esempio, invece di visualizzare direttamente `Status.InProgress`, potresti visualizzare `i18n.t('status.in_progress')`.
• Evitare assunzioni culturali specifiche: Sii consapevole delle differenze culturali quando definisci i valori dell'enum. Ad esempio, i formati delle date, i simboli valutari e le unità di misura possono variare significativamente tra le culture. Se è necessario rappresentare questi valori, considera l'utilizzo di una libreria che gestisca la localizzazione e l'internazionalizzazione.
• Documentare il tuo codice: Fornisci documentazione chiara e concisa per i tuoi enum e le loro alternative, spiegando il loro scopo e utilizzo. Questo aiuterà altri sviluppatori a comprendere il tuo codice, indipendentemente dal loro background o dalla loro esperienza.

Esempio: Localizzare i Ruoli Utente

Riconsideriamo l'esempio dei ruoli utente e vediamo come localizzare i nomi dei ruoli per diverse lingue.

            
// Uso delle Const Assertions con Localizzazione
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Funzione di localizzazione (utilizzando una libreria i18n ipotetica)
function getLocalizedRoleName(role: UserRoleType, locale: string): string {
  switch (role) {
    case UserRole.Admin:
      return i18n.t('user_role.admin', { locale });
    case UserRole.Editor:
      return i18n.t('user_role.editor', { locale });
    case UserRole.Viewer:
      return i18n.t('user_role.viewer', { locale });
    default:
      return 'Ruolo Sconosciuto';
  }
}

// Esempio d'uso
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Restituisce "Éditeur" localizzato per il francese canadese.
console.log(`Ruolo corrente: ${localizedRoleName}`);

            

              
                Copy
              
            
          

In questo esempio, utilizziamo una funzione di localizzazione per recuperare il nome del ruolo tradotto in base alla locale dell'utente. Ciò garantisce che i nomi dei ruoli vengano visualizzati nella lingua preferita dall'utente.

Conclusione

Gli enum di TypeScript sono una funzionalità utile, ma non sono sempre la scelta migliore. Le const assertions e gli union types offrono alternative valide che possono fornire migliori prestazioni, immutabilità e manutenibilità del codice. Comprendendo i vantaggi e gli svantaggi di ciascun approccio, puoi prendere decisioni informate su quale utilizzare nei tuoi progetti. Considera le esigenze specifiche della tua applicazione, le preferenze del tuo team e la manutenibilità a lungo termine del tuo codice. Ponderando attentamente questi fattori, puoi scegliere l'approccio migliore per definire le costanti nei tuoi progetti TypeScript, portando a codebase più pulite, efficienti e manutenibili.