TypeScript Enum-alternativer: Const Assertions vs. Union Typer

TypeScript's enum er en stærk funktion til at definere et sæt navngivne konstanter. Det er dog ikke altid det bedste valg. Denne artikel udforsker alternativer til enums, specifikt const assertions og union typer, og giver vejledning i, hvornår man skal bruge hver især for optimal kodekvalitet, vedligeholdelse og ydeevne. Vi vil dykke ned i nuancerne ved hver tilgang, tilbyde praktiske eksempler og adressere almindelige bekymringer.

Forståelse af TypeScript Enums

Før vi dykker ned i alternativer, lad os hurtigt gennemgå TypeScript enums. En enum er en måde at definere et sæt navngivne numeriske konstanter på. Som standard tildeles det første enum-medlem værdien 0, og efterfølgende medlemmer øges med 1.

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

const currentStatus: Status = Status.InProgress; // currentStatus will be 1

            

              
                Copy
              
            
          

Du kan også eksplicit tildele værdier til enum-medlemmer:

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

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse will be 200

            

              
                Copy
              
            
          

Fordele ved Enums

• Læsbarhed: Enums forbedrer kodelæsbarheden ved at give meningsfulde navne til numeriske konstanter.
• Typesikkerhed: De håndhæver typesikkerhed ved at begrænse værdier til de definerede enum-medlemmer.
• Autoudfyldning: IDE'er giver autoudfyldningsforslag til enum-medlemmer, hvilket reducerer fejl.

Ulemper ved Enums

• Runtime Overhead: Enums kompileres til JavaScript-objekter, hvilket kan introducere runtime overhead, især i store applikationer.
• Mutabilitet: Enums er mutable som standard. Selvom TypeScript leverer const enum for at forhindre mutation, har det begrænsninger.
• Omvendt mapping: Numeriske enums skaber en omvendt mapping (f.eks. returnerer Status[1] "InProgress"), hvilket ofte er unødvendigt og kan øge bundlestørrelsen.

Alternativ 1: Const Assertions

Const assertions giver en måde at skabe uforanderlige, skrivebeskyttede datastrukturer på. De kan bruges som et alternativ til enums i mange tilfælde, især når du har brug for et simpelt sæt af streng- eller numeriske konstanter.

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

// Typescript infers the following type:
// {
//    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); // Valid
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'StatusType'.

            

              
                Copy
              
            
          

I dette eksempel definerer vi et almindeligt JavaScript-objekt med strengværdier. as const-assertionen fortæller TypeScript, at dette objekt skal behandles som skrivebeskyttet og udlede de mest specifikke typer for dets egenskaber. Vi udtrækker derefter en union-type fra nøglerne. Denne tilgang tilbyder flere fordele:

Fordele ved Const Assertions

• Uforanderlighed: Const assertions skaber uforanderlige datastrukturer, hvilket forhindrer utilsigtede ændringer.
• Ingen Runtime Overhead: De er simple JavaScript-objekter, så der er ingen runtime overhead forbundet med enums.
• Typesikkerhed: De giver stærk typesikkerhed ved at begrænse værdier til de definerede konstanter.
• Tree-shaking venlig: Moderne bundlere kan let "tree-shake" ubrugte værdier, hvilket reducerer bundlestørrelsen.

Overvejelser ved Const Assertions

• Mere verbose: Definition og typing kan være lidt mere verbose end enums, især for simple tilfælde.
• Ingen omvendt mapping: De giver ikke omvendt mapping, men dette er ofte en fordel snarere end en ulempe.

Alternativ 2: Union Typer

Union typer giver dig mulighed for at definere en variabel, der kan indeholde en af flere mulige typer. De er en mere direkte måde at definere de tilladte værdier på uden et objekt, hvilket er en fordel, når du ikke har brug for nøgle-værdi-forholdet i en enum eller const assertion.

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

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

processStatus('in_progress'); // Valid
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'Status'.

            

              
                Copy
              
            
          

Dette er en kortfattet og typesikker måde at definere et sæt tilladte værdier på.

Fordele ved Union Typer

• Kortfattethed: Union typer er den mest kortfattede tilgang, især for simple sæt af streng- eller numeriske konstanter.
• Typesikkerhed: De giver stærk typesikkerhed ved at begrænse værdier til de definerede muligheder.
• Ingen Runtime Overhead: Union typer eksisterer kun under kompilering og har ingen runtime-repræsentation.

Overvejelser ved Union Typer

• Ingen nøgle-værdi-relation: De giver ikke et nøgle-værdi-forhold som enums eller const assertions. Det betyder, at du ikke nemt kan slå en værdi op efter dens navn.
• Gentagelse af streng-litteraler: Du skal muligvis gentage streng-litteraler, hvis du bruger det samme sæt værdier flere steder. Dette kan afhjælpes med en delt `type` definition.

Hvornår skal man bruge hvad?

Den bedste tilgang afhænger af dine specifikke behov og prioriteter. Her er en guide til at hjælpe dig med at vælge:

• Brug Enums, når:
  • Du har brug for et simpelt sæt numeriske konstanter med implicit inkrementering.
  • Du har brug for omvendt mapping (selvom dette sjældent er nødvendigt).
  • Du arbejder med ældre kode, der allerede bruger enums i vid udstrækning, og du har intet presserende behov for at ændre det.
• Brug Const Assertions, når:
  • Du har brug for et sæt streng- eller numeriske konstanter, der skal være uforanderlige.
  • Du har brug for en nøgle-værdi-relation og ønsker at undgå runtime overhead.
  • Tree-shaking og bundlestørrelse er vigtige overvejelser.
• Brug Union Typer, når:
  • Du har brug for en enkel, kortfattet måde at definere et sæt tilladte værdier på.
  • Du ikke har brug for en nøgle-værdi-relation.
  • Ydeevne og bundlestørrelse er afgørende.

Eksempelsituation: Definition af brugerroller

Lad os overveje et scenarie, hvor du skal definere brugerroller i en applikation. Du kan have roller som "Admin", "Editor" og "Viewer".

Brug af Enums:

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

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

            

              
                Copy
              
            
          

Brug af Const Assertions:

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

type UserRoleType = typeof UserRole[keyof typeof UserRole];

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

            

              
                Copy
              
            
          

Brug af Union Typer:

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

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

            

              
                Copy
              
            
          

I dette scenarie tilbyder union typer den mest kortfattede og effektive løsning. Const assertions er et godt alternativ, hvis du foretrækker et nøgle-værdi-forhold, måske til opslag af beskrivelser af hver rolle. Enums anbefales generelt ikke her, medmindre du har et specifikt behov for numeriske værdier eller omvendt mapping.

Eksempelsituation: Definition af API-slutpunktsstatuskoder

Lad os overveje et scenarie, hvor du skal definere API-slutpunktsstatuskoder. Du kan have koder som 200 (OK), 400 (Bad Request), 401 (Unauthorized) og 500 (Internal Server Error).

Brug af Enums:

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

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

            

              
                Copy
              
            
          

Brug af 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
              
            
          

Brug af Union Typer:

            
type StatusCode = 200 | 400 | 401 | 500;

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

            

              
                Copy
              
            
          

Igen tilbyder union typer den mest kortfattede og effektive løsning. Const assertions er et stærkt alternativ og kan foretrækkes, da det giver en mere detaljeret beskrivelse for en given statuskode. Enums kan være nyttige, hvis eksterne biblioteker eller API'er forventer heltal-baserede statuskoder, og du ønsker at sikre problemfri integration. De numeriske værdier stemmer overens med standard HTTP-koder, hvilket potentielt forenkler interaktionen med eksisterende systemer.

Ydeevneovervejelser

I de fleste tilfælde er ydeevneforskellen mellem enums, const assertions og union typer ubetydelig. Men i ydeevnekritiske applikationer er det vigtigt at være opmærksom på de potentielle forskelle.

• Enums: Enums introducerer runtime overhead på grund af oprettelsen af JavaScript-objekter. Denne overhead kan være betydelig i store applikationer med mange enums.
• Const Assertions: Const assertions har ingen runtime overhead. De er simple JavaScript-objekter, der behandles som skrivebeskyttede af TypeScript.
• Union Typer: Union typer har ingen runtime overhead. De eksisterer kun under kompilering og slettes under kompileringen.

Hvis ydeevne er en stor bekymring, er union typer generelt det bedste valg. Const assertions er også en god mulighed, især hvis du har brug for en nøgle-værdi-relation. Undgå at bruge enums i ydeevnekritiske dele af din kode, medmindre du har en specifik grund til at gøre det.

Globale implikationer og bedste praksis

Når du arbejder på projekter med internationale teams eller globale brugere, er det afgørende at overveje lokalisering og internationalisering. Her er nogle bedste praksis for brug af enums og deres alternativer i en global kontekst:

• Brug beskrivende navne: Vælg enum-medlemsnavne (eller const assertion-nøgler), der er klare og utvetydige, selv for ikke-indfødte engelsktalende. Undgå slang eller fagsprog.
• Overvej lokalisering: Hvis du har brug for at vise enum-medlemsnavne til brugere, kan du overveje at bruge et lokaliseringsbibliotek til at levere oversættelser for forskellige sprog. For eksempel, i stedet for direkte at vise `Status.InProgress`, kan du f.eks. vise `i18n.t('status.in_progress')`.
• Undgå kulturspecifikke antagelser: Vær opmærksom på kulturelle forskelle, når du definerer enum-værdier. F.eks. kan datoformater, valutasymboler og måleenheder variere betydeligt på tværs af kulturer. Hvis du har brug for at repræsentere disse værdier, kan du overveje at bruge et bibliotek, der håndterer lokalisering og internationalisering.
• Dokumenter din kode: Giv klar og kortfattet dokumentation for dine enums og deres alternativer, der forklarer deres formål og brug. Dette vil hjælpe andre udviklere med at forstå din kode, uanset deres baggrund eller erfaring.

Eksempel: Lokalisering af brugerroller

Lad os genbesøge eksemplet med brugerroller og overveje, hvordan man lokaliserer rollenavnene for forskellige sprog.

            
// Using Const Assertions with Localization
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Localization function (using a hypothetical i18n library)
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 'Unknown Role';
  }
}

// Example usage
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Returns localized "Éditeur" for French Canadian.
console.log(`Current role: ${localizedRoleName}`);

            

              
                Copy
              
            
          

I dette eksempel bruger vi en lokaliseringsfunktion til at hente det oversatte rollenavn baseret på brugerens locale. Dette sikrer, at rollenavnene vises på brugerens foretrukne sprog.

Konklusion

TypeScript enums er en nyttig funktion, men de er ikke altid det bedste valg. Const assertions og union typer tilbyder levedygtige alternativer, der kan give bedre ydeevne, uforanderlighed og kodevedligeholdelse. Ved at forstå fordelene og ulemperne ved hver tilgang kan du træffe informerede beslutninger om, hvilken du skal bruge i dine projekter. Overvej de specifikke behov for din applikation, dit teams præferencer og den langsigtede vedligeholdelse af din kode. Ved omhyggeligt at afveje disse faktorer kan du vælge den bedste tilgang til at definere konstanter i dine TypeScript-projekter, hvilket fører til renere, mere effektive og mere vedligeholdelsesvenlige kodebaser.