Implementación de enumeradores en Go para controlar estados

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:32

Implementación de enumeradores en Go para controlar estados

Curso de Go

Clase 19 de 28

Clase 19 / 28

Recursos

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.

Gregory Taveras Ramirez

Hace 4 meses

1. ¿Cómo se llama o se usa una función sin nombre (Anónima)?

Una función anónima se define usando la palabra clave func pero omitiendo el nombre. Tienes dos formas principales de usarla:

A. Ejecutarla inmediatamente (IIFE)

Le pones paréntesis al final para que se ejecute en el mismo instante en que se define:

func() {
    fmt.Println("¡Hola desde una función anónima!")
}() // Estos paréntesis la ejecutan inmediatamente

B. Asignarla a una variable

Puedes guardarla en una variable para llamarla más tarde cuando la necesites:

saludar := func(nombre string) {
    fmt.Printf("Hola, %s!\n", nombre)
}

// Así se llama:
saludar("Carlos")

2. Explicación del código de la imagen (Enumeraciones)

Lo que hay en tu imagen es el patrón estándar en Go para crear y dar formato a enumeraciones:

El mapa (stateName): Traduce los valores numéricos/internos de la enumeración a un texto legible (string).
El método (String()): El bloque func (estadoServidor ServerState) String() string define un método receptor. No es anónimo; el nombre de la función es String.

¿Cómo se usa este ejemplo en la vida real?

Para que ese código funcione, primero se suele definir el tipo y las constantes (la enumeración propiamente dicha) usando iota:

type ServerState int

const (
    StateIdle ServerState = iota
    StateConnected
    StateError
    StateRetrying
)

Al haberle añadido el método String(), Go lo usará automáticamente cuando intentes imprimir el estado, por lo que no necesitas llamarlo manualmente.

Ejemplo de uso:

func main() {
    miEstado := StateConnected

    // Go detecta automáticamente el método String() al usar fmt.Println
    fmt.Println(miEstado) 
    // Salida en consola: conectado
}

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Implementación de enumeradores en Go para controlar estados