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

Valores y copias

9 min de lectura 4 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.

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:

  1. Darle una fotocopia. Si él tacha una tarea en su hoja, tu hoja sigue igual. Eso es copiar un valor.
  2. 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; }
type Tarea struct {
    Titulo string
    Hecha  bool
}

Ahora mira qué pasa al asignar. Pulsa Ejecutar:

Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

func main() {
    // 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"
)

func main() {
    // 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 Gob := a hace…Para copiar de verdadEn PHP
int, float64, boolFotocopiaYa lo esFotocopia
stringFotocopia (y nadie puede cambiarlo)Ya lo esFotocopia (copy-on-write)
[3]string (array)Fotocopia enteraYa lo esFotocopia (copy-on-write)
Tarea (struct)Fotocopia enteraYa lo esUn objeto: llave (handle)
[]string (slice)Llave: comparte el contenidoslices.Clone(a)Un array: fotocopia
map[string]intLlave: comparte la tablamaps.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
<?php
declare(strict_types=1);

final class Tarea
{
    public function __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 = new Tarea("Comprar pan");
$otra = $original;
$otra->hecha = true;
echo "original: " . var_export($original->hecha, true) . PHP_EOL;
Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

func main() {
    // 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.

PHPGoQuié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 := tareaCada uno tiene su tarea
__clone() para copiar a fondoNo existe: copias a mano lo de dentro (slices.Clone(t.Etiquetas))Quien hace la copia decide
readonly para que nadie te la cambiePasar por valor: la función recibe su fotocopiaLa 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"

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Recibe una fotocopia: lo que cambie aquí se pierde al salir
func Completar(t Tarea) {
    t.Hecha = true
}

func main() {
    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 cambia
    for _, 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 índice
    for 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éPHPGo
Cómo sabe qué tirarCuenta cuántas variables usan cada dato (refcount) y libera al llegar a 0Recorre lo que sigue al alcance de tus variables y libera el resto
CuándoEn el momento, y al final de cada petición se tira todoMientras 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:

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Fotocopia de una tarea

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

Resumen

Lo que te llevas de esta lección

  1. Números, strings, arrays y structs se copian al asignar y al pasar a una función (en PHP, como un array).
  2. Slices y maps se comparten: se copia la ventana o la llave, no el contenido (en PHP, como un objeto por handle).
  3. La copia de verdad de un slice es slices.Clone(lista), y de un map maps.Clone(m) (en PHP bastaba con $copia = $lista).
  4. Un struct asignado ya es un clone: copia := tarea (en PHP, $copia = clone $tarea).
  5. En for _, t := range tareas, t es una fotocopia: cambia con tareas[i].Hecha = true (en PHP, foreach ($tareas as &$t) con arrays).
  6. 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.