Lección 10 de 36 · Memoria: valores y punteros✦ WebMCP implementado
Valores y copias
9 min de lectura4 retos
Cuando escribes b := a, ¿tienes dos cosas o una sola con dos nombres? En PHP la respuesta depende de si a es un array o un objeto. En Go también depende del tipo, pero las reglas son pocas y se ven en el código. En esta lección aprendes qué se copia, qué se comparte y quién limpia la memoria.
¿De dónde vienen los nombres?
GC = Garbage Collector (recolector de basura)
La parte de Go que libera la memoria que ya nadie usa. PHP también tiene uno (gc_collect_cycles()), aunque casi nunca lo notas.
copy-on-write = copiar al escribir
El truco de PHP: $copia = $lista no copia nada hasta que alguien escribe en una de las dos. Go no lo usa: copia en el momento o comparte, sin trucos ocultos.
En 4 ideas
1/4
En Go asignar o pasar un valor hace una copia: números, strings, arrays ([3]string) y structs. Es lo que hace PHP con un array: $copia = $lista y cada una va por su lado.
Los slices y los maps se comparten: la copia es solo una «llave» al mismo contenido. Es lo que hace PHP con los objetos, que viajan «por handle»: $b = $a y los dos tocan el mismo objeto.
Por eso for _, t := range tareas te da una copia de cada tarea: cambiar t.Hecha no toca la lista. En PHP, foreach ($tareas as $t) funciona con objetos y falla con arrays; en Go se cambia por índice: tareas[i].Hecha = true.
Go tiene recolector de basura como PHP: no haces free(). La diferencia es que PHP tira toda la memoria al acabar cada petición y un programa de Go vive días, así que lo que guardes sin querer se queda.
1 · ¿Fotocopia o llave?
Imagina que tienes tu lista de tareas en una hoja de papel. Un amigo te la pide. Puedes hacer dos cosas:
Darle una fotocopia. Si él tacha una tarea en su hoja, tu hoja sigue igual. Eso es copiar un valor.
Darle una copia de la llave de tu casa, donde está la hoja colgada en la nevera. La llave es nueva, pero la casa es la misma: si él tacha una tarea, tú la ves tachada. Eso es compartir.
Todo lenguaje tiene que decidir qué pasa en b = a: fotocopia o llave. PHP decide así:
Números, strings y arrays: fotocopia. Con un truco: PHP no fotocopia de verdad hasta que alguien escribe en una de las dos (eso se llama copy-on-write, «copiar al escribir»). Por fuera parece una copia; por dentro ahorra trabajo.
Objetos: llave. La variable no guarda el objeto, guarda un handle (un número que dice cuál de los objetos en memoria es el tuyo). $b = $a copia el handle, no el objeto. Para tener dos objetos de verdad hace falta clone.
Go decide por el tipo, y lo sabes mirando la declaración. Lo verás en las dos secciones siguientes.
2 · Lo que se copia: números, strings, arrays y structs
Antes de nada, un adelanto del módulo 04. Un struct es un tipo que agrupa varios campos con nombre, como una clase de PHP que solo tiene propiedades. Este es el nuestro:
Gomain.go
// En PHP: final class Tarea { public string $titulo; public bool $hecha; }typeTareastruct {
TitulostringHechabool
}
Ahora mira qué pasa al asignar. Pulsa Ejecutar:
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
funcmain() {
// Un número: fotocopia
pendientes := 3
otra := pendientes
otra = 10
fmt.Println("pendientes:", pendientes, "otra:", otra)
// Un array de tamaño fijo [3]string: fotocopia entera
hoy := [3]string{"Comprar pan", "Llamar al banco", "Repasar Go"}
manana := hoy
manana[0] = "Comprar fruta"
fmt.Println("hoy:", hoy[0], "| mañana:", manana[0])
// Un struct: fotocopia entera (¡en PHP un objeto NO se copiaría!)
original := Tarea{Titulo: "Comprar pan"}
copia := original
copia.Hecha = true
fmt.Println("original:", original.Hecha, "| copia:", copia.Hecha)
}
Los tres casos se comportan igual: tocar la copia no toca el original. Los strings también se copian, pero hay un detalle: en Go un string no se puede cambiar (es inmutable), así que da igual cuántas variables lo compartan por dentro: nadie puede estropeárselo a otro.
3 · Lo que se comparte: slices y maps
En el módulo 02 viste que un slice es una ventana sobre un array escondido: guarda dónde empieza, cuántos elementos ve (len) y cuánto cabe (cap). Cuando copias un slice copias la ventana, no lo que hay detrás. Es la copia de la llave: dos ventanas, una sola casa.
Con los maps pasa lo mismo: la variable es una llave a una tabla que vive en otra parte.
Gomain.go
package main
import (
"fmt""slices"
)
funcmain() {
// Un slice: se copia la ventana, el contenido se comparte
lista := []string{"Comprar pan", "Llamar al banco"}
alias := lista
alias[0] = "Comprar fruta"
fmt.Println("lista:", lista[0])
// Un map: igual, las dos variables apuntan a la misma tabla
porEtiqueta := map[string]int{"casa": 2}
otro := porEtiqueta
otro["casa"] = 99
fmt.Println("casa:", porEtiqueta["casa"])
// Para una copia de verdad: slices.Clone (y maps.Clone para maps)// En PHP: $copia = $lista; (ya era una copia)
copia := slices.Clone(lista)
copia[0] = "Comprar pan"
fmt.Println("lista:", lista[0], "| copia:", copia[0])
}
Tipo en Go
b := a hace…
Para copiar de verdad
En PHP
int, float64, bool
Fotocopia
Ya lo es
Fotocopia
string
Fotocopia (y nadie puede cambiarlo)
Ya lo es
Fotocopia (copy-on-write)
[3]string (array)
Fotocopia entera
Ya lo es
Fotocopia (copy-on-write)
Tarea (struct)
Fotocopia entera
Ya lo es
Un objeto: llave (handle)
[]string (slice)
Llave: comparte el contenido
slices.Clone(a)
Un array: fotocopia
map[string]int
Llave: comparte la tabla
maps.Clone(a)
Un array: fotocopia
4 · PHP frente a Go: se da la vuelta
Pon las dos reglas una al lado de la otra y verás que se dan la vuelta: lo que PHP copia (el array), Go lo comparte (el slice); y lo que PHP comparte (el objeto), Go lo copia (el struct).
PHP 8.5copias.php
<?phpdeclare(strict_types=1);
finalclass Tarea
{
publicfunction__construct(
public string $titulo,
public bool $hecha = false,
) {}
}
// Un array se copia: cada variable va por su lado$lista = ["Comprar pan", "Llamar al banco"];
$copia = $lista;
$copia[0] = "Comprar fruta";
echo"lista: {$lista[0]}" . PHP_EOL;
// Un objeto se comparte: las dos variables tienen el mismo handle$original = newTarea("Comprar pan");
$otra = $original;
$otra->hecha = true;
echo"original: " . var_export($original->hecha, true) . PHP_EOL;
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
funcmain() {
// Un slice se comparte: las dos variables ven el mismo contenido
lista := []string{"Comprar pan", "Llamar al banco"}
copia := lista
copia[0] = "Comprar fruta"
fmt.Println("lista:", lista[0])
// Un struct se copia: cada variable va por su lado
original := Tarea{Titulo: "Comprar pan"}
otra := original
otra.Hecha = true
fmt.Println("original:", original.Hecha)
}
El PHP imprime lista: Comprar pan y original: true. El Go imprime justo lo contrario: lista: Comprar fruta y original: false.
Equivalencia POO · PHP → Go
En PHP la copia de un objeto se pide con clone. En Go no hace falta: asignar un struct ya es un clone.
PHP
Go
Quién lo ve
$otra = $tarea; (mismo objeto)
otra := &tarea (un puntero, en la lección siguiente)
Los dos nombres tocan la misma tarea
$otra = clone $tarea;
otra := tarea
Cada uno tiene su tarea
__clone() para copiar a fondo
No existe: copias a mano lo de dentro (slices.Clone(t.Etiquetas))
Quien hace la copia decide
readonly para que nadie te la cambie
Pasar por valor: la función recibe su fotocopia
La función no puede tocar tu tarea
¿Por qué? · En PHP no existe
¿Por qué un struct se copia, si en PHP un objeto no? En PHP no existe esta regla
En PHP, cuando pasas un objeto a una función, la función puede cambiártelo sin avisar. Mira function guardar(Tarea $t): ¿te marca la tarea como hecha? No lo sabes hasta leer su código. Por eso PHP acabó añadiendo readonly y la costumbre de hacer clone «por si acaso».
Go elige lo contrario: por defecto, cada uno tiene su fotocopia. Si una función recibe t Tarea, sabes sin mirar dentro que tu tarea no va a cambiar. Si quieres que la cambie, lo dices en la firma con un puntero (*Tarea, en la lección siguiente) y se ve a simple vista.
¿Y por qué entonces los slices se comparten? Porque copiar una lista de un millón de tareas en cada llamada sería lentísimo. PHP lo resuelve con un truco escondido (copy-on-write, un contador por dentro). Go lo resuelve a la vista: lo que se copia es la ventana, que son tres números, y eso es instantáneo.
5 · Al pasar a una función y en el range
Pasar algo a una función es lo mismo que asignarlo: la función recibe una fotocopia del struct. Y en un for … range pasa igual: la variable del bucle es una fotocopia de cada elemento, no el elemento.
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
// Recibe una fotocopia: lo que cambie aquí se pierde al salirfuncCompletar(t Tarea) {
t.Hecha = true
}
funcmain() {
tareas := []Tarea{{Titulo: "Comprar pan"}, {Titulo: "Repasar Go"}}
Completar(tareas[0])
fmt.Println("tras Completar:", tareas[0].Hecha)
// En PHP con objetos: foreach ($tareas as $t) { $t->hecha = true; }// Aquí t es una fotocopia de cada tarea: la lista no cambiafor _, t := range tareas {
t.Hecha = true
}
fmt.Println("tras range con t:", tareas[0].Hecha, tareas[1].Hecha)
// Bien: se escribe en la lista por su índicefor i := range tareas {
tareas[i].Hecha = true
}
fmt.Println("tras range con i:", tareas[0].Hecha, tareas[1].Hecha)
}
Las dos primeras líneas imprimen false: ni la función ni el primer bucle han tocado la lista. Solo el bucle por índice escribe en la tarea de verdad.
6 · El recolector de basura
Cada fotocopia ocupa memoria. ¿Quién la tira cuando ya no se usa? En Go, igual que en PHP, nadie tiene que hacerlo a mano: no hay free() como en C. Un ayudante, el recolector de basura (garbage collector, GC), pasa de vez en cuando, mira qué datos ya no puede alcanzar ninguna variable y los libera.
Es como el camión de la basura: tú no llevas las bolsas al vertedero, solo dejas de usarlas. Eso sí, si guardas algo en una caja que no vacías nunca, el camión no se lo lleva.
Qué
PHP
Go
Cómo sabe qué tirar
Cuenta cuántas variables usan cada dato (refcount) y libera al llegar a 0
Recorre lo que sigue al alcance de tus variables y libera el resto
Cuándo
En el momento, y al final de cada petición se tira todo
Mientras el programa sigue funcionando, sin pararlo casi nada
Ciclos (A apunta a B y B a A)
Hace falta un recolector extra (gc_collect_cycles())
Sin problema: no cuenta referencias
La pregunta que te vas a hacer
«Vale, pero… ¿y si mi servidor de Go se queda sin memoria?»
En PHP casi nunca te preocupa: cada petición empieza con la memoria limpia y, al terminar, php-fpm lo tira todo. Si un script se pasa, choca con memory_limit y se acaba ahí.
En Go tu servidor es un solo programa que vive días. Si en cada petición guardas algo en un map global (una caché, un log en memoria) y nunca lo borras, el recolector no puede tirarlo porque sigue al alcance. La memoria sube poco a poco: eso es una fuga de memoria. Para encontrarla, Go trae un medidor de serie:
El programa debería imprimir que la tarea original sigue pendiente y que su copia está hecha: original: false y copia: true, en dos líneas. Ahora imprime true en las dos, porque marca la original antes de copiarla. Haz la copia primero y marca solo la copia. En PHP sería $copia = clone $original;.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Asignar un struct ya hace la fotocopia. Copia primero y luego cambia copia.Hecha, no original.Hecha.
Reto 2 de 4 · ✓ Resuelto
Completada, sin tocar la original
Completa Completada(t Tarea) Tarea: devuelve una copia de la tarea con Hecha a true, sin cambiar la que te pasan. Por ejemplo, Completada(Tarea{Titulo: "Pan"}) devuelve Tarea{Titulo: "Pan", Hecha: true}. Es el método with…() de una clase readonly de PHP: return clone($this, ['hecha' => true]);.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.t ya es una fotocopia: puedes cambiar t.Hecha sin miedo y devolverla. No hace falta crear otra variable.
Reto 3 de 4 · ✓ Resuelto
Copia de seguridad de la lista
Completa CopiaDeSeguridad(titulos []string) []string: devuelve una lista con los mismos títulos pero independiente, de modo que cambiar la copia no cambie la original. Por ejemplo, CopiaDeSeguridad([]string{"Pan", "Leche"}) devuelve []string{"Pan", "Leche"}. En PHP bastaba con return $titulos;, porque el array ya se copiaba; en Go eso devuelve otra llave a la misma lista.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Devolver titulos es dar otra llave a la misma casa. El paquete slices tiene una función que hace la fotocopia de los elementos: slices.Clone. Acuérdate de importarlo.
Reto 4 de 4 · ✓ Resuelto
Marca todas como hechas
Completa MarcarTodas(tareas []Tarea): pone Hecha = true en todas las tareas de la lista que recibe, sin devolver nada. Como el slice se comparte, el cambio se verá fuera. Ahora mismo el bucle cambia una fotocopia y no hace nada. En PHP, con arrays, es el foreach ($tareas as &$t) { $t['hecha'] = true; }.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.t es una fotocopia de cada tarea. Recorre los índices con for i := range tareas y escribe en tareas[i].Hecha.
Resumen
Lo que te llevas de esta lección
Números, strings, arrays y structs se copian al asignar y al pasar a una función (en PHP, como un array).
Slices y maps se comparten: se copia la ventana o la llave, no el contenido (en PHP, como un objeto por handle).
La copia de verdad de un slice es slices.Clone(lista), y de un map maps.Clone(m) (en PHP bastaba con $copia = $lista).
Un struct asignado ya es un clone: copia := tarea (en PHP, $copia = clone $tarea).
En for _, t := range tareas, t es una fotocopia: cambia con tareas[i].Hecha = true (en PHP, foreach ($tareas as &$t) con arrays).
El recolector libera lo que ya no se alcanza, pero un servidor de Go no se reinicia en cada petición como php-fpm.
Para recordarlo: «Struct y array, fotocopia; slice y map, llave»
Si el tipo es un número, un string, un array [N]T o un struct, cada variable tiene su fotocopia. Si es un slice o un map, todas tienen una llave a la misma casa. Justo al revés que en PHP, donde el array es la fotocopia y el objeto es la llave.