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

Composición con embedding: sin extends ni traits

8 min de lectura 3 retos

Go no tiene extends ni trait. Para reutilizar código mete un struct dentro de otro (embedding) y sus campos y métodos «suben» al de fuera. Parece herencia, pero no lo es, y esa diferencia es la que más sorprende a quien viene de PHP.

En 4 ideas
1/4

Embeber es poner un tipo dentro de un struct sin nombre de campo: type TareaUrgente struct { Tarea }. En PHP sería class TareaUrgente extends Tarea o un use ConMarcaDeTiempo;.

1 · Sin extends ni traits: embedding

Herencia es decir «una TareaUrgente es una Tarea». Composición es decir «una TareaUrgente lleva dentro una Tarea». Piensa en una mochila: no es un estuche, pero lleva uno dentro y puedes sacar los lápices sin abrir el estuche a mano.

En Go se escribe el tipo dentro del struct sin nombre de campo. A eso se le llama embedding (incrustar):

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

trait ConMarcaDeTiempo
{
    public string $creadaEn = "2026-11-17";

    public function antiguedad(): string
    {
        return "creada el {$this->creadaEn}";
    }
}

class Tarea
{
    public function __construct(public string $titulo) {}

    public function describir(): string
    {
        return "Tarea: {$this->titulo}";
    }
}

final class TareaUrgente extends Tarea
{
    use ConMarcaDeTiempo;

    public function describir(): string
    {
        return "¡URGENTE! " . parent::describir();
    }
}

$u = new TareaUrgente("Pagar el alquiler");
echo $u->describir() . PHP_EOL;
echo $u->antiguedad() . PHP_EOL;
echo $u->titulo . PHP_EOL;
Gomain.go
package main

import "fmt"

// En PHP: trait ConMarcaDeTiempo
type MarcaDeTiempo struct {
    CreadaEn string
}

func (m MarcaDeTiempo) Antiguedad() string {
    return "creada el " + m.CreadaEn
}

type Tarea struct {
    Titulo string
}

func (t Tarea) Describir() string {
    return "Tarea: " + t.Titulo
}

// TareaUrgente LLEVA DENTRO una Tarea y una MarcaDeTiempo (sin nombre de campo).
// En PHP: class TareaUrgente extends Tarea { use ConMarcaDeTiempo; }
type TareaUrgente struct {
    Tarea
    MarcaDeTiempo
}

// Tapa el Describir de Tarea y lo reutiliza.
func (u TareaUrgente) Describir() string {
    // En PHP: parent::describir()
    return "¡URGENTE! " + u.Tarea.Describir()
}

func main() {
    u := TareaUrgente{
        Tarea:         Tarea{Titulo: "Pagar el alquiler"},
        MarcaDeTiempo: MarcaDeTiempo{CreadaEn: "2026-11-17"},
    }
    fmt.Println(u.Describir())
    // Antiguedad() «sube» desde MarcaDeTiempo
    fmt.Println(u.Antiguedad())
    // Los campos también suben: u.Titulo es u.Tarea.Titulo
    fmt.Println(u.Titulo)
}

Fíjate en dos cosas. El campo embebido se llama como su tipo: u.Tarea y u.MarcaDeTiempo. Y el parent::describir() de PHP es simplemente u.Tarea.Describir(): llamas al método del campo de dentro por su nombre.

Equivalencia POO · PHP → Go

Todo lo que en PHP haces con herencia y traits, en Go se hace metiendo structs dentro de structs (y con interfaces cuando necesitas polimorfismo).

PHPGoQuién lo ve
class TareaUrgente extends Tareatype TareaUrgente struct { Tarea }Los campos y métodos públicos de Tarea suben a TareaUrgente
use ConMarcaDeTiempo; (trait)struct { MarcaDeTiempo }Igual: lo de MarcaDeTiempo sube al struct de fuera
parent::describir()u.Tarea.Describir()Cualquiera: el campo embebido es un campo más
protectedNo existeLo que empieza por minúscula lo ve todo el paquete
abstract class / final classNo existen: no hay herencia que limitarPara «obligar a implementar», una interfaz
interface A extends B, Ctype A interface { B; C }Quien use A necesita todos los métodos de B y C

2 · Promoción de campos y métodos

Cuando escribes u.Titulo, Go busca Titulo primero en TareaUrgente. Si no lo encuentra, baja un nivel y lo busca en los tipos embebidos. A eso se le llama promoción: lo de dentro sube.

  • Si el de fuera tiene un campo o método con el mismo nombre, gana el de fuera y tapa al de dentro (como un método que sobrescribes).
  • Al de dentro siempre puedes llegar por su nombre completo: u.Tarea.Describir().
  • Si dos tipos embebidos al mismo nivel tienen el mismo nombre y el de fuera no lo tapa, Go no elige por ti.

Ese último caso es el problema del diamante de la herencia múltiple. PHP lo resuelve con insteadof en los traits; Go se niega a compilar si lo usas:

Gomain.go
type Auditoria struct{ Autor string }

func (a Auditoria) Resumen() string { return a.Autor }

type Etiquetado struct{ Etiqueta string }

func (e Etiquetado) Resumen() string { return e.Etiqueta }

type TareaAuditada struct {
    Auditoria
    Etiquetado
}

// t.Resumen(): ¿el de Auditoria o el de Etiquetado?
ambiguous selector t.Resumen
Gomain.go
package main

import "fmt"

type Contador struct {
    total int
}

// Receptor puntero: cambia el contador de verdad.
func (c *Contador) Sumar() {
    c.total++
}

func (c Contador) Total() int {
    return c.total
}

type Lista struct {
    Nombre string
    Contador
    Tareas []string
}

func (l *Lista) Agregar(titulo string) {
    l.Tareas = append(l.Tareas, titulo)
    // Sumar() sube desde Contador. En PHP: $this->sumar() de un trait.
    l.Sumar()
}

func main() {
    hoy := &Lista{Nombre: "Hoy"}
    hoy.Agregar("Comprar pan")
    hoy.Agregar("Repasar Go")
    fmt.Println(hoy.Nombre, "tiene", hoy.Total(), "tareas:", hoy.Tareas)
}

3 · No es herencia: el método del de dentro no ve al de fuera

Aquí está la trampa. En PHP, cuando un método de la clase padre llama a $this->etiqueta(), PHP mira qué objeto es de verdad y llama a la versión del hijo. Go no hace eso.

Cuando Tarea.Describir() llama a t.Etiqueta(), t es una Tarea, punto. La Tarea no sabe que vive dentro de una TareaUrgente, igual que el estuche no sabe en qué mochila está:

Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
}

func (t Tarea) Etiqueta() string {
    return "normal"
}

// Describir llama a t.Etiqueta(): t es SIEMPRE una Tarea.
func (t Tarea) Describir() string {
    return "[" + t.Etiqueta() + "] " + t.Titulo
}

type TareaUrgente struct {
    Tarea
}

// Tapa Etiqueta... pero solo para quien llame a u.Etiqueta().
func (u TareaUrgente) Etiqueta() string {
    return "URGENTE"
}

func main() {
    u := TareaUrgente{Tarea{Titulo: "Pagar el alquiler"}}
    fmt.Println(u.Etiqueta())
    // En PHP saldría [URGENTE]; en Go sale [normal].
    fmt.Println(u.Describir())
}

Y otra diferencia: una TareaUrgente no es una Tarea. No puedes pasarla a una función que pide Tarea; tienes que pasar u.Tarea:

Gomain.go
func Imprimir(t Tarea) { fmt.Println(t.Titulo) }

u := TareaUrgente{Tarea{Titulo: "Pagar"}}
// No compila: TareaUrgente no es Tarea
Imprimir(u)
// Compila: le pasas la Tarea que lleva dentro
Imprimir(u.Tarea)
cannot use u (variable of struct type TareaUrgente) as Tarea value in argument to Imprimir

¿Por qué? · En PHP no existe

¿Por qué Go no tiene herencia? En PHP es lo normal

La herencia ata al hijo con el padre por dentro. Si cambias un método del padre, puedes romper hijos que ni conoces, porque PHP llama a sus versiones sin avisar. Es el problema de la clase base frágil, y la razón de que en PHP moderno se recomiende marcar las clases como final.

En Go cada tipo hace solo lo suyo. Lo que el de fuera reutiliza está a la vista (u.Tarea) y nadie cambia el comportamiento del de dentro por la espalda. Cuando de verdad quieres que algo varíe, lo dices con una interfaz:

Gomain.go
type Etiquetador interface {
    Etiqueta() string
}

// El que varía (la etiqueta) entra por parámetro, a la vista.
func Describir(e Etiquetador, titulo string) string {
    return "[" + e.Etiqueta() + "] " + titulo
}

Así se evita el extends de cinco niveles en el que nadie sabe ya qué método se ejecuta.

4 · Embeber interfaces: contratos que se suman y decoradores

Una interfaz puede llevar otras dentro. Es tu interface RepositorioTareas extends Lector, Escritor de PHP. La biblioteca estándar lo hace mucho: io.ReadWriter es io.Reader + io.Writer.

Gomain.go
type LectorTareas interface {
    BuscarPorID(id int) (Tarea, error)
    Listar() ([]Tarea, error)
}

type EscritorTareas interface {
    Guardar(t Tarea) (Tarea, error)
    Borrar(id int) error
}

// En PHP: interface RepositorioTareas extends LectorTareas, EscritorTareas {}
type RepositorioTareas interface {
    LectorTareas
    EscritorTareas
}

Así, una función que solo lee pide LectorTareas y no puede borrar nada por error.

Y un struct puede embeber una interfaz. Todos sus métodos suben, y tú tapas solo los que quieres cambiar. Es el patrón decorador: envolver algo para añadirle un extra (un log, una caché) sin tocarlo, como poner una funda al móvil.

Gomain.go
package main

import "fmt"

type Tarea struct {
    ID     int
    Titulo string
}

type RepositorioTareas interface {
    Guardar(t Tarea) (Tarea, error)
    Listar() ([]Tarea, error)
}

type RepoMemoria struct {
    tareas []Tarea
}

func (r *RepoMemoria) Guardar(t Tarea) (Tarea, error) {
    t.ID = len(r.tareas) + 1
    r.tareas = append(r.tareas, t)
    return t, nil
}

func (r *RepoMemoria) Listar() ([]Tarea, error) {
    return r.tareas, nil
}

// RepoConLog lleva dentro CUALQUIER RepositorioTareas.
// Listar() sube tal cual; Guardar() lo tapamos para añadir el log.
type RepoConLog struct {
    RepositorioTareas
}

func (r RepoConLog) Guardar(t Tarea) (Tarea, error) {
    fmt.Println("log: guardando", t.Titulo)
    // En PHP: return $this->interno->guardar($t);
    return r.RepositorioTareas.Guardar(t)
}

func main() {
    var repo RepositorioTareas = RepoConLog{&RepoMemoria{}}
    repo.Guardar(Tarea{Titulo: "Comprar pan"})
    repo.Guardar(Tarea{Titulo: "Repasar Go"})

    tareas, _ := repo.Listar()
    fmt.Println("Hay", len(tareas), "tareas")
}

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Embebe la auditoría

Haz que TareaAuditada embeba también Auditoria, y cambia la segunda línea de main para que use el método promocionado u.Firma(). Debe imprimir Tarea: Comprar pan y firmada por Ana. Es el use UnTrait; 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. Embeber es poner un tipo sin nombre de campo: struct { Tarea } (en PHP, extends Tarea o use UnTrait;).
  2. Los campos y métodos de dentro suben: u.Titulo, u.Describir(); y el de fuera puede taparlos (como sobrescribir).
  3. parent::metodo() es u.Tarea.Metodo(): el campo embebido se llama como su tipo.
  4. No es herencia: el de dentro no llama a los métodos del de fuera, y una TareaUrgente no es una Tarea (en PHP, $this sí ve al hijo).
  5. Las interfaces se suman embebiéndolas (interface A extends B, C) y un struct que embebe una interfaz es un decorador gratis.

Para recordarlo: «Lleva dentro, no es»

Como la mochila y el estuche: la mochila lleva dentro un estuche y puedes sacar los lápices directamente, pero la mochila no es un estuche, y el estuche no sabe en qué mochila está.