TypeScripti Enum'i Alternatiivid: Const Assertions vs. Union Types

TypeScripti enum on võimas funktsioon nimetatud konstantide kogumi defineerimiseks. Siiski pole see alati parim valik. See artikkel uurib enum'ide alternatiive, täpsemalt const assertions ja union types, ning annab juhiseid, millal neid kasutada optimaalse koodikvaliteedi, hooldatavuse ja jõudluse tagamiseks. Süveneme iga lähenemise nüanssidesse, pakkudes praktilisi näiteid ja käsitledes levinud muresid.

TypeScripti Enum'ide Mõistmine

Enne alternatiividesse süvenemist vaatame kiirelt üle TypeScripti enum'id. Enum on viis defineerida nimetatud numbriliste konstantide kogum. Vaikimisi omistatakse esimesele enum'i liikmele väärtus 0 ja järgmised liikmed suurenevad 1 võrra.

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

const currentStatus: Status = Status.InProgress; // currentStatus väärtus on 1

            

              
                Copy
              
            
          

Saate ka enum'i liikmetele väärtusi selgesõnaliselt omistada:

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

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse väärtus on 200

            

              
                Copy
              
            
          

Enum'ide Eelised

• Loetavus: Enum'id parandavad koodi loetavust, andes numbrilistele konstantidele tähenduslikud nimed.
• Tüübikindlus: Need tagavad tüübikindluse, piirates väärtusi defineeritud enum'i liikmetega.
• Automaatne täiendamine: IDE-d pakuvad enum'i liikmete jaoks automaatse täiendamise soovitusi, mis vähendab vigu.

Enum'ide Puudused

• Käitusaja lisakulu: Enum'id kompileeritakse JavaScripti objektideks, mis võib tekitada käitusaja lisakulu, eriti suurtes rakendustes.
• Muudetavus: Enum'id on vaikimisi muudetavad. Kuigi TypeScript pakub mutatsiooni vältimiseks const enum'i, on sellel piirangud.
• Pöördvastendus: Numbrilised enum'id loovad pöördvastenduse (nt Status[1] tagastab "InProgress"), mis on sageli ebavajalik ja võib suurendada paketi suurust.

Alternatiiv 1: Const Assertions

Const assertions pakuvad võimalust luua muutumatuid, kirjutuskaitstud andmestruktuure. Neid saab paljudel juhtudel kasutada enum'ide alternatiivina, eriti kui vajate lihtsat string- või numbriliste konstantide kogumit.

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

// Typescript järeldab järgmise tüübi:
// {
//    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); // Kehtiv
// processStatus('invalid'); // Viga: Argument tüübiga '"invalid"' ei ole omistatav parameetrile tüübiga 'StatusType'.

            

              
                Copy
              
            
          

Selles näites defineerime tavalise JavaScripti objekti string-väärtustega. as const väide ütleb TypeScriptile, et see käsitleks seda objekti kirjutuskaitstuna ja järeldaks selle omaduste jaoks kõige spetsiifilisemad tüübid. Seejärel eraldame võtmetest union-tüübi. See lähenemine pakub mitmeid eeliseid:

Const Assertions'i Eelised

• Muutumatus: Const assertions loovad muutumatuid andmestruktuure, vältides juhuslikke muudatusi.
• Käitusaja lisakulu puudumine: Need on lihtsad JavaScripti objektid, seega puudub enum'idega seotud käitusaja lisakulu.
• Tüübikindlus: Need pakuvad tugevat tüübikindlust, piirates väärtusi defineeritud konstantidega.
• Tree-shaking sõbralik: Kaasaegsed bundler'id saavad kasutamata väärtused kergesti eemaldada (tree-shake), vähendades paketi suurust.

Const Assertions'i Kaalutlused

• Sõnaohtram: Defineerimine ja tüüpide määramine võib olla veidi sõnaohtram kui enum'ide puhul, eriti lihtsamatel juhtudel.
• Pöördvastenduse puudumine: Need ei paku pöördvastendust, kuid see on sageli pigem eelis kui puudus.

Alternatiiv 2: Union Types

Union types võimaldavad teil defineerida muutuja, mis võib omada ühte mitmest võimalikust tüübist. See on otsesem viis lubatud väärtuste defineerimiseks ilma objektita, mis on kasulik, kui te ei vaja enum'i või const assertion'i võtme-väärtuse seost.

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

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

processStatus('in_progress'); // Kehtiv
// processStatus('invalid'); // Viga: Argument tüübiga '"invalid"' ei ole omistatav parameetrile tüübiga 'Status'.

            

              
                Copy
              
            
          

See on lühike ja tüübikindel viis lubatud väärtuste kogumi defineerimiseks.

Union Types'i Eelised

• Lühidus: Union types on kõige lühem lähenemine, eriti lihtsate string- või numbriliste konstantide kogumite puhul.
• Tüübikindlus: Need pakuvad tugevat tüübikindlust, piirates väärtusi defineeritud valikutega.
• Käitusaja lisakulu puudumine: Union types eksisteerivad ainult kompileerimise ajal ja neil pole käitusajal esitust.

Union Types'i Kaalutlused

• Võtme-väärtuse seose puudumine: Need ei paku võtme-väärtuse seost nagu enum'id või const assertions. See tähendab, et te ei saa väärtust selle nime järgi kergesti otsida.
• Stringiliteraalide kordamine: Võib osutuda vajalikuks korrata stringiliteraale, kui kasutate sama väärtuste kogumit mitmes kohas. Seda saab leevendada jagatud type definitsiooniga.

Millal Mida Kasutada?

Parim lähenemine sõltub teie konkreetsetest vajadustest ja prioriteetidest. Siin on juhend, mis aitab teil valida:

• Kasutage Enum'e, kui:
  • Vajate lihtsat numbriliste konstantide kogumit kaudse inkrementimisega.
  • Vajate pöördvastendust (kuigi seda on harva vaja).
  • Töötate pärandkoodiga, mis juba kasutab enum'e laialdaselt ja teil pole tungivat vajadust seda muuta.
• Kasutage Const Assertions'it, kui:
  • Vajate string- või numbriliste konstantide kogumit, mis peaks olema muutumatu.
  • Vajate võtme-väärtuse seost ja soovite vältida käitusaja lisakulu.
  • Tree-shaking ja paketi suurus on olulised kaalutlused.
• Kasutage Union Types'i, kui:
  • Vajate lihtsat ja lühikest viisi lubatud väärtuste kogumi defineerimiseks.
  • Te ei vaja võtme-väärtuse seost.
  • Jõudlus ja paketi suurus on kriitilise tähtsusega.

Näidisstsenaarium: Kasutajarollide Defineerimine

Vaatleme stsenaariumi, kus peate rakenduses defineerima kasutajarollid. Teil võivad olla rollid nagu "Admin", "Editor" ja "Viewer".

Enum'ide Kasutamine:

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

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

            

              
                Copy
              
            
          

Const Assertions'i Kasutamine:

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

type UserRoleType = typeof UserRole[keyof typeof UserRole];

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

            

              
                Copy
              
            
          

Union Types'i Kasutamine:

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

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

            

              
                Copy
              
            
          

Selles stsenaariumis pakuvad union types kõige lühemat ja tõhusamat lahendust. Const assertions on hea alternatiiv, kui eelistate võtme-väärtuse seost, näiteks iga rolli kirjelduste otsimiseks. Enum'e siin üldiselt ei soovitata, välja arvatud juhul, kui teil on spetsiifiline vajadus numbriliste väärtuste või pöördvastenduse järele.

Näidisstsenaarium: API Lõpp-punkti Staatuskoodide Defineerimine

Vaatleme stsenaariumi, kus peate defineerima API lõpp-punkti staatuskoodid. Teil võivad olla koodid nagu 200 (OK), 400 (Bad Request), 401 (Unauthorized) ja 500 (Internal Server Error).

Enum'ide Kasutamine:

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

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

            

              
                Copy
              
            
          

Const Assertions'i Kasutamine:

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

type StatusCodeType = typeof StatusCode[keyof typeof StatusCode];

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

            

              
                Copy
              
            
          

Union Types'i Kasutamine:

            
type StatusCode = 200 | 400 | 401 | 500;

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

            

              
                Copy
              
            
          

Jällegi, union types pakuvad kõige lühemat ja tõhusamat lahendust. Const assertions on tugev alternatiiv ja võib olla eelistatud, kuna see annab antud staatuskoodile sõnaohtrama kirjelduse. Enum'id võivad olla kasulikud, kui välised teegid või API-d ootavad täisarvupõhiseid staatuskoode ja soovite tagada sujuva integratsiooni. Numbrilised väärtused ühtivad standardsete HTTP-koodidega, mis võib potentsiaalselt lihtsustada suhtlust olemasolevate süsteemidega.

Jõudlusega Seotud Kaalutlused

Enamikul juhtudel on jõudluse erinevus enum'ide, const assertions'i ja union types'i vahel tühine. Siiski, jõudluskriitilistes rakendustes on oluline olla teadlik potentsiaalsetest erinevustest.

• Enum'id: Enum'id tekitavad käitusaja lisakulu JavaScripti objektide loomise tõttu. See lisakulu võib olla märkimisväärne suurtes rakendustes, kus on palju enum'e.
• Const Assertions: Const assertions'il puudub käitusaja lisakulu. Need on lihtsad JavaScripti objektid, mida TypeScript käsitleb kirjutuskaitstuna.
• Union Types: Union types'il puudub käitusaja lisakulu. Need eksisteerivad ainult kompileerimise ajal ja kustutatakse kompileerimise käigus.

Kui jõudlus on peamine murekoht, on union types üldiselt parim valik. Const assertions on samuti hea valik, eriti kui vajate võtme-väärtuse seost. Vältige enum'ide kasutamist oma koodi jõudluskriitilistes osades, välja arvatud juhul, kui teil on selleks konkreetne põhjus.

Globaalsed Mõjud ja Parimad Praktikad

Kui töötate rahvusvaheliste meeskondade või globaalsete kasutajatega projektides, on ülioluline arvestada lokaliseerimise ja rahvusvahelistamisega. Siin on mõned parimad praktikad enum'ide ja nende alternatiivide kasutamiseks globaalses kontekstis:

• Kasutage kirjeldavaid nimesid: Valige enum'i liikmete nimed (või const assertion'i võtmed), mis on selged ja üheselt mõistetavad ka neile, kelle emakeel ei ole inglise keel. Vältige slängi või erialakeelt.
• Arvestage lokaliseerimisega: Kui peate kasutajatele kuvama enum'i liikmete nimesid, kaaluge lokaliseerimisteegi kasutamist, et pakkuda tõlkeid erinevatesse keeltesse. Näiteks selle asemel, et kuvada otse Status.InProgress, võiksite kuvada i18n.t('status.in_progress').
• Vältige kultuurispetsiifilisi eeldusi: Olge enum'i väärtuste defineerimisel teadlik kultuurilistest erinevustest. Näiteks kuupäevavormingud, valuutasümbolid ja mõõtühikud võivad kultuuriti oluliselt erineda. Kui teil on vaja neid väärtusi esitada, kaaluge teegi kasutamist, mis tegeleb lokaliseerimise ja rahvusvahelistamisega.
• Dokumenteerige oma kood: Pakkuge oma enum'idele ja nende alternatiividele selget ja lühikest dokumentatsiooni, selgitades nende eesmärki ja kasutamist. See aitab teistel arendajatel teie koodi mõista, olenemata nende taustast või kogemusest.

Näide: Kasutajarollide Lokaliseerimine

Vaatame uuesti kasutajarollide näidet ja kaalume, kuidas rollide nimesid erinevate keelte jaoks lokaliseerida.

            
// Const Assertions'i kasutamine koos lokaliseerimisega
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Lokaliseerimisfunktsioon (kasutades hüpoteetilist i18n teeki)
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';
  }
}

// Kasutusnäide
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Tagastab lokaliseeritud "Éditeur" prantsuse-kanada keele jaoks.
console.log(`Current role: ${localizedRoleName}`);

            

              
                Copy
              
            
          

Selles näites kasutame lokaliseerimisfunktsiooni, et hankida tõlgitud rolli nimi kasutaja lokaadi põhjal. See tagab, et rollide nimed kuvatakse kasutaja eelistatud keeles.

Kokkuvõte

TypeScripti enum'id on kasulik funktsioon, kuid need ei ole alati parim valik. Const assertions ja union types pakuvad elujõulisi alternatiive, mis võivad pakkuda paremat jõudlust, muutumatust ja koodi hooldatavust. Mõistes iga lähenemise eeliseid ja puudusi, saate teha teadlikke otsuseid, millist neist oma projektides kasutada. Arvestage oma rakenduse spetsiifiliste vajaduste, meeskonna eelistuste ja koodi pikaajalise hooldatavusega. Neid tegureid hoolikalt kaaludes saate valida parima lähenemise konstantide defineerimiseks oma TypeScripti projektides, mis viib puhtama, tõhusama ja paremini hooldatava koodibaasini.