Enums
## Objetivos de Aprendizaje
- Crear y usar enums
- Comprender enums numericos y de cadena
- Usar const enums para rendimiento
- Trabajar con valores calculados
- Dominar metodos de enum
## Enums Basicos
### Enums Numericos
```typescript
enum Direction {
Up, // 0
Down, // 1
Left, // 2
Right // 3
}
let dir: Direction = Direction.Up;
console.log(dir); // 0
```
### Con Valores Iniciales
```typescript
enum Status {
Pending = 1,
Active = 2,
Completed = 4,
Failed = 8
}
console.log(Status.Pending); // 1
console.log(Status.Active); // 2
```
### Auto-Incremento
```typescript
enum Color {
Red = 1,
Green, // 2
Blue // 3
}
console.log(Color.Red); // 1
console.log(Color.Green); // 2
console.log(Color.Blue); // 3
```
## Enums de Cadena
### Declaracion
```typescript
enum Direction {
Up = "UP",
Down = "DOWN",
Left = "LEFT",
Right = "RIGHT"
}
let dir: Direction = Direction.Up;
console.log(dir); // "UP"
```
### Por Que Enums de Cadena?
- Mas explicitos y legibles
- Buenos para depuracion
- Sin comportamiento de auto-incremento
## Usando Enums
### En Switch
```typescript
enum Status {
Pending,
Active,
Completed
}
function getStatusMessage(status: Status): string {
switch (status) {
case Status.Pending:
return "Esperando...";
case Status.Active:
return "En progreso...";
case Status.Completed:
return "Hecho!";
default:
return "Desconocido";
}
}
```
### Como Tipos de Retorno
```typescript
enum Result {
Success,
Error
}
function divide(a: number, b: number): { result: number; status: Result } {
if (b === 0) {
return { result: 0, status: Result.Error };
}
return { result: a / b, status: Result.Success };
}
```
## Mapeo Inverso
Los enums numericos pueden obtener valor de clave:
```typescript
enum Color {
Red = 1,
Green = 2,
Blue = 3
}
console.log(Color.Red); // 1
console.log(Color[1]); // "Red"
console.log(Color[2]); // "Green"
```
## Const Enums
### Declaracion de Const Enum
```typescript
const enum Direction {
Up,
Down,
Left,
Right
}
```
### Beneficios
- Inline en tiempo de compilacion
- Sin codigo en tiempo de ejecucion generado
- Mejor rendimiento
### Uso
```typescript
const enum Directions {
Up = "UP",
Down = "DOWN"
}
let dir = Directions.Up; // Inline como "UP"
```
### JavaScript Generado
```typescript
// TypeScript
const enum Direction { Up, Down }
let dir = Direction.Up;
// JavaScript Generado
let dir = 0; // Inline!
```
## Enums Heterogeneos
Mezcla de cadena y numero (evitar cuando sea posible):
```typescript
enum BooleanLike {
No = 0,
Yes = "YES"
}
```
## Enum con Metodos
```typescript
enum Operation {
Add = 1,
Subtract = 2,
Multiply = 3,
Divide = 4
}
function calculate(a: number, b: number, op: Operation): number {
switch (op) {
case Operation.Add:
return a + b;
case Operation.Subtract:
return a - b;
case Operation.Multiply:
return a * b;
case Operation.Divide:
return a / b;
default:
return 0;
}
}
calculate(10, 5, Operation.Add); // 15
calculate(10, 5, Operation.Multiply); // 50
```
## Enums Similares a Objetos
Cuando los valores de enum son constantes:
```typescript
const enum HttpStatus {
Ok = 200,
Created = 201,
BadRequest = 400,
Unauthorized = 401,
NotFound = 404
}
function checkStatus(code: number): string {
if (code === HttpStatus.Ok) return "Exito";
if (code === HttpStatus.NotFound) return "No encontrado";
return "Desconocido";
}
```
## Union con Enums
```typescript
enum ShapeKind {
Circle,
Square
}
interface Circle {
kind: ShapeKind.Circle;
radius: number;
}
interface Square {
kind: ShapeKind.Square;
side: number;
}
type Shape = Circle | Square;
```
## Enum en Interfaces
```typescript
interface Event {
type: enum {
Click,
Hover,
Focus
};
target: string;
}
function handleEvent(event: Event): void {
if (event.type === Event.type.Click) {
// Manejar click
}
}
```
## Verificacion de Agotamiento
### Con Never
```typescript
enum Status {
Active,
Pending,
Deleted
}
function assertNever(x: never): never {
throw new Error("Valor inesperado: " + x);
}
function processStatus(status: Status): string {
switch (status) {
case Status.Active:
return "Activo";
case Status.Pending:
return "Pendiente";
case Status.Deleted:
return "Eliminado";
default:
return assertNever(status);
}
}
```
## Enums Ambientes
Declaracion sin implementacion:
```typescript
declare enum Status {
Active,
Pending
}
// Usado en archivos .d.ts
```
## Resumen
- Los enums crean constantes nombradas
- Los enums numericos auto-incrementan desde 0
- Los enums de cadena deben ser inicializados
- Usar `const enum` para mejor rendimiento
- Mapeo inverso: `Color[1]` obtiene clave desde valor
- Los enums son utiles para codigos de estado y elecciones
- Usar verificacion de agotamiento con `never`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →