Lección 16 de 36 · Interfaces, composición y genéricos✦ WebMCP implementado
Interfaces implícitas: sin implements
9 min de lectura4 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.
El compilador comprueba el contrato donde usas el tipo como interfaz, no donde lo declaras. Si falta un método, no compila, igual que PHP da un error fatal si no implementas un método de la interfaz.
String() string es el __toString() de Go: fmt.Println lo usa solo. any es el mixed de PHP, y el type switchswitch v.(type) es tu match (true) con instanceof.
En Go se prefieren interfaces pequeñas (uno o dos métodos) y se declaran donde se usan. En PHP es normal una interfaz grande junto a la clase que la implementa.
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
<?phpdeclare(strict_types=1);
interface Describible
{
publicfunctiondescribir(): string;
}
// En PHP hay que firmar el contrato con «implements».finalreadonlyclass Tarea implements Describible
{
publicfunction__construct(
public string $titulo,
public bool $hecha = false,
) {}
publicfunctiondescribir(): string
{
return ($this->hecha ? "[x] " : "[ ] ") . $this->titulo;
}
}
functionimprimir(Describible $d): void
{
echo$d->describir() . PHP_EOL;
}
imprimir(newTarea("Comprar pan"));
imprimir(newTarea("Repasar Go", hecha: true));
Gomain.go
package main
import"fmt"// En PHP: interface Describible { public function describir(): string; }typeDescribibleinterface {
Describir() string
}
typeTareastruct {
TitulostringHechabool
}
// 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): voidfuncImprimir(d Describible) {
fmt.Println(d.Describir())
}
funcmain() {
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.
PHP
Go
Quién lo ve / lo comprueba
interface RepositorioTareas { … }
type RepositorioTareas interface { … }
Cualquiera que importe el paquete (empieza por mayúscula)
class RepoMemoria implements RepositorioTareas
Nada: basta con tener los métodos
El compilador, donde usas el tipo como interfaz
__toString()
String() string (interfaz fmt.Stringer)
fmt.Println, %v y %s lo llaman solos
mixed
any
Cualquiera; para usar el valor hay que preguntar su tipo
$v instanceof Tarea
t, ok := v.(Tarea)
Solo funciona sobre una interfaz (any, Describible…)
abstract class
No existe: interfaz + struct embebido
Lo 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"
)
typeTareastruct {
IDintTitulostringHechabool
}
// El error que se devuelve si no existe (lo verás a fondo en el módulo 06).varErrTareaNoEncontrada = errors.New("tarea no encontrada")
// En PHP: interface RepositorioTareas { public function guardar(Tarea $t): Tarea; ... }typeRepositorioTareasinterface {
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.typeRepoMemoriastruct {
tareas map[int]Tarea
siguiente int
}
// En PHP: new RepoMemoria() con su constructor.funcNuevoRepoMemoria() *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 {
returnTarea{}, 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 {
returnErrTareaNoEncontrada
}
delete(r.tareas, id)
returnnil
}
// ContarPendientes solo conoce el contrato: no sabe si hay un map o SQLite debajo.funcContarPendientes(repo RepositorioTareas) int {
tareas, _ := repo.Listar()
n := 0for _, t := range tareas {
if !t.Hecha {
n++
}
}
return n
}
funcmain() {
// 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:
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)
No
Sí
¿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.typeStringerinterface {
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"typePrioridadintconst (
BajaPrioridad = iotaMediaAlta
)
// En PHP: public function label(): string en un enumfunc (p Prioridad) String() string {
switch p {
caseBaja:
return"baja"caseMedia:
return"media"caseAlta:
return"alta"
}
return"desconocida"
}
typeTareastruct {
TitulostringPrioridadPrioridadHechabool
}
// En PHP: public function __toString(): stringfunc (t Tarea) String() string {
marca := "[ ]"if t.Hecha {
marca = "[x]"
}
return fmt.Sprintf("%s %s (%v)", marca, t.Titulo, t.Prioridad)
}
funcmain() {
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:
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).
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"typeTareastruct {
Titulostring
}
// En PHP: function describir(mixed $v): stringfuncDescribir(v any) string {
// En cada case, x ya tiene el tipo de ese case.switch x := v.(type) {
caseTarea:
return"una tarea: " + x.Titulocaseint:
return fmt.Sprintf("un ID: %d", x)
casestring:
return"un texto de " + fmt.Sprint(len(x)) + " letras"casenil:
return"nada"default:
return fmt.Sprintf("no sé qué es un %T", x)
}
}
funcmain() {
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"
)
typeTareastruct {
TitulostringHechabool
}
// Exportar no sabe adónde escribe: solo que sabe Write().// En PHP: function exportar($stream, array $tareas) con fwrite($stream, ...)funcExportar(w io.Writer, tareas []Tarea) {
for _, t := range tareas {
fmt.Fprintf(w, "%v;%s\n", t.Hecha, t.Titulo)
}
}
funcmain() {
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.BuilderExportar(&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"typeTareastruct {
Titulostring
}
func (t *Tarea) String() string {
if t == nil {
return"(sin tarea)"
}
return t.Titulo
}
// Mal: devuelve un *Tarea nil metido en una interfaz.funcBuscarMal(titulo string) fmt.Stringer {
var t *Tareaif titulo == "pan" {
t = &Tarea{Titulo: "Comprar pan"}
}
return t
}
// Bien: si no hay nada, devuelve nil a secas.funcBuscarBien(titulo string) fmt.Stringer {
if titulo == "pan" {
return &Tarea{Titulo: "Comprar pan"}
}
returnnil
}
funcmain() {
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:
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 · ✓ Resuelto
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
Pista. Mira t.Hecha con un if y antepón la marca al título con +.
Reto 2 de 4 · ✓ Resuelto
¿Qué hay en la caja?
Completa Describir(v any) string con un type switch: una Tarea devuelve tarea: <titulo>, un int devuelve id <n>, un string devuelve texto: <s> y cualquier otra cosa (también nil) devuelve desconocido. Por ejemplo Describir(7) devuelve id 7. Es el match (true) con instanceof e is_int() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.switch x := v.(type) { case Tarea: … case int: … }. Dentro de cada case, x ya es de ese tipo. default recoge el resto, incluido nil.
Reto 3 de 4 · ✓ Resuelto
Completa el repositorio en memoria
RepoMemoria ya sabe Guardar y Listar. Escribe BuscarPorID(id int) (Tarea, error) y Borrar(id int) error: si el ID no existe, los dos devuelven ErrTareaNoEncontrada; si existe, BuscarPorID devuelve la tarea y Borrar la quita del map. Los tests lo usan a través de la interfazRepositorioTareas. En PHP sería el find() y el remove() de un repositorio en memoria para tests.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Usa el «comma ok» del map: t, ok := r.tareas[id]. Si !ok, devuelve ErrTareaNoEncontrada. Para quitar una clave: delete(r.tareas, id).
Reto 4 de 4 · ✓ Resuelto
Filtros pequeños
Con la interfaz de un método Filtro (Acepta(t Tarea) bool), haz que SoloPendientes acepte las tareas no hechas, que ConEtiqueta acepte las que llevan su Etiqueta, y escribe Aplicar(ts []Tarea, f Filtro) []Tarea, que devuelve las tareas aceptadas en el mismo orden. Por ejemplo Aplicar(ts, ConEtiqueta{Etiqueta: "urgente"}). Es como pasar a array_filter() objetos que implementan una interfaz Filtro.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.SoloPendientes devuelve !t.Hecha. Para la etiqueta, slices.Contains(t.Etiquetas, f.Etiqueta) (o un for). En Aplicar, recorre ts y haz append de las que f.Acepta(t).
Resumen
Lo que te llevas de esta lección
Un tipo cumple una interfaz solo con tener sus métodos, sin implements (en PHP, class X implements Y).
Si los métodos tienen receptor puntero, en la interfaz metes &valor (en PHP los objetos ya van por referencia).
String() string es tu __toString(), y fmt.Println lo usa solo.
any es mixed; v.(Tarea) con ok y switch v.(type) son tu instanceof y tu match (true).
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 &».