Cum se utilizează Enums în TypeScript

O enumerare, sau un tip enumerat, este o structură de date care vă permite să definiți un set de valori denumite.

Enumerările oferă o modalitate de a reprezenta un set fix de valori ca constante. Acestea vă pot ajuta să faceți codul mai expresiv și mai auto-documentat, dând nume semnificative unor valori specifice. Aici veți învăța cum puteți utiliza enumerarea în TypeScript.

Crearea unei Enum

Enumerările reprezintă, în general, un număr fix de opțiuni pentru o anumită valoare. De exemplu, o enumerare care reprezintă culorile primare poate avea valori fixe pentru roșu, galben și albastru.

Enumerările reprezintă datele ca un set de perechi cheie/valoare cunoscute sub numele de membri enumerați. Cheia trebuie să fie întotdeauna un șir. Cu toate acestea, valoarea – un număr cu incrementare automată în mod implicit – poate fi numerică, un șir sau calculată.

Puteți crea o enumerare în limbajul TypeScript

folosind enumerare cuvânt cheie. Urmează-l cu numele enumerației și o pereche de bretele ({}) conţinând membrii enumerarii. O convenție de denumire JavaScript comună afirmă că numele enumerate ar trebui să înceapă cu o literă majusculă.

enumerare Direcția {
 Sus,
 Jos,
 Stânga,
 Dreapta
}

Acest exemplu prezintă o enumerare numită Direcţie. Enumerația are un membru care reprezintă fiecare direcție: Sus, Jos, Stânga și Dreapta.

Deoarece acest cod nu specifică o valoare pentru fiecare tastă, TypeScript va atribui automat valori. Primul membru, Up, va avea valoarea 0. Membrii rămași vor avea fiecare o valoare cu 1 mai mare decât a membrului anterior. Puteți declara acest lucru în mod explicit dacă vă este greu să vă amintiți:

enumerare Direcția {
 Sus = 0,
 Jos = 1,
 Stânga = 2,
 Corect = 3,
}

Sau puteți declara în mod explicit valori diferite, lăsând valorile nedeclarate să continue să crească ca înainte:

enumerare Stare {
 Activ = 9,
 Inactiv, // 10
}

În acest exemplu, membrul inactiv are valoarea 10. Acest comportament se aplică enumărilor care au numai valori numerice, nu celor cu șir sau membri eterogene.

Diferitele tipuri de enumerare

Enumerările din TypeScript au un tip implicit pe care se bazează pe tipul de valori pe care le dețin membrii lor. Cel mai comun tip este enumerarea numerică, al cărui comportament se referă la secțiunea anterioară, dar există două variante.

Enumări șiruri

O enumerare șir este o enumerare în care toți membrii săi sunt șiruri. Spre deosebire de enumerarile numerice, în care valorile sunt atribuite automat, trebuie să inițializați fiecare membru cu un șir:

enumerare Culori primare {
 Roșu = "ROȘU",
 Galben = "GALBEN",
 Albastru = "ALBASTRU"
}

Deși enumerările șirurilor nu au proprietăți de incrementare automată, ele pot avea mai mult sens dacă le serializați. Valorile lor ar trebui să fie în continuare descriptive, fără nume de membri, în timp ce un set de valori numerice ar putea să nu fie autodescriere.

Enumări eterogene

Enumerările eterogene sunt enumerari care conțin atât membri numerici, cât și membri șir. De exemplu:

enumerare rezultat {
 Succes = "SUCCES",
 Eșec = 0
}

Enumerările eterogene sunt utile atunci când aveți membri enumerați care necesită tipuri de valori diferite în funcție de contextul sau semnificația specifică fiecărui membru. Însă Documentație TypeScript descurajează utilizarea enumerărilor eterogene, deoarece introduc complexitate care poate face codul mai predispus la erori.

Membrii Enum calculați și constante

Fiecare membru enumerare are o valoare, care poate fi fie constantă, fie calculată.

Membrii Enum constant

Un membru enum este constant dacă îndeplinește oricare dintre condițiile de mai jos.

1. Este primul membru al enumerarii și nu are inițializator.
2. Nu are un inițializator, iar membrul de enumerare precedent a fost o constantă numerică.
3. Este inițializată cu o expresie enum constantă.

Conform documentației TypeScript, o expresie de enumerare constantă este un subset de expresii TypeScript care poate fi evaluată complet în timpul compilării. De exemplu, un șir sau un literal numeric.

De exemplu, membrii enumerărilor din blocul de cod de mai jos sunt toți constanți:

// CAZUL 1
enumerare Direcția {
 Sus,
 Jos,
 Stânga,
 Dreapta
}
// CAZUL 2
enumerare Ziua săptămânii {
 luni = 1,
 Marţi,
 Miercuri,
 Joi,
 vineri
}
// CAZUL 3
enumerare sezonul {
 Primavara = "ARC",
 Vara = "VARĂ",
 Toamna = "TOAMNĂ",
 Iarna = "IARNĂ"
}

Când transpilați membrii enumerați constant în JavaScript simplu, codul generat folosește valorile lor literale. Acest lucru poate fi benefic pentru performanță și poate facilita depanarea.

De exemplu, iată versiunea transpilată a enumerarii sezonului:

var Sezon;
(funcţie (Sezon) {
 Sezon["Arc"] = "ARC";
 Sezon["Vară"] = "VARĂ";
 Sezon["Toamnă"] = "TOAMNĂ";
 Sezon["Iarnă"] = "IARNĂ";
})(Sezon || (Sezon = {}));

Membrii Enum calculati

Puteți utiliza membrii enumerați calculați pentru a atribui valori membrilor enumerați pe baza expresiilor sau a altor calcule dinamice. De exemplu:

enumerare Mărimea {
 Mic = 1,
 Mediu = calculateSize(12),
 Mare = calculateSize(5)
}
funcţiecalculateSize(valoare: număr): număr{
întoarcere valoare * 5;
}
consolă.log (Dimensiune. Mare)

The mărimea enum are trei membri: Mic, Mediu, și Mare. Acesta atribuie în mod explicit valoarea 1 membrului mic. The Mediu și Mare membrii folosesc o funcție calculateSize pentru a-și calcula valorile în timpul execuției.

Când lucrați cu membri de enumerare calculați, este important să rețineți că valorile nu sunt cunoscute până la runtime. Acest lucru poate introduce mai multă complexitate și potențial erori de rulare comparativ cu membrii enumerarii cu valori constante.

De exemplu:

var Mărimea;
(funcţie (mărimea) {
 Dimensiune[Mărime["Mic"] = 1] = "Mic";
 Dimensiune[Mărime["Mediu"] = calculateSize(12)] = "Mediu";
 Dimensiune[Mărime["Mare"] = calculateSize(5)] = "Mare";
})(Mărimea || (Mărimea = {}));
consolă.Buturuga(mărimea.Mare)

Blocul de cod de mai sus este versiunea transpilată a mărimea enumerare. Observați cum TypeScript nu include valorile returnate de la calculateSize() în codul JavaScript. În schimb, include apelul de funcție original, astfel încât JavaScript determină valorile în timpul execuției.

Accesarea valorilor Enum

Puteți accesa valorile membrilor enumerați utilizând notația cu puncte a obiectului.

De exemplu:

enumerare Direcția {
 Sus = 0,
 Jos = 1,
 Stânga = 2,
 Corect = 3,
}
consolă.log (Directia. Stânga) // 2

Enumerări numerice de cartografiere inversă

Maparea inversă în enumerări numerice se referă la capacitatea de a prelua numele membrului de enumerare corespunzător din valoarea sa. Acest lucru poate fi util în special atunci când lucrați cu valori numerice, pe care ar putea fi necesar să le decodați.

În mod implicit, valorile enumerate în TypeScript sunt mapate înainte, ceea ce înseamnă că puteți accesa doar valoarea asociată unui nume. Cu toate acestea, puteți efectua manual maparea inversă pentru a prelua membrul enumerare pe baza valorii sale.

De exemplu:

enumerare Direcția {
 Sus = 1,
 Jos,
 Stânga,
 Dreapta
}
funcţiegetDirectionName(directionValue: număr): şir{
// Mapare inversă
const directionName = Direcție[directionValue];
întoarcere directionName;
}
consolă.log (getDirectionName(1)); // "Sus"
consolă.log (getDirectionName(3)); // "Stânga"

Acest getDirectionName funcția efectuează maparea inversă accesând numele membrului enum folosind valoarea sa ca index. Funcția necesită a directionValue ca argument și preia numele membrului enum corespunzător folosind Direcție[directionValue].

Maparea inversă poate fi la îndemână în scenariile în care aveți o valoare numerică și trebuie să determinați numele membrului de enumerare corespunzător. Oferă o modalitate convenabilă de a lucra cu enumerari atât în ​​direcția înainte, cât și în cea inversă.

Există multe aplicații ale enumerarilor

Puteți utiliza enumări în diferite scenarii, cum ar fi gestionarea instrucțiunilor de comutare, definirea parametrilor de funcție, maparea datelor și reprezentarea opțiunilor sau setărilor.

Indiferent dacă trebuie să reprezentați un set finit de opțiuni sau să gestionați tranziții complexe de stare, enumerările din TypeScript sunt un instrument valoros pentru a îmbunătăți claritatea și structura codului dvs.