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 11 de 36 · Memoria: valores y punteros ✦ WebMCP implementado

Punteros: lo que hacía & en PHP

9 min de lectura 4 retos

En la lección anterior viste que Go copia los structs. ¿Y si una función sí tiene que cambiarte la tarea? Para eso están los punteros: en vez de la fotocopia, le das la dirección de tu tarea. Es lo que en PHP hacías con &$tarea, pero a la vista y con las reglas claras.

¿De dónde vienen los nombres?

& = operador de dirección (address-of)
&t se lee «la dirección de t». En PHP, &$t crea una referencia; en Go te da un puntero.
* = indirección (pointer indirection), «lo apuntado por»
*p se lee «lo que hay en la dirección p». Y en un tipo, *Tarea se lee «puntero a Tarea».
nil = del latín nihil, «nada»
El valor de un puntero que no apunta a ninguna parte: el null de PHP.
new = new (nuevo)
Reserva una variable nueva y te da su dirección. No tiene nada que ver con el new de las clases de PHP: no llama a ningún constructor.
En 4 ideas
1/4

Un puntero guarda la dirección de una variable, no su valor. &t te da la dirección y *p lee o escribe lo que hay ahí. En PHP, lo más parecido es la referencia &$t.

1 · ¿Qué es un puntero?

Cada variable vive en un sitio de la memoria, como cada casa vive en una calle con su número. Un puntero es un papelito con la dirección de esa casa apuntada. Con el papelito puedes ir a la casa y cambiar lo que hay dentro.

  • & = «dame la dirección». p := &pendientes apunta en p dónde vive pendientes.
  • * = «ve a esa dirección». *p es lo que hay en esa casa: puedes leerlo y escribirlo.
  • *int es el tipo «puntero a un int». El * delante de un tipo significa eso.
Gomain.go
package main

import "fmt"

func main() {
    pendientes := 3

    // p guarda la dirección de pendientes (su tipo es *int)
    p := &pendientes
    fmt.Println("p apunta a un valor:", *p)

    // Escribir en *p es escribir en pendientes
    // En PHP: $ref = &$pendientes; $ref = 5;
    *p = 5
    fmt.Println("pendientes:", pendientes)

    // Una copia normal no comparte nada
    copia := pendientes
    copia = 100
    fmt.Println("pendientes:", pendientes, "copia:", copia)

    // La dirección en sí es un número (cambia en cada ejecución)
    fmt.Printf("tipo de p: %T\n", p)
}

2 · De &$x en PHP a *T en Go

En PHP ya usabas algo parecido: la referencia con &. Cuando una función recibe array &$tarea, trabaja con tu array, no con una copia. En Go lo haces con un puntero, y el & se pone al llamar, para que se vea quién puede cambiar qué.

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

// El & de la firma hace que $tarea sea TU array, no una copia
function completar(array &$tarea): void
{
    $tarea["hecha"] = true;
}

$tarea = ["titulo" => "Comprar pan", "hecha" => false];

// Al llamar no se ve el &: hay que mirar la firma
completar($tarea);

echo "hecha: " . var_export($tarea["hecha"], true) . PHP_EOL;
Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

// *Tarea: recibe la dirección de una tarea, no una fotocopia
func Completar(t *Tarea) {
    // Es lo mismo que (*t).Hecha = true: Go pone el * por ti
    t.Hecha = true
}

func main() {
    tarea := Tarea{Titulo: "Comprar pan"}

    // Al llamar SÍ se ve: &tarea, «te doy mi dirección»
    Completar(&tarea)

    fmt.Println("hecha:", tarea.Hecha)
}

Fíjate en t.Hecha = true. Con un puntero, lo correcto sería (*t).Hecha, «ve a la dirección y cambia el campo». Como es tan habitual, Go te deja escribir solo t.Hecha y pone el * por ti. No hay -> como en PHP: el punto vale para los dos casos.

Y si te olvidas del & al llamar, Go no te deja seguir. Este es el error de verdad del compilador:

./main.go:12:15: cannot use t (variable of struct type Tarea) as *Tarea value in argument to Completar

¿Por qué? · En PHP no existe

¿Por qué punteros a la vista, si en PHP vivía sin ellos? En PHP no existen así

En realidad PHP los usa todo el rato, pero escondidos: cada objeto viaja por handle y cada & crea una referencia. El problema es que no se ve al llamar. En completar($tarea) no sabes si te van a cambiar la tarea: tienes que ir a leer la firma, o el cuerpo si es un objeto.

En Go se ve en los dos lados:

  • En la firma: func Completar(t *Tarea) avisa «yo puedo cambiarla»; func Mostrar(t Tarea) promete «yo no te la toco».
  • En la llamada: Completar(&tarea) lleva el &, así que al leer el código sabes que esa línea puede cambiar tarea.

¿Y por qué no los punteros peligrosos de C? En Go no hay aritmética de punteros (no puedes hacer p + 1 para ir a la casa de al lado) y el recolector de basura no tira nada que siga apuntado. Te quedas con lo útil y sin las trampas.

3 · Crear con &Tarea{} y con new

Muchas veces quieres crear una tarea y quedarte directamente con su dirección. Hay dos formas:

  • &Tarea{Titulo: "Comprar pan"}: crea la tarea con sus campos y te da su dirección. Es la más usada.
  • new(Tarea): crea una tarea con todos sus campos a su valor cero ("", false) y te da su dirección. Desde Go 1.26 también vale con un valor: new(3) te da un *int que apunta a un 3.
Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

// NuevaTarea crea una tarea y devuelve su dirección
// En PHP: return new Tarea($titulo);
func NuevaTarea(titulo string) *Tarea {
    t := Tarea{Titulo: titulo}
    // Devolver la dirección de una variable local es seguro en Go
    return &t
}

func main() {
    pan := NuevaTarea("Comprar pan")
    pan.Hecha = true
    fmt.Println(pan.Titulo, pan.Hecha)

    vacia := new(Tarea)
    fmt.Printf("%q %v\n", vacia.Titulo, vacia.Hecha)

    // Dos llamadas, dos tareas distintas en dos direcciones distintas
    fmt.Println("¿la misma?", NuevaTarea("a") == NuevaTarea("a"))
}

Equivalencia POO · PHP → Go

El new de Go no es el de PHP: no hay clases ni constructores. Lo que en PHP es new Tarea(...), en Go suele ser &Tarea{...} o una función NuevaTarea(...) (lo verás a fondo en el módulo 04).

PHPGoQuién lo ve
new Tarea("pan")&Tarea{Titulo: "pan"}Quien tenga el puntero toca la misma tarea
public function __construct(...)func NuevaTarea(titulo string) *Tarea (una función normal)Cualquiera del paquete, o de fuera si empieza por mayúscula
$t = $otra; (objeto: misma tarea)t := otra con otra de tipo *TareaLos dos nombres apuntan a la misma tarea
$t1 === $t2 (¿el mismo objeto?)p1 == p2 (¿la misma dirección?)Compara direcciones, no contenidos

¿Por qué? · En PHP no existe

¿Por qué es seguro devolver &t si t es local? En PHP no te lo habrías preguntado

En C, devolver la dirección de una variable local es un desastre: la variable desaparece al salir de la función y te quedas con un papelito que apunta a un solar.

Go lo resuelve solo. Al compilar mira si alguien va a usar esa dirección después de que la función termine (eso se llama escape analysis, «análisis de escape»). Si es así, guarda la variable en una zona de memoria que dura más (el heap), y el recolector de basura la tirará cuando nadie apunte a ella. Tú no tienes que hacer nada: igual que en PHP, donde un objeto vive mientras alguien lo use.

4 · El puntero nil

Un puntero que no apunta a ninguna parte vale nil: es el null de PHP. Es el valor cero de cualquier puntero, así que var t *Tarea empieza siendo nil. Es un papelito en blanco: no lleva dirección.

Si intentas ir a la casa de un papelito en blanco, Go para el programa con un panic (un error que lo detiene todo). Este es el mensaje de verdad al leer t.Titulo con t a nil:

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0xa61d0]

Dereference es «ir a lo apuntado» (el *). Por eso, cuando un puntero puede venir vacío, se comprueba antes:

Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Describir acepta una tarea que puede no existir (nil)
// En PHP: function describir(?Tarea $t): string
func Describir(t *Tarea) string {
    if t == nil {
        return "(ninguna tarea)"
    }
    return t.Titulo
}

func main() {
    var nada *Tarea
    fmt.Println("¿es nil?", nada == nil)
    fmt.Println(Describir(nada))

    pan := &Tarea{Titulo: "Comprar pan"}
    fmt.Println(Describir(pan))
}
SituaciónPHP 8.5Go
Leer un campo de algo vacío$t->titulo con $t = null: Warning y sigue con nullt.Titulo con t == nil: panic, el programa se para
Escribir un campo de algo vacío$t->hecha = true con null: Errorpanic
Leer sin miedo$t?->titulo (nullsafe)if t != nil { … } (no hay ?.)
Decir «puede no haber»?Tarea*Tarea (y nil = no hay)

5 · ¿Cuándo usar puntero?

Al principio da la tentación de ponerle * a todo, «por si acaso», como quien hace clone en PHP por si acaso. No hace falta. Usa puntero cuando se cumpla alguna de estas:

  1. La función tiene que cambiar el valor del que llama: func Completar(t *Tarea). Es el caso principal (en PHP, &$t o un objeto).
  2. El struct es muy grande y se pasa mucho: copiar la dirección es más barato que fotocopiar cien campos. Para una Tarea de cinco campos, la copia es instantánea: no te preocupes.
  3. Tiene que poder no haber valor: un *Tarea puede ser nil; una Tarea siempre existe (en PHP, ?Tarea).

Y estos casos no necesitan puntero:

  • Leer o mostrar: func Describir(t Tarea) string. La fotocopia te protege de cambios sin querer.
  • Slices y maps: ya se comparten (son una llave). Una función que recibe []Tarea puede cambiar ts[i].Hecha sin *. Solo si tiene que cambiar la longitud (con append) devuelve el slice nuevo, como hace append mismo.
  • Números, bool y strings pequeños: si una función calcula algo, mejor que lo devuelva que escribirlo en un puntero.

La pregunta que te vas a hacer

«Vale, pero… ¿no era más fácil el PHP de siempre?»

En una petición web de PHP casi nunca importa: todo vive unos milisegundos y se tira. En Go, tu servidor guarda datos en memoria durante días y los comparte entre muchas peticiones a la vez (módulo 08). Saber exactamente quién puede cambiar qué te evita fallos muy difíciles de encontrar.

Si quieres repasarlo con otras palabras:

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Suma a través de la dirección

El programa debería imprimir Hechas: 3, pero imprime Hechas: 0 porque suma en una copia. Cambia la línea de p para que guarde la dirección de hechas y suma con *p += 3. En PHP sería $ref = &$hechas; $ref += 3;.

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. &t da la dirección y *p va a ella; *Tarea es el tipo «puntero a Tarea» (en PHP, la referencia &$t).
  2. func Completar(t *Tarea) cambia tu tarea y se llama con Completar(&tarea), con el & a la vista (en PHP, function completar(array &$t)).
  3. Con punteros a structs vale el punto: t.Hecha en vez de (*t).Hecha (en PHP, $t->hecha).
  4. &Tarea{...} crea y da la dirección, y devolverla desde una función es seguro (en PHP, new Tarea(...)).
  5. Un puntero vacío es nil y leer a través de él es un panic: comprueba if t == nil (en PHP, ?-> o ?Tarea).
  6. Por valor para leer, por puntero para cambiar; los slices y maps ya se comparten sin *.

Para recordarlo: «DAN»

DDirección
&tarea
AAbre
*p
NNil antes
if p == nil

Con un puntero: pides la Dirección con &, Abres la casa con * (o con el punto en un struct) y, si puede venir vacío, miras si es Nil antes de entrar. Y para elegir: «por valor para leer, por puntero para cambiar».