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 16 de 36 · Interfaces, composición y genéricos ✦ WebMCP implementado

Interfaces implícitas: sin implements

9 min de lectura 4 retos

En PHP firmas el contrato con implements. En Go no se firma nada: si un tipo tiene los métodos que pide una interfaz, ya la cumple. Aquí estrenas el RepositorioTareas de la app de tareas, el __toString() de Go, el mixed de Go y el instanceof de Go.

¿De dónde vienen los nombres?

any = any (cualquiera)
Un tipo que admite cualquier valor. Es un alias de interface{}, la interfaz vacía. En PHP sería mixed.
Stringer = String + -er (el que sabe hacer String())
Costumbre de Go: una interfaz de un solo método se llama como el método más «-er». Stringer tiene String(), Writer tiene Write(), Reader tiene Read().
io = input/output (entrada/salida)
El paquete de las interfaces para leer y escribir datos, como io.Writer. En PHP lo más parecido son los streams (fwrite(), php://output).
En 4 ideas
1/4

Una interfaz es una lista de métodos. Un tipo la cumple solo con tener esos métodos, sin escribir implements. En PHP tienes que poner class RepoMemoria implements RepositorioTareas.

1 · Interfaces sin implements

Una interfaz es un contrato: una lista de métodos que alguien promete saber hacer. Piensa en un enchufe. Al enchufe le da igual qué conectes: tostadora, móvil o lámpara. Solo pide que la clavija encaje.

En PHP la clase tiene que declarar que encaja con implements. En Go no: si el tipo tiene los métodos, encaja. Nadie lo firma.

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

interface Describible
{
    public function describir(): string;
}

// En PHP hay que firmar el contrato con «implements».
final readonly class Tarea implements Describible
{
    public function __construct(
        public string $titulo,
        public bool $hecha = false,
    ) {}

    public function describir(): string
    {
        return ($this->hecha ? "[x] " : "[ ] ") . $this->titulo;
    }
}

function imprimir(Describible $d): void
{
    echo $d->describir() . PHP_EOL;
}

imprimir(new Tarea("Comprar pan"));
imprimir(new Tarea("Repasar Go", hecha: true));
Gomain.go
package main

import "fmt"

// En PHP: interface Describible { public function describir(): string; }
type Describible interface {
    Describir() string
}

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Tarea no dice «implements Describible» en ningún sitio.
// Tiene el método Describir() string, así que YA cumple la interfaz.
func (t Tarea) Describir() string {
    if t.Hecha {
        return "[x] " + t.Titulo
    }
    return "[ ] " + t.Titulo
}

// En PHP: function imprimir(Describible $d): void
func Imprimir(d Describible) {
    fmt.Println(d.Describir())
}

func main() {
    Imprimir(Tarea{Titulo: "Comprar pan"})
    Imprimir(Tarea{Titulo: "Repasar Go", Hecha: true})
}

El compilador hace la comprobación cuando usas una Tarea como Describible (al llamar a Imprimir). Si a Tarea le faltara el método, el programa no compilaría, igual que en PHP sale un error fatal si te dejas un método de la interfaz.

Equivalencia POO · PHP → Go

Las interfaces de Go se parecen mucho a las de PHP. Lo que cambia es quién firma: en PHP la clase; en Go nadie, lo comprueba el compilador.

PHPGoQuién lo ve / lo comprueba
interface RepositorioTareas { … }type RepositorioTareas interface { … }Cualquiera que importe el paquete (empieza por mayúscula)
class RepoMemoria implements RepositorioTareasNada: basta con tener los métodosEl compilador, donde usas el tipo como interfaz
__toString()String() string (interfaz fmt.Stringer)fmt.Println, %v y %s lo llaman solos
mixedanyCualquiera; para usar el valor hay que preguntar su tipo
$v instanceof Tareat, ok := v.(Tarea)Solo funciona sobre una interfaz (any, Describible…)
abstract classNo existe: interfaz + struct embebidoLo verás en la lección siguiente

¿Por qué? · En PHP no existe

¿Por qué no hay implements? En PHP no existe esta libertad

En PHP, para que la clase Mailer de una librería de Composer encaje con tu interfaz Notificador, tendrías que editar vendor/ para añadir implements Notificador. No puedes, así que escribes un adaptador (una clase envoltorio) solo para eso.

En Go, la interfaz la escribe quien la necesita, no quien hace el tipo. Si el tipo de la librería ya tiene el método, encaja sin tocarlo. Así se evitan dos problemas de PHP:

  • Las clases no se atan a interfaces de otros: el paquete que hace el tipo no importa el paquete que lo usa.
  • No hay que crear adaptadores de relleno para tipos de terceros que ya hacen lo que pides.

El precio: no ves en la declaración qué interfaces cumple un tipo. A cambio, el compilador te lo dice en cuanto lo usas mal.

2 · El RepositorioTareas de la app

Esta es la interfaz central de nuestra app de tareas. Dice qué sabe hacer un repositorio, no cómo. Hoy la cumplirá un repositorio en memoria (un map); en el proyecto final, uno con SQLite. El resto de la app no notará el cambio, igual que en PHP cambias Doctrine por un repositorio en memoria en los tests.

Gomain.go
package main

import (
    "errors"
    "fmt"
)

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

// El error que se devuelve si no existe (lo verás a fondo en el módulo 06).
var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

// En PHP: interface RepositorioTareas { 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
}

// RepoMemoria guarda las tareas en un map. No dice «implements» en ningún sitio.
type RepoMemoria struct {
    tareas    map[int]Tarea
    siguiente int
}

// En PHP: new RepoMemoria() con su constructor.
func NuevoRepoMemoria() *RepoMemoria {
    return &RepoMemoria{tareas: map[int]Tarea{}}
}

func (r *RepoMemoria) Guardar(t Tarea) (Tarea, error) {
    if t.ID == 0 {
        r.siguiente++
        t.ID = r.siguiente
    }
    r.tareas[t.ID] = t
    return t, nil
}

func (r *RepoMemoria) BuscarPorID(id int) (Tarea, error) {
    t, ok := r.tareas[id]
    if !ok {
        return Tarea{}, ErrTareaNoEncontrada
    }
    return t, nil
}

func (r *RepoMemoria) Listar() ([]Tarea, error) {
    lista := make([]Tarea, 0, len(r.tareas))
    // Recorremos por ID para que el orden sea siempre el mismo.
    for id := 1; id <= r.siguiente; id++ {
        if t, ok := r.tareas[id]; ok {
            lista = append(lista, t)
        }
    }
    return lista, nil
}

func (r *RepoMemoria) Borrar(id int) error {
    if _, ok := r.tareas[id]; !ok {
        return ErrTareaNoEncontrada
    }
    delete(r.tareas, id)
    return nil
}

// ContarPendientes solo conoce el contrato: no sabe si hay un map o SQLite debajo.
func ContarPendientes(repo RepositorioTareas) int {
    tareas, _ := repo.Listar()
    n := 0
    for _, t := range tareas {
        if !t.Hecha {
            n++
        }
    }
    return n
}

func main() {
    // Aquí el compilador comprueba que *RepoMemoria cumple RepositorioTareas.
    var repo RepositorioTareas = NuevoRepoMemoria()

    repo.Guardar(Tarea{Titulo: "Comprar pan"})
    repo.Guardar(Tarea{Titulo: "Repasar Go", Hecha: true})
    repo.Guardar(Tarea{Titulo: "Llamar al banco"})
    repo.Borrar(1)

    _, err := repo.BuscarPorID(1)
    fmt.Println("¿Sigue la 1?", err)
    fmt.Println("Pendientes:", ContarPendientes(repo))
}

3 · Receptor puntero: ¿quién cumple la interfaz?

En el módulo 04 viste que un método con receptor puntero (func (r *RepoMemoria)) puede cambiar el struct original. Eso afecta a las interfaces: los métodos con *RepoMemoria son de *RepoMemoria (la dirección), no de RepoMemoria (una copia).

Si intentas meter el valor en la interfaz, Go se niega:

Gomain.go
// Guardar tiene receptor puntero: func (r *RepoMemoria) Guardar(...)
var repo RepositorioTareas = RepoMemoria{}
cannot use RepoMemoria{} (value of struct type RepoMemoria) as RepositorioTareas value in variable declaration: RepoMemoria does not implement RepositorioTareas (method Guardar has pointer receiver)

Y si te dejas un método, el mensaje te dice cuál:

cannot use &RepoMemoria{} (value of type *RepoMemoria) as RepositorioTareas value in variable declaration: *RepoMemoria does not implement RepositorioTareas (missing method Borrar)
Si los métodos tienen receptor…Cumple la interfaz RepoMemoria{}Cumple la interfaz &RepoMemoria{}
por valor: func (r RepoMemoria)SíSí
puntero: func (r *RepoMemoria)NoSí

¿Por qué? · En PHP no existe

¿Por qué el valor no cumple la interfaz? En PHP no pasa

En PHP los objetos siempre viajan por referencia: $repo->guardar() cambia el repositorio, nunca una copia. En Go un struct se copia al meterlo en una interfaz.

Si Go dejara meter la copia, Guardar cambiaría la copia y tus tareas desaparecerían sin avisar. Para que eso no pase, el compilador exige la dirección (&): así todos trabajan sobre el mismo repositorio.

Regla práctica: si el método cambia el struct, receptor puntero, y en la interfaz metes &valor (o lo que devuelve un NuevoX() que ya da un puntero).

4 · fmt.Stringer: el __toString() de Go

La interfaz más famosa de Go tiene un solo método:

Gomain.go
// Está en el paquete fmt.
type Stringer interface {
    String() string
}

Si tu tipo tiene String() string, fmt.Println, %v y %s lo usan solos para pintarlo. Es tu __toString(), y sirve también para los enums con iota del módulo 04:

Gomain.go
package main

import "fmt"

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

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

type Tarea struct {
    Titulo    string
    Prioridad Prioridad
    Hecha     bool
}

// En PHP: public function __toString(): string
func (t Tarea) String() string {
    marca := "[ ]"
    if t.Hecha {
        marca = "[x]"
    }
    return fmt.Sprintf("%s %s (%v)", marca, t.Titulo, t.Prioridad)
}

func main() {
    t := Tarea{Titulo: "Pagar el alquiler", Prioridad: Alta}
    // Println ve que Tarea es un fmt.Stringer y llama a String()
    fmt.Println(t)
    fmt.Printf("Prioridad: %v\n", Media)

    tareas := []Tarea{t, {Titulo: "Regar", Hecha: true}}
    // También dentro de un slice
    fmt.Println(tareas)
}

5 · any y el type switch: mixed e instanceof

any es una interfaz sin métodos, así que todo la cumple. Es tu mixed. Pero con un any en la mano no puedes hacer casi nada: primero tienes que preguntar qué hay dentro, como abrir una caja sin etiqueta.

Hay dos formas de preguntar:

  1. Aserción de tipo (type assertion): t, ok := v.(Tarea). Es el «comma ok» del módulo 04: ok dice si dentro había una Tarea. En PHP: if ($v instanceof Tarea).
  2. Type switch: switch x := v.(type) { case …: }. Un switch sobre el tipo. En PHP: match (true) { $v instanceof Tarea => …, is_int($v) => … }.
Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
}

// En PHP: function describir(mixed $v): string
func Describir(v any) string {
    // En cada case, x ya tiene el tipo de ese case.
    switch x := v.(type) {
    case Tarea:
        return "una tarea: " + x.Titulo
    case int:
        return fmt.Sprintf("un ID: %d", x)
    case string:
        return "un texto de " + fmt.Sprint(len(x)) + " letras"
    case nil:
        return "nada"
    default:
        return fmt.Sprintf("no sé qué es un %T", x)
    }
}

func main() {
    fmt.Println(Describir(Tarea{Titulo: "Comprar pan"}))
    fmt.Println(Describir(42))
    fmt.Println(Describir("hola"))
    fmt.Println(Describir(nil))
    fmt.Println(Describir(3.5))

    // Aserción con comma ok: si no es una Tarea, ok es false y no hay pánico.
    var v any = "no soy una tarea"
    t, ok := v.(Tarea)
    fmt.Printf("ok=%v, t=%+v\n", ok, t)
}

6 · Interfaces pequeñas y la trampa del nil

En Go se prefieren interfaces de uno o dos métodos. Cuanto más pequeña, más tipos la cumplen. La estrella es io.Writer: solo pide Write([]byte) (int, error). La cumplen la consola (os.Stdout), un fichero, una respuesta HTTP y un strings.Builder. Con una sola función escribes en todos:

Gomain.go
package main

import (
    "fmt"
    "io"
    "os"
    "strings"
)

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Exportar no sabe adónde escribe: solo que sabe Write().
// En PHP: function exportar($stream, array $tareas) con fwrite($stream, ...)
func Exportar(w io.Writer, tareas []Tarea) {
    for _, t := range tareas {
        fmt.Fprintf(w, "%v;%s\n", t.Hecha, t.Titulo)
    }
}

func main() {
    tareas := []Tarea{{Titulo: "Comprar pan"}, {Titulo: "Repasar Go", Hecha: true}}

    // A la consola (en PHP: php://output)
    Exportar(os.Stdout, tareas)

    // A un texto en memoria (en PHP: php://memory)
    var b strings.Builder
    Exportar(&b, tareas)
    fmt.Printf("En memoria: %d bytes\n", b.Len())
}

Ahora la trampa. Una interfaz guarda dos cosas: el tipo y el valor. Solo es nil si las dos están vacías. Si metes un puntero nil de tipo *Tarea, la interfaz tiene tipo, así que no es nil:

Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
}

func (t *Tarea) String() string {
    if t == nil {
        return "(sin tarea)"
    }
    return t.Titulo
}

// Mal: devuelve un *Tarea nil metido en una interfaz.
func BuscarMal(titulo string) fmt.Stringer {
    var t *Tarea
    if titulo == "pan" {
        t = &Tarea{Titulo: "Comprar pan"}
    }
    return t
}

// Bien: si no hay nada, devuelve nil a secas.
func BuscarBien(titulo string) fmt.Stringer {
    if titulo == "pan" {
        return &Tarea{Titulo: "Comprar pan"}
    }
    return nil
}

func main() {
    fmt.Println("BuscarMal == nil:", BuscarMal("leche") == nil)
    fmt.Println("BuscarBien == nil:", BuscarBien("leche") == nil)
}

La pregunta que te vas a hacer

«Vale, pero… ¿y el contenedor de dependencias de Laravel o Symfony?»

En PHP le dices al contenedor «cuando alguien pida RepositorioTareas, dale RepoDoctrine» y él lo inyecta solo. En Go lo normal es hacerlo a mano en main(): creas el repositorio y se lo pasas a quien lo necesite por su constructor. Sin magia ni reflexión: lo lees de arriba abajo.

Como las interfaces son implícitas y pequeñas, esto se queda corto y claro. Si el proyecto crece mucho, hay herramientas:

  • Effective Go: interfaces: la guía oficial de estilo.
  • Wire: genera el código de inyección en tiempo de compilación.
  • Fx: un contenedor de dependencias de Uber, más parecido al de Symfony.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Tu primer __toString()

Haz que Tarea se pinte sola con fmt.Println: su método String() string debe devolver [x] <titulo> si está hecha y [ ] <titulo> si no. El programa debe imprimir [x] Comprar pan y [ ] Llamar al banco. Es el __toString() de PHP.

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. Un tipo cumple una interfaz solo con tener sus métodos, sin implements (en PHP, class X implements Y).
  2. Si los métodos tienen receptor puntero, en la interfaz metes &valor (en PHP los objetos ya van por referencia).
  3. String() string es tu __toString(), y fmt.Println lo usa solo.
  4. any es mixed; v.(Tarea) con ok y switch v.(type) son tu instanceof y tu match (true).
  5. Interfaces pequeñas y declaradas donde se usan; y devuelve nil a secas, no un puntero nil (en PHP, null es solo null).

Para recordarlo: «Si encaja, vale»

Como un enchufe: a la interfaz no le importa qué conectas, solo que la clavija (los métodos) encaje. Nadie firma implements. Y para no pillarte los dedos: «método con estrella, en la interfaz va con &».