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 12 de 36 · De clases a structs ✦ WebMCP implementado

Structs: clases sin clases

9 min de lectura 4 retos

En Go no hay clases. Hay structs: fichas con campos que tienen nombre y tipo. En esta lección montas la Tarea de nuestra app, ves cómo se crea sin constructor y en qué se parece y en qué no a una clase de PHP.

¿De dónde vienen los nombres?

struct = structure (estructura)
La palabra viene de C, donde un struct agrupa varios datos bajo un nombre. En PHP lo más parecido es una clase que solo tiene propiedades.
json = JavaScript Object Notation
El mismo formato que generas con json_encode(). En Go lo maneja el paquete encoding/json.
Marshal = to marshal (ordenar, poner en formación)
Convertir un valor de Go en bytes de JSON: tu json_encode(). Lo contrario es Unmarshal, tu json_decode().
En 4 ideas
1/4

Un struct es una ficha con campos tipados. Es como una clase de PHP con solo propiedades: class Tarea { public int $id; public string $titulo; }.

1 · Un struct es una ficha

Piensa en una ficha de cartulina. Arriba pone «Tarea» y debajo hay huecos con su nombre: número, título, ¿hecha? Cada hueco solo admite un tipo de dato. Eso es un struct.

En PHP lo harías con una clase que solo tiene propiedades. En Go se declara con type Nombre struct { ... }:

Gomain.go
package main

import "fmt"

// En PHP: class Tarea { public int $id; public string $titulo; ... }
type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

func main() {
    // En PHP: $t = new Tarea(); $t->id = 1; $t->titulo = "Comprar pan";
    t := Tarea{ID: 1, Titulo: "Comprar pan"}

    // En PHP: $t->hecha = true;
    t.Hecha = true

    fmt.Println(t.Titulo)
    // %+v imprime el struct con el nombre de cada campo
    fmt.Printf("%+v\n", t)
}

Fíjate en tres cosas:

  1. Los campos se leen y se escriben con un punto: t.Titulo. Es tu $t->titulo, sin flecha.
  2. No hay new: escribes el tipo y, entre llaves, los campos que quieras rellenar.
  3. El campo que no rellenas no queda «sin definir»: toma su valor cero (0, "", false). Por eso Hecha valía false antes de cambiarlo.

Equivalencia POO · PHP → Go

Un struct cubre la parte de datos de una clase. Los métodos llegan en la lección siguiente, y la herencia no existe.

PHPGoQuién lo ve
class Tarea { ... }type Tarea struct { ... }Lo que el nombre diga: Tarea exportado, tarea solo el paquete
public string $titulo;Titulo stringCualquier paquete que importe el tuyo
private string $nota;nota stringSolo el código del mismo paquete (no solo el mismo struct)
protected—No existe: no hay herencia
new Tarea()Tarea{}Un literal: crea el valor con sus campos a valor cero
public function __construct(...)func NuevaTarea(...) TareaUna función normal del paquete, por convención Nuevo…
readonly—No existe: se protege con campos en minúscula y métodos de lectura

2 · Crear tareas: literales y valor cero

Hay varias formas de crear un struct. Todas son literales: escribes el valor tal cual, como escribes [1, 2, 3] para un array en PHP.

Gomain.go
// Con nombres de campo: la forma buena (el orden da igual)
a := Tarea{ID: 1, Titulo: "Comprar pan"}

// Sin nombres: en el orden exacto de la declaración (frágil, evítalo)
b := Tarea{2, "Llamar al banco", false}

// Vacía: todos los campos a valor cero
var c Tarea

// Con & delante obtienes un puntero, como el objeto de PHP (módulo 03)
d := &Tarea{ID: 4, Titulo: "Repasar Go"}
d.Hecha = true

Usa siempre la primera forma. Si mañana añades un campo Prioridad, los literales sin nombres dejan de compilar todos a la vez, y los que llevan nombres siguen funcionando.

Y si te equivocas al escribir un campo, Go no te deja seguir. Este es el mensaje real del compilador con Tarea{ID: 1, Titlo: "pan"}:

./main.go:11:23: unknown field Titlo in struct literal of type Tarea

¿Por qué? · En PHP no existe

¿Por qué no puedo añadir campos sobre la marcha? En PHP sí

En PHP, $t->titlo = "pan"; (con una errata) crea una propiedad dinámica nueva y la buena se queda vacía. PHP 8.2 solo lo marca como obsoleto, y un stdClass lo acepta siempre.

En Go la forma del struct se decide al declararlo y no cambia nunca. Ventajas:

  • El compilador caza las erratas en los nombres de campo antes de ejecutar.
  • Cada Tarea ocupa siempre lo mismo en memoria, así que crear un millón es barato y rápido.
  • Tu editor sabe exactamente qué campos hay y te los autocompleta todos.

3 · Sin constructor: la función NuevaTarea

Go no tiene __construct. Cuando crear una tarea necesita algo más que rellenar campos (limpiar el título, poner un valor por defecto), escribes una función normal que devuelve la tarea ya montada. Por convención se llama Nuevo… o Nueva… (en inglés, NewTask).

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

final class Tarea
{
    public function __construct(
        public readonly int $id,
        public readonly string $titulo,
        public bool $hecha = false,
    ) {}

    public static function nueva(int $id, string $titulo): self
    {
        $titulo = trim($titulo);
        return new self($id, $titulo === "" ? "Sin título" : $titulo);
    }
}

$t = Tarea::nueva(1, "  Comprar pan ");
echo "{$t->id}: {$t->titulo}" . PHP_EOL;
Gomain.go
package main

import (
    "fmt"
    "strings"
)

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

// NuevaTarea hace de constructor: es una función más del paquete.
// En PHP: public static function nueva(int $id, string $titulo): self
func NuevaTarea(id int, titulo string) Tarea {
    titulo = strings.TrimSpace(titulo)
    if titulo == "" {
        titulo = "Sin título"
    }
    return Tarea{ID: id, Titulo: titulo}
}

func main() {
    t := NuevaTarea(1, "  Comprar pan ")
    fmt.Printf("%d: %s\n", t.ID, t.Titulo)
}

¿Por qué? · En PHP no existe

¿Por qué Go no tiene constructores?

Un constructor de PHP es una función con reglas especiales: se llama con new, no puede devolver otra cosa, no puede fallar sin lanzar una excepción y no le puedes poner nombre. Si necesitas dos formas de crear un objeto, acabas con métodos static como Tarea::nueva() o Tarea::desdeArray().

Go se ahorra todo eso: una función normal puede llamarse como quieras, puede devolver un puntero o un valor y puede devolver además un error si los datos no valen (NuevaTarea(...) (Tarea, error), módulo 06). Y como todo campo tiene valor cero, muchas veces ni siquiera hace falta: Tarea{} ya es una tarea válida.

4 · Campos exportados y etiquetas json

Igual que con las funciones, la mayúscula inicial de un campo decide quién lo ve. Titulo se ve desde cualquier paquete; nota solo desde el tuyo. Esto importa mucho con JSON: el paquete encoding/json es otro paquete, así que solo ve los campos en mayúscula.

Para elegir el nombre de cada campo en el JSON se usan etiquetas (tags): un texto entre comillas invertidas detrás del tipo. Son como los atributos #[...] de PHP: información extra que otro código lee.

Gomain.go
package main

import (
    "encoding/json"
    "fmt"
)

type Tarea struct {
    ID     int    `json:"id"`
    Titulo string `json:"titulo"`
    Hecha  bool   `json:"hecha"`
    // en minúscula: encoding/json no la ve y no sale en el JSON
    nota string
}

func main() {
    t := Tarea{ID: 1, Titulo: "Comprar pan", nota: "solo para mí"}

    // En PHP: echo json_encode($t);
    datos, err := json.Marshal(t)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println(string(datos))
}

La pregunta que te vas a hacer

«Vale, pero… ¿y cómo devuelvo JSON desde mi API, como hago con json_encode()?»

Igual que aquí: defines un struct con sus etiquetas json, lo conviertes con json.Marshal (o lo escribes directamente en la respuesta HTTP con json.NewEncoder) y listo. Para leer el JSON que te mandan en un POST se usa lo contrario, json.Unmarshal, que rellena tu struct. Lo harás en el módulo 07.

5 · Comparar tareas con ==

Dos structs del mismo tipo se comparan con ==, campo a campo. Es como el == de PHP entre dos objetos de la misma clase. Y como en Go un struct es un valor (módulo 03), no hay un === que mire si es «el mismo objeto».

Gomain.go
package main

import "fmt"

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

func main() {
    a := Tarea{ID: 1, Titulo: "Comprar pan"}
    b := Tarea{ID: 1, Titulo: "Comprar pan"}
    c := Tarea{ID: 2, Titulo: "Comprar pan"}

    // En PHP: var_dump($a == $b);
    fmt.Println(a == b)
    fmt.Println(a == c)
}

Ojo: si el struct tiene un campo que no se puede comparar, como un slice de etiquetas, == no compila. Este es el mensaje real con Etiquetas []string:

./main.go:14:17: invalid operation: a == b (struct containing []string cannot be compared)

6 · Structs anónimos: para usar y tirar

A veces solo necesitas agrupar dos o tres datos una vez, sin darle nombre a un tipo. En PHP harías un array asociativo al vuelo, ['titulo' => 'pan', 'hecha' => true]. En Go hay structs anónimos: el tipo se escribe en el mismo sitio donde se usa.

Gomain.go
// En PHP: $resumen = ['total' => 3, 'hechas' => 1];
resumen := struct {
    Total  int
    Hechas int
}{Total: 3, Hechas: 1}

fmt.Println(resumen.Total, resumen.Hechas)

Donde más los verás es en los tests, para una lista de casos de prueba (módulo 07). Si ese mismo grupo de datos aparece en dos sitios, dale nombre con type.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Tu primera tarea como struct

Crea con un literal la tarea número 1 con el título Comprar pan, sin marcarla como hecha, para que el programa imprima exactamente {ID:1 Titulo:Comprar pan Hecha:false}. Es el new Tarea(1, 'Comprar pan') 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. type Tarea struct { ... } es una clase con solo propiedades (en PHP, class Tarea { public ... }).
  2. Se crea con un literal con nombres, Tarea{ID: 1, Titulo: "pan"} (en PHP, new Tarea(...)); lo que no rellenas queda a valor cero.
  3. No hay constructor: NuevaTarea(...) es una función normal (en PHP, __construct o un static de fábrica).
  4. Mayúscula = public, minúscula = private del paquete; las etiquetas json:"titulo" eligen el nombre en el JSON (en PHP, las claves de json_encode()).
  5. == compara campo a campo (en PHP, == entre objetos), y no compila si hay slices o maps dentro.

Para recordarlo: «Ficha, Literal, Nueva, Mayúscula»

FFicha
type Tarea struct
LLiteral
Tarea{ID: 1}
NNueva
NuevaTarea(...)
MMayúscula
Titulo

Ficha con campos, se rellena con un Literal, se prepara con Nueva… y la Mayúscula decide quién la ve. Sin clase, sin new, sin __construct.