Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 14 de 36 · De clases a structs ✦ WebMCP implementado

Enums con iota frente a enum de PHP 8.1

8 min de lectura 4 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.

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
type Prioridad int

var p Prioridad = 1
var 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
<?php
declare(strict_types=1);

enum Prioridad: int
{
    case Baja = 0;
    case Media = 1;
    case Alta = 2;

    public function etiqueta(): string
    {
        return match ($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: int
type Prioridad int

const (
    // iota = 0, 1, 2: las líneas vacías repiten «Prioridad = iota»
    Baja Prioridad = iota
    Media
    Alta
)

// En PHP: public function etiqueta(): string
func (p Prioridad) String() string {
    switch p {
    case Baja:
        return "baja"
    case Media:
        return "media"
    case Alta:
        return "alta"
    }
    return "desconocida"
}

func main() {
    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"

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

// Un array con los nombres, en el mismo orden que las constantes
var 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]
}

type Tarea struct {
    Titulo    string
    Prioridad Prioridad
}

func main() {
    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"

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

// En PHP: Prioridad::tryFrom($n) !== null
func (p Prioridad) EsValida() bool {
    return p >= Baja && p <= Alta
}

// En PHP: Prioridad::tryFrom($n) ?? Prioridad::Media
func PrioridadDesde(n int) Prioridad {
    p := Prioridad(n)
    if !p.EsValida() {
        return Media
    }
    return p
}

func main() {
    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 prioridad
func DiasDePlazo(p Prioridad) int {
    switch p {
    case Alta:
        return 1
    case Media:
        return 3
    case Baja:
        return 7
    default:
        // En PHP: throw new UnhandledMatchError(...)
        panic(fmt.Sprintf("prioridad sin plazo: %d", int(p)))
    }
}
PHP 8.1+GoQuién lo comprueba
enum Prioridad: inttype Prioridad int + const con iotaEl compilador
Prioridad::Alta->valueint(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 → UnhandledMatchErrorswitch con default que avisaTú

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.

PHPGoQuién lo ve
enum Prioridad: int { ... }type Prioridad intCualquier paquete (mayúscula)
case Alta = 2;Alta en un bloque const con iotaCualquier paquete; en minúscula, solo el tuyo
public function etiqueta()func (p Prioridad) String() stringLo usa fmt al imprimir
Prioridad::from($n)func PrioridadDesde(n int) PrioridadFunción del paquete: no hay static
readonly (los casos no cambian)constNadie puede cambiar una constante

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

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

Resumen

Lo que te llevas de esta lección

  1. type Prioridad int crea un tipo propio que no se mezcla con int (en PHP, enum Prioridad: int).
  2. const ( Baja Prioridad = iota; Media; Alta ) numera 0, 1, 2 sola (en PHP, case Baja = 0; a mano).
  3. Un método String() le da nombre al imprimir (en PHP, tu método label() con match).
  4. Prioridad(7) compila: valida con EsValida() donde entran datos (en PHP, tryFrom()).
  5. 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.