Lección 14 de 36 · De clases a structs✦ WebMCP implementado
Enums con iota frente a enum de PHP 8.1
8 min de lectura4 retos
PHP 8.1 trajo enum, y seguro que ya lo usas. Go no tiene enum: lo monta con un tipo propio y unas constantes numeradas con iota. En esta lección le das a cada tarea su Prioridad (baja, media o alta) y aprendes a cubrir a mano lo que el enum de PHP te daba hecho.
¿De dónde vienen los nombres?
iota = la letra griega iota (ι)
La letra más pequeña del alfabeto griego (en inglés, «not one iota» es «ni una pizca»). El lenguaje APL ya usaba ι para generar una serie de enteros seguidos, que es justo lo que hace aquí. En PHP no hay nada parecido: numerabas a mano.
const = constant (constante)
Un valor fijo que se decide al compilar, como el const de una clase de PHP.
En 4 ideas
1/4
Un enum de Go es un tipo propio sobre un entero: type Prioridad int. En PHP sería enum Prioridad: int.
Los casos son constantes, y iota las numera solas: Baja = 0, Media = 1, Alta = 2. Como case Baja = 0; en PHP, pero sin escribir los números.
El nombre bonito se lo da un método String(). Es el método label() con un match que te harías en el enum de PHP.
Go no impide Prioridad(7) ni avisa si a un switch le falta un caso: la validación (tu tryFrom()) y el default (tu UnhandledMatchError) los escribes tú.
1 · Un tipo propio: type Prioridad int
Primero se crea un tipo nuevo basado en int. Es como una etiqueta en un bote: dentro hay un número, pero el bote dice «Prioridad», y Go no deja mezclarlo con otros números sin querer.
Gomain.go
typePrioridadintvar p Prioridad = 1var n int = 2// p == n no compila: son tipos distintos aunque los dos sean números// Hay que convertir a propósito:
fmt.Println(p == Prioridad(n))
Si comparas los dos sin convertir, el mensaje real del compilador es:
./main.go:10:22: invalid operation: p == n (mismatched types Prioridad and int)
Así nadie pasa por error el ID de una tarea donde se espera una prioridad, aunque los dos sean números.
2 · Las constantes y iota
Los casos del enum son constantes de ese tipo, agrupadas en un bloque const ( ... ). Dentro del bloque, iota vale 0 en la primera línea, 1 en la segunda, 2 en la tercera… Y si una línea no dice nada, repite la de arriba con el siguiente número.
PHP 8.5prioridad.php
<?phpdeclare(strict_types=1);
enum Prioridad: int
{
case Baja = 0;
case Media = 1;
case Alta = 2;
publicfunctionetiqueta(): string
{
returnmatch ($this) {
Prioridad::Baja => "baja",
Prioridad::Media => "media",
Prioridad::Alta => "alta",
};
}
}
$p = Prioridad::Alta;
echo$p->value . " " . $p->etiqueta() . PHP_EOL;
Gomain.go
package main
import"fmt"// En PHP: enum Prioridad: inttypePrioridadintconst (
// iota = 0, 1, 2: las líneas vacías repiten «Prioridad = iota»BajaPrioridad = iotaMediaAlta
)
// En PHP: public function etiqueta(): stringfunc (p Prioridad) String() string {
switch p {
caseBaja:
return"baja"caseMedia:
return"media"caseAlta:
return"alta"
}
return"desconocida"
}
funcmain() {
p := Alta// %d el número (en PHP: ->value), %v usa String()
fmt.Printf("%d %v\n", p, p)
}
Con Media = 1 encaja con la tabla del proyecto final: prioridad INTEGER NOT NULL DEFAULT 1. Una tarea nueva nace con prioridad media.
3 · Un nombre bonito con String()
Sin método String(), una prioridad se imprime como lo que es por dentro: un número. Con él, fmt la imprime con su nombre, igual que hacía con la Tarea en la lección anterior.
Gomain.go
package main
import"fmt"typePrioridadintconst (
BajaPrioridad = iotaMediaAlta
)
// Un array con los nombres, en el mismo orden que las constantesvar nombres = [...]string{"baja", "media", "alta"}
func (p Prioridad) String() string {
if p < Baja || p > Alta {
return fmt.Sprintf("Prioridad(%d)", int(p))
}
return nombres[p]
}
typeTareastruct {
TitulostringPrioridadPrioridad
}
funcmain() {
t := Tarea{Titulo: "Llamar al banco", Prioridad: Alta}
fmt.Println(t.Titulo, "-", t.Prioridad)
fmt.Printf("%+v\n", t)
fmt.Println(Prioridad(7))
}
4 · Validar: el tryFrom() que no viene de serie
Aquí está la gran diferencia con PHP. Un enum de PHP es cerrado: Prioridad::from(7) lanza un error y Prioridad::tryFrom(7) devuelve null. En Go, Prioridad(7)compila y funciona: es un int con otra etiqueta y cabe cualquier número.
Así que la validación la escribes tú, en el sitio donde entran datos de fuera (un formulario, un JSON, la base de datos):
Gomain.go
package main
import"fmt"typePrioridadintconst (
BajaPrioridad = iotaMediaAlta
)
// En PHP: Prioridad::tryFrom($n) !== nullfunc (p Prioridad) EsValida() bool {
return p >= Baja && p <= Alta
}
// En PHP: Prioridad::tryFrom($n) ?? Prioridad::MediafuncPrioridadDesde(n int) Prioridad {
p := Prioridad(n)
if !p.EsValida() {
returnMedia
}
return p
}
funcmain() {
fmt.Println(Prioridad(2).EsValida(), Prioridad(7).EsValida())
fmt.Println(PrioridadDesde(2), PrioridadDesde(7))
}
¿Por qué? · En PHP no existe
¿Por qué Go no tiene enums de verdad?
Go se diseñó para tener muy pocas piezas. Un tipo con nombre más unas constantes ya da lo importante: un nombre legible, que el compilador no deje mezclar Prioridad con int sin querer, y que el valor en memoria sea un simple número, rapidísimo de guardar en SQLite o en JSON.
El precio es que el compilador no sabe cuáles son «todos los casos». Lo que en PHP te daba el lenguaje (rechazar el 7, avisar si a un match le falta un caso), en Go lo escribes con un método EsValida() y un default. Son tres líneas, y quedan a la vista.
5 · El switch exhaustivo, a mano
En PHP, un match sin brazo para un caso lanza UnhandledMatchError: te enteras al momento. En Go, un switch al que le falta un caso simplemente no entra en ninguno y sigue adelante en silencio.
La costumbre es cerrar siempre con un default que haga ruido, para que un caso nuevo olvidado no pase desapercibido:
Gomain.go
// Cuántos días tienes para hacer la tarea según su prioridadfuncDiasDePlazo(p Prioridad) int {
switch p {
caseAlta:
return1caseMedia:
return3caseBaja:
return7default:
// En PHP: throw new UnhandledMatchError(...)panic(fmt.Sprintf("prioridad sin plazo: %d", int(p)))
}
}
PHP 8.1+
Go
Quién lo comprueba
enum Prioridad: int
type Prioridad int + const con iota
El compilador
Prioridad::Alta->value
int(Alta)
El compilador
Prioridad::tryFrom($n)
Prioridad(n) + EsValida()
Tú
Prioridad::cases()
Un slice escrito a mano: []Prioridad{Baja, Media, Alta}
Tú
match sin caso → UnhandledMatchError
switch con default que avisa
Tú
Equivalencia POO · PHP → Go
El enum de PHP es una clase especial con casos y métodos. En Go se reparte en tres piezas normales del lenguaje.
PHP
Go
Quién lo ve
enum Prioridad: int { ... }
type Prioridad int
Cualquier paquete (mayúscula)
case Alta = 2;
Alta en un bloque const con iota
Cualquier paquete; en minúscula, solo el tuyo
public function etiqueta()
func (p Prioridad) String() string
Lo usa fmt al imprimir
Prioridad::from($n)
func PrioridadDesde(n int) Prioridad
Función del paquete: no hay static
readonly (los casos no cambian)
const
Nadie puede cambiar una constante
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Una prioridad más: Urgente
Añade la prioridad Urgente detrás de Alta (debe valer 3 sin escribir el número) e imprímela junto a las otras para que el programa muestre exactamente 0 1 2 3. Es añadir un case Urgente = 3; a tu enum de PHP, pero aquí el número lo pone iota.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Basta una línea nueva con Urgente dentro del bloque const: repite el Prioridad = iota de arriba con el siguiente número. Luego añádela al Println.
Reto 2 de 4 · ✓ Resuelto
Ponle nombre a la prioridad
Completa (p Prioridad) String() string para que devuelva baja, media o alta, y desconocida para cualquier otro número. Por ejemplo, Alta.String() devuelve alta y Prioridad(9).String() devuelve desconocida. Es el método etiqueta() con match de tu enum de PHP, con su brazo default.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Un switch p con un case por constante y un default que devuelva desconocida.
Reto 3 de 4 · ✓ Resuelto
Del formulario a la prioridad
Completa PrioridadDesdeTexto(s string) (Prioridad, bool): recibe lo que llega de un formulario ("alta", " Media "…), ignora espacios y mayúsculas, y devuelve la prioridad y true. Si el texto no es ninguna, devuelve Media y false. Es el Prioridad::tryFrom() de PHP, pero desde un texto.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Limpia el texto con strings.TrimSpace y strings.ToLower, y luego un switch sobre el texto con un return Prioridad, true por caso. Si ninguno coincide, return Media, false.
Reto 4 de 4 · ✓ Resuelto
Subir de prioridad sin pasarse
Completa dos métodos de Prioridad: EsValida() bool (solo Baja, Media y Alta valen) y Subir() Prioridad, que devuelve la prioridad siguiente pero nunca pasa de Alta. Por ejemplo, Media.Subir() es Alta y Alta.Subir() sigue siendo Alta. En PHP el enum no te dejaría crear un caso 3; en Go tienes que impedirlo tú.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.EsValida es una comparación doble: entre Baja y Alta. En Subir, si ya estás en Alta (o más), devuelve Alta; si no, p + 1.
Resumen
Lo que te llevas de esta lección
type Prioridad int crea un tipo propio que no se mezcla con int (en PHP, enum Prioridad: int).
const ( Baja Prioridad = iota; Media; Alta ) numera 0, 1, 2 sola (en PHP, case Baja = 0; a mano).
Un método String() le da nombre al imprimir (en PHP, tu método label() con match).
Prioridad(7) compila: valida con EsValida() donde entran datos (en PHP, tryFrom()).
Cierra cada switch de un enum con un default que avise (en PHP, el UnhandledMatchError gratis).
Para recordarlo: «Tipo, Iota, String, Valida»
TTipo type Prioridad int
IIota Baja Prioridad = iota
SString func (p Prioridad) String()
VValida p.EsValida()
Un enum de Go son cuatro pasos: el Tipo, las constantes con Iota, el String para el nombre y la Validación que PHP te daba hecha. Si falta la V, se cuela un 7.