Implementación de enumeradores en Go para controlar estados

Clase 19 de 28 • Curso de Go

Resumen

La correcta implementación de enumeradores en Go es esencial para mejorar el control y limitar el margen de error en las aplicaciones. Al utilizar enumeradores establecemos un conjunto específico y cerrado de opciones, garantizando que los usuarios seleccionen únicamente alternativas válidas.

¿Qué son los enumeradores y cuándo utilizarlos?

Un enumerador es una característica común en muchos lenguajes de programación, usada para definir un conjunto específico y limitado de opciones. Al implementar enumeradores en Go, se impide que un usuario seleccione opciones fuera del rango especificado, simplificando la validación y asegurando respuestas correctas por defecto.

Ventajas principales del uso de enumeradores:

Limita opciones disponibles para el usuario.
Facilita validaciones estrictas minimizando errores.
Ofrece valores por defecto claramente definidos.

¿Cómo implementar enumeradores correctamente en Go?

Para crear un enumerador en Go, se inicia definiendo un tipo y usando la constante especial iota, que automáticamente asigna valores numéricos incrementales a las constantes enumeradas. Veamos un ejemplo práctico:

type serverState int

const (
    idle serverState = iota
    connected
    error
    retry
)

Aquí, el estado idle será el valor por defecto si no se especifica otra opción explícitamente.

¿Cómo manipular cadenas y enumeradores juntos?

Un mapa puede vincular fácilmente estos estados definidos con cadenas más legibles para el usuario. Observa este ejemplo claro en código Go:

var serverStateMap = map[serverState]string{
    idle:      "Idle",
    connected: "Connected",
    error:     "Error",
    retry:     "Retrying",
}

Aunque los códigos internos generalmente utilizan términos en inglés, es posible personalizar fácilmente estos mensajes hacia otros idiomas o cadenas relevantes.

¿Cómo manejar diferentes estados con un control switch?

Para optimizar la gestión integral de estos estados en Go, se puede usar la estructura switch, permitiendo comportamientos específicos según el estado recibido:

func verificacionDeRed(servidor serverState) serverState {
    switch servidor {
    case idle:
        return connected
    case connected, retry:
        return idle
    case error:
        panic("Estado desconocido del servidor")
    default:
        return idle
    }
}

La sentencia panic permite lanzar un error personalizado en situaciones inesperadas, asegurando que los errores sean manejables y claramente definidos.

¿Cómo mostrar estados de forma sencilla al usuario?

Extraer y mostrar únicamente la cadena asociada al estado actual simplifica enormemente la interacción con el usuario final:

fmt.Println("Estado del servidor:", serverStateMap[estadoServidor])

Esto facilita enormemente la presentación clara y entendible de los estados internos, independientemente de que los valores subyacentes se mantengan en inglés.

Recuerda que el uso correcto y combinado de enumeradores y estructuras de objetos permite controlar estrictamente cuáles opciones están disponibles, simplificando el código, previniendo errores y garantizando una experiencia de usuario clara y efectiva.

¿Qué consideraciones adicionales conoces o sugieres al utilizar enumeradores en Go? Déjanos tu comentario.

Jehú Frayle

student•

Por si alguien también se confundió con esta parte...

func (estadoServidor ServerState) String() string {
	return stateName[serv]
}
```Esta función se ve rara al principio, pero es una forma especial de asociar un método al tipo `ServerState`.

En Go, cuando escribes `func (x Tipo)`, estás diciendo que la función es un método del tipo `Tipo`. En este caso, `String()` es un método que se activa automáticamente cuando se imprime una variable de tipo `ServerState` con `fmt.Println` u otras funciones similares.

Lo útil de esto es que podemos definir cómo queremos que se vea el texto cuando imprimimos un valor de `ServerState`, en lugar de mostrar simplemente un número (como `0`, `1`, etc.).

David Guerrero Morales Guerrero

student•

String() es un método especial en Go que implementa la interfaz Stringer

https://go.dev/tour/methods/17

Moises Almonte

student•

Realice este ejemplo utilizando enumerados.

Cree un struct para imitar un campo de texto. También un Enum Color, el cual facilitara formatear el texto del campo.

package main

import "fmt"

// Clase 
type TextField struct {
	text string
	textColor Color
}

//Enum
type Color int

//Inicializando el Enum, utilizando la palabra especial iota
const (
	Blue = iota
	Red
	Green
	Yellow
	Black
	White
)

//Mapa para facilitar la relacion del index del Enum Color 
// con el color_ansi, para formatear el texto
var color_ansi = map[Color] string{
	Blue:		"\x1b[34m",
	Red:		"\x1b[31m",
	Green:		"\x1b[32m",
	Yellow:		"\x1b[33m",
	Black:		"\x1b[30m",
	White:		"\x1b[37M",
}

//Como menciono el profesor Amin, si exiten las clases en Go
//Esta formar de declara una funcion, es para asociar la funcion al objeto Color (Enum)
func (c Color) colorAnsi() string{
	return color_ansi[c]
}

// Esta funcion sera asociada al struct TextField, para imprimir el objeto a la terminal
func (t TextField) paint(){
	color_reset_ansi := "\x1b[0m"
	txt_len := len(t.text)
	printLines(txt_len)
	fmt.Println("|" + t.textColor.colorAnsi() + t.text + color_reset_ansi + "|")
	printLines(txt_len)
}

// Funcion para imprimir la separacion superior e inferior.
func printLines(length int){
	for i := 0; i < length + 2; i++ {
		fmt.Printf("%s", "-")
	}
	fmt.Printf("\n")
}

func main(){
	txtField := TextField{"Estoy aprediendo Go en Platzi!", Color(Green)}
	txtField.paint()

	txtField.textColor = Color(Yellow)
	txtField.paint()

	txtField.textColor = Color(Blue)
	txtField.paint()

	txtField.textColor = Color(Red)
	txtField.paint()
}

Salida:

Ronaldo Jiménez

student•

Este ejemplo me ayudo mucho a entender el concepto desde la perspectiva de Go:

package main

import "fmt"

// En Go, no existen las enumeraciones (enums) nativas.
// En su lugar, se usa una combinación de constantes y `iota`.

// Se define un nuevo tipo llamado PizzaSize, que es un alias de int.
// Esto nos da seguridad de tipo.
type PizzaSize int

// `iota` es un generador de secuencias que se incrementa automáticamente.
// Cada constante en este bloque obtiene un valor secuencial, comenzando desde 0.
const (
	// Small es 0
	Small PizzaSize = iota
	// Medium es 1
	Medium
	// Large es 2
	Large
)

func main() {
	// Declaramos una variable para una pizza mediana, usando el "enum"
	myPizza := Medium

	// Usamos un switch para decidir qué acción tomar según el tamaño de la pizza.
	// Esto es más legible que usar números directamente (e.g., `case 1`).
	fmt.Println("Ordenando tu pizza...")

	switch myPizza {
	case Small:
		fmt.Println("Has ordenado una pizza pequeña.")
	case Medium:
		fmt.Println("Has ordenado una pizza mediana. ¡Excelente elección!")
	case Large:
		fmt.Println("Has ordenado una pizza grande. ¡Perfecta para compartir!")
	default:
		// Esta rama se ejecuta si el valor de myPizza no coincide con ninguno de los enums
		fmt.Println("Lo siento, ese tamaño de pizza no está disponible.")
	}

	// También podemos ver los valores numéricos detrás de los "enums"
	fmt.Printf("\nEl valor numérico de 'Small' es: %d\n", Small)
	fmt.Printf("El valor numérico de 'Medium' es: %d\n", Medium)
	fmt.Printf("El valor numérico de 'Large' es: %d\n", Large)
}