Lección 11 de 36 · Memoria: valores y punteros✦ WebMCP implementado
Punteros: lo que hacía & en PHP
9 min de lectura4 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.
*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.
Una función que recibe *Tarea puede cambiar la tarea del que la llama; una que recibe Tarea trabaja con una fotocopia. En PHP es la diferencia entre function completar(array &$t) y function completar(array $t).
Se crea un struct y su puntero de una vez con &Tarea{Titulo: "pan"} (o new(Tarea) vacío), y devolver la dirección de una variable local es seguro. Es tu new Tarea("pan") de PHP.
Un puntero sin dirección vale nil, y leer a través de él para el programa (panic). En PHP, leer una propiedad de null solo da un Warning; por eso en Go se comprueba if p == nil antes.
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"funcmain() {
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
<?phpdeclare(strict_types=1);
// El & de la firma hace que $tarea sea TU array, no una copiafunctioncompletar(array &$tarea): void
{
$tarea["hecha"] = true;
}
$tarea = ["titulo" => "Comprar pan", "hecha" => false];
// Al llamar no se ve el &: hay que mirar la firmacompletar($tarea);
echo"hecha: " . var_export($tarea["hecha"], true) . PHP_EOL;
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
// *Tarea: recibe la dirección de una tarea, no una fotocopiafuncCompletar(t *Tarea) {
// Es lo mismo que (*t).Hecha = true: Go pone el * por ti
t.Hecha = true
}
funcmain() {
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"typeTareastruct {
TitulostringHechabool
}
// NuevaTarea crea una tarea y devuelve su dirección// En PHP: return new Tarea($titulo);funcNuevaTarea(titulo string) *Tarea {
t := Tarea{Titulo: titulo}
// Devolver la dirección de una variable local es seguro en Goreturn &t
}
funcmain() {
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).
Cualquiera del paquete, o de fuera si empieza por mayúscula
$t = $otra; (objeto: misma tarea)
t := otra con otra de tipo *Tarea
Los 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:
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"typeTareastruct {
TitulostringHechabool
}
// Describir acepta una tarea que puede no existir (nil)// En PHP: function describir(?Tarea $t): stringfuncDescribir(t *Tarea) string {
if t == nil {
return"(ninguna tarea)"
}
return t.Titulo
}
funcmain() {
var nada *Tarea
fmt.Println("¿es nil?", nada == nil)
fmt.Println(Describir(nada))
pan := &Tarea{Titulo: "Comprar pan"}
fmt.Println(Describir(pan))
}
Situación
PHP 8.5
Go
Leer un campo de algo vacío
$t->titulo con $t = null: Warning y sigue con null
t.Titulo con t == nil: panic, el programa se para
Escribir un campo de algo vacío
$t->hecha = true con null: Error
panic
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:
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).
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.
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.
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
Pista.p := &hechas guarda la dirección. Luego, para sumar en esa casa y no en el papelito, escribe *p += 3.
Reto 2 de 4 · ✓ Resuelto
Completar de verdad
Completa Completar(t *Tarea) para que ponga Hecha = true en la tarea del que llama. Ahora mismo hace una fotocopia con *t y cambia la fotocopia. Se usa así: Completar(&tarea). En PHP es function completar(Tarea $t): void { $t->hecha = true; }.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.copia := *t es una fotocopia de lo que hay en la dirección. Escribe directamente a través del puntero: t.Hecha = true.
Reto 3 de 4 · ✓ Resuelto
Fábrica de tareas
Completa NuevaTarea(titulo string) *Tarea: crea una tarea pendiente con ese título y devuelve su dirección. Cada llamada debe dar una tarea distinta. Por ejemplo, NuevaTarea("Comprar pan").Titulo vale "Comprar pan". Es tu new Tarea($titulo) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.new(Tarea) crea una tarea vacía. Usa el literal con el campo relleno y pide su dirección: &Tarea{Titulo: titulo}.
Reto 4 de 4 · ✓ Resuelto
Busca y devuelve la de verdad
Completa Buscar(tareas []Tarea, titulo string) *Tarea: devuelve la dirección de la tarea dentro de la lista con ese título, o nil si no está. Así quien la reciba puede marcarla: Buscar(ts, "Pan").Hecha = true debe cambiar la lista. Ahora mismo devuelve la dirección de la fotocopia del range. En PHP sería un foreach que devuelve el objeto encontrado o null (con firma ?Tarea).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.&t es la dirección de la fotocopia del bucle, no de la tarea de la lista. Recorre por índice y devuelve &tareas[i].
Resumen
Lo que te llevas de esta lección
&t da la dirección y *p va a ella; *Tarea es el tipo «puntero a Tarea» (en PHP, la referencia &$t).
func Completar(t *Tarea) cambia tu tarea y se llama con Completar(&tarea), con el & a la vista (en PHP, function completar(array &$t)).
Con punteros a structs vale el punto: t.Hecha en vez de (*t).Hecha (en PHP, $t->hecha).
&Tarea{...} crea y da la dirección, y devolverla desde una función es seguro (en PHP, new Tarea(...)).
Un puntero vacío es nil y leer a través de él es un panic: comprueba if t == nil (en PHP, ?-> o ?Tarea).
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».