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 32 de 36 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 2: el dominio, la entidad Tarea

8 min de lectura 4 retos

El dominio es el corazón de la app: qué es una tarea y qué reglas cumple. En esta fase escribes el paquete internal/dominio con la entidad Tarea, su constructor que valida, sus métodos y sus errores. No toca ni la base de datos ni la web.

En 4 ideas
1/4

La entidad es un struct y el enum es un int con iota. En PHP serían una final class Tarea y un enum Prioridad: int.

1 · La entidad Tarea y su prioridad

Una entidad es algo que tiene identidad propia: dos tareas con el mismo título siguen siendo dos tareas distintas, porque tienen distinto ID. Como dos hermanos gemelos: se parecen, pero cada uno tiene su DNI.

Ya conoces todas las piezas: el struct (módulo 04), el enum con iota (módulo 04) y el método String() que usa fmt para pintarlo (módulo 05, la interfaz Stringer).

PHP 8.5tarea.php
<?php
declare(strict_types=1);

namespace App\Domain;

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

final class TituloVacio extends \DomainException {}
final class TituloLargo extends \DomainException {}

final class Tarea
{
    /** @param list<string> $etiquetas */
    private function __construct(
        public private(set) int $id,
        public private(set) string $titulo,
        public private(set) Prioridad $prioridad,
        public private(set) bool $hecha = false,
        public private(set) array $etiquetas = [],
    ) {}

    public static function nueva(string $titulo, Prioridad $prioridad): self
    {
        $titulo = trim($titulo);
        if ($titulo === "") {
            throw new TituloVacio("el título está vacío");
        }
        if (mb_strlen($titulo) > 100) {
            throw new TituloLargo("el título pasa de 100 caracteres");
        }
        return new self(0, $titulo, $prioridad);
    }
}
Gotarea.go
package dominio

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

var (
    ErrTituloVacio       = errors.New("el título está vacío")
    ErrTituloLargo       = errors.New("el título pasa de 100 caracteres")
    ErrPrioridadInvalida = errors.New("prioridad no válida")
)

type Tarea struct {
    ID        int
    Titulo    string
    Prioridad Prioridad
    Hecha     bool
    Etiquetas []string
}

// NuevaTarea es el constructor: la puerta para crear una tarea válida.
func NuevaTarea(titulo string, p Prioridad) (Tarea, error) {
    titulo = strings.TrimSpace(titulo)
    if titulo == "" {
        return Tarea{}, ErrTituloVacio
    }
    // En PHP: mb_strlen($titulo) > 100
    if utf8.RuneCountInString(titulo) > 100 {
        return Tarea{}, ErrTituloLargo
    }
    if p < Baja || p > Alta {
        return Tarea{}, ErrPrioridadInvalida
    }
    return Tarea{Titulo: titulo, Prioridad: p, Etiquetas: []string{}}, nil
}

El ID empieza a 0: significa «aún no guardada». El repositorio le dará un número de verdad en la fase 3, igual que el AUTOINCREMENT rellena el id en PHP después del INSERT.

Gomain.go
package main

import "fmt"

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

// String hace que fmt pinte «alta» en vez de «2».
// En PHP: el ->name de un enum, o un método label()
func (p Prioridad) String() string {
    switch p {
    case Baja:
        return "baja"
    case Media:
        return "media"
    case Alta:
        return "alta"
    }
    return "desconocida"
}

type Tarea struct {
    ID        int
    Titulo    string
    Prioridad Prioridad
    Hecha     bool
    Etiquetas []string
}

func main() {
    t := Tarea{Titulo: "Comprar pan", Prioridad: Alta, Etiquetas: []string{}}
    fmt.Println(t.Prioridad)
    fmt.Printf("%+v\n", t)
    fmt.Println(Prioridad(7))
}

2 · Un constructor que valida: NuevaTarea

La regla de oro del dominio: no puede existir una tarea inválida. Ni sin título, ni con un título de mil letras, ni con prioridad 7. Por eso todas nacen por la misma puerta, NuevaTarea, que comprueba todo antes de dejarla pasar. Como el portero de una discoteca.

Gomain.go
package main

import (
    "errors"
    "fmt"
    "strings"
    "unicode/utf8"
)

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

var (
    ErrTituloVacio       = errors.New("el título está vacío")
    ErrTituloLargo       = errors.New("el título pasa de 100 caracteres")
    ErrPrioridadInvalida = errors.New("prioridad no válida")
)

type Tarea struct {
    ID        int
    Titulo    string
    Prioridad Prioridad
    Hecha     bool
    Etiquetas []string
}

func NuevaTarea(titulo string, p Prioridad) (Tarea, error) {
    titulo = strings.TrimSpace(titulo)
    if titulo == "" {
        return Tarea{}, ErrTituloVacio
    }
    if utf8.RuneCountInString(titulo) > 100 {
        return Tarea{}, ErrTituloLargo
    }
    if p < Baja || p > Alta {
        return Tarea{}, ErrPrioridadInvalida
    }
    return Tarea{Titulo: titulo, Prioridad: p, Etiquetas: []string{}}, nil
}

func main() {
    titulos := []string{"  Comprar pan ", "   ", strings.Repeat("ñ", 101)}
    for _, titulo := range titulos {
        t, err := NuevaTarea(titulo, Media)
        // En PHP: catch (TituloVacio $e)
        if errors.Is(err, ErrTituloVacio) {
            fmt.Println("rechazada: sin título")
            continue
        }
        if err != nil {
            fmt.Println("rechazada:", err)
            continue
        }
        fmt.Printf("creada: %q\n", t.Titulo)
    }
    _, err := NuevaTarea("Repasar Go", Prioridad(7))
    fmt.Println("prioridad 7:", err)
}

¿Por qué? · En PHP no existe

¿Por qué Go no tiene constructores ni private function __construct? En PHP sí

En Go un «constructor» es una función normal con el nombre Nuevo… o New…: no hay palabra reservada. Y como Titulo empieza por mayúscula (es público), cualquiera puede saltarse la puerta escribiendo Tarea{Titulo: ""}. En PHP, el private function __construct lo impide.

Go lo hace a propósito: prefiere que el valor cero de un struct sea útil y que no haya magia escondida al crear algo. Tienes dos caminos:

  • Campos públicos + constructor por convención (lo que hacemos aquí): sencillo, y el repositorio y las plantillas leen los campos sin más. La regla del equipo es «las tareas nuevas, siempre con NuevaTarea».
  • Campos privados (titulo string) + métodos Titulo() para leerlos: el compilador impide crear una tarea inválida desde fuera del paquete, a cambio de más código.

Para un proyecto pequeño, la primera opción. Si la entidad es delicada (dinero, permisos), la segunda.

3 · El comportamiento: Completar y Etiquetar

Una entidad no es solo datos: también sabe hacer cosas con sus reglas. Una tarea se puede completar (pero no dos veces) y etiquetar (en minúsculas, sin repetir y sin comas, porque en SQLite van separadas por comas).

Gomain.go
var (
    ErrYaCompletada     = errors.New("la tarea ya estaba completada")
    ErrEtiquetaInvalida = errors.New("etiqueta vacía o con comas")
)

// Completar marca la tarea como hecha.
// En PHP: public function completar(): void { $this->hecha = true; }
func (t *Tarea) Completar() error {
    if t.Hecha {
        return ErrYaCompletada
    }
    t.Hecha = true
    return nil
}

// Etiquetar añade una etiqueta en minúsculas y sin repetir.
func (t *Tarea) Etiquetar(etiqueta string) error {
    etiqueta = strings.ToLower(strings.TrimSpace(etiqueta))
    if etiqueta == "" || strings.Contains(etiqueta, ",") {
        return ErrEtiquetaInvalida
    }
    // En PHP: in_array($etiqueta, $this->etiquetas, true)
    if !slices.Contains(t.Etiquetas, etiqueta) {
        t.Etiquetas = append(t.Etiquetas, etiqueta)
    }
    return nil
}

El * de (t *Tarea) es el receptor puntero del módulo 04: el método trabaja sobre la tarea original, no sobre una copia. Sin él, t.Hecha = true cambiaría una fotocopia que se tira al salir del método. Míralo funcionar:

Gomain.go
package main

import (
    "errors"
    "fmt"
)

var ErrYaCompletada = errors.New("la tarea ya estaba completada")

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

func (t *Tarea) Completar() error {
    if t.Hecha {
        return ErrYaCompletada
    }
    t.Hecha = true
    return nil
}

func main() {
    t := Tarea{ID: 1, Titulo: "Comprar pan"}
    err := t.Completar()
    fmt.Println("1ª vez:", err, "→ hecha:", t.Hecha)
    err = t.Completar()
    fmt.Println("2ª vez:", err)
}

4 · Los errores del dominio

En PHP crearías una clase de excepción por cada problema. En Go basta una variable con errors.New (módulo 06), que se llama Err… por convención. Quien la reciba la reconoce con errors.Is, aunque venga envuelta con %w.

Error de GoCuándo saleEn PHPLo que hará la web (fase 5)
ErrTituloVacioTítulo vacío o solo espaciosthrow new TituloVacio()422 y el formulario con el aviso
ErrTituloLargoMás de 100 letrasthrow new TituloLargo()422
ErrPrioridadInvalidaPrioridad fuera de 0-2Un ValueError de Prioridad::from(7)422
ErrEtiquetaInvalidaEtiqueta vacía o con comasthrow new EtiquetaInvalida()422
ErrYaCompletadaCompletar dos vecesthrow new YaCompletada()409
ErrTareaNoEncontradaEl id no existe (fase 3)throw new TareaNoEncontrada()404

Equivalencia POO · PHP → Go

Así queda la entidad de PHP traducida a Go, pieza a pieza:

PHPGoQuién lo ve
final class Tareatype Tarea structTodo el que importe dominio (no hay herencia, así que todo es «final»)
public private(set) string $tituloTitulo string (público) o titulo string + Titulo()Público: se lee y se escribe desde fuera. Privado: solo el paquete dominio
private function __construct + static nueva()func NuevaTarea(...) (Tarea, error)Cualquiera; el constructor privado no existe
$this->hecha = truefunc (t *Tarea) Completar() con t.Hecha = trueEl receptor t es tu $this
enum Prioridad: inttype Prioridad int + const (… iota)Público si empieza por mayúscula
class TituloVacio extends DomainExceptionvar ErrTituloVacio = errors.New(...)Público: dominio.ErrTituloVacio
try { … } catch (TituloVacio $e)if errors.Is(err, dominio.ErrTituloVacio)Quien llama a la función

5 · Un dominio que no depende de nada

Mira los import del paquete dominio: solo errors, slices, strings y unicode/utf8. Ni SQL, ni HTTP, ni JSON. Es a propósito: el dominio es la receta, y una receta no dice en qué horno se cocina.

También vive aquí el contrato del repositorio, la interfaz que cumplirán SQLite y la versión en memoria en la fase 3:

Gomain.go
package dominio

// RepositorioTareas es el contrato que cumple cualquier almacén de tareas.
// En PHP: interface TareaRepository { public function guardar(Tarea $t): Tarea; ... }
type RepositorioTareas interface {
    Guardar(t Tarea) (Tarea, error)
    BuscarPorID(id int) (Tarea, error)
    Listar() ([]Tarea, error)
    Borrar(id int) error
}

Como no depende de nada, el dominio se prueba con un test de tabla (módulo 07) que tarda milisegundos:

Gomain.go
func TestNuevaTarea(t *testing.T) {
    casos := []struct {
        nombre    string
        titulo    string
        prioridad Prioridad
        errEsp    error
    }{
        {"válida", "Comprar pan", Media, nil},
        {"vacía", "   ", Media, ErrTituloVacio},
        {"larga", strings.Repeat("a", 101), Media, ErrTituloLargo},
        {"prioridad rara", "Comprar pan", Prioridad(7), ErrPrioridadInvalida},
    }
    for _, c := range casos {
        t.Run(c.nombre, func(t *testing.T) {
            _, err := NuevaTarea(c.titulo, c.prioridad)
            if !errors.Is(err, c.errEsp) {
                t.Errorf("NuevaTarea(%q) error = %v; quería %v", c.titulo, err, c.errEsp)
            }
        })
    }
}
$ go test -v ./internal/dominio/
=== RUN   TestNuevaTarea
=== RUN   TestNuevaTarea/válida
=== RUN   TestNuevaTarea/vacía
=== RUN   TestNuevaTarea/larga
=== RUN   TestNuevaTarea/prioridad_rara
--- PASS: TestNuevaTarea (0.00s)
    --- PASS: TestNuevaTarea/válida (0.00s)
    --- PASS: TestNuevaTarea/vacía (0.00s)
    --- PASS: TestNuevaTarea/larga (0.00s)
    --- PASS: TestNuevaTarea/prioridad_rara (0.00s)
PASS
ok      tareas/internal/dominio 0.007s

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Pinta la prioridad

Completa el método String() de Prioridad para que devuelva baja, media o alta, y desconocida para cualquier otro valor. Así fmt.Println(Alta) pinta alta. Es el ->name de un enum de PHP (o un método label()).

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. La entidad es un struct y la prioridad un int con iota y String() (en PHP, final class + enum Prioridad: int).
  2. El constructor es NuevaTarea(...) (Tarea, error): valida y devuelve un error (en PHP, static nueva() que lanza excepciones).
  3. Los métodos que cambian la tarea van con receptor puntero *Tarea (en PHP, tocar $this->hecha).
  4. Los errores del dominio son variables Err… que se miran con errors.Is (en PHP, clases extends DomainException y catch).
  5. El dominio no importa nada de SQL ni HTTP (en PHP, src/Domain sin PDO ni Request).

Para recordarlo: «Nace válida, cambia con puntero»

Una tarea nace válida porque solo se crea con NuevaTarea, y cambia con puntero porque sus métodos llevan *Tarea. Si una de las dos falla, el dominio miente.