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 21 de 36 · Errores y funciones ✦ WebMCP implementado

Closures: function() use () sin use

8 min de lectura 4 retos

En PHP, una función anónima no ve las variables de fuera hasta que se las pasas con use. En Go las ve solas, y no recibe una copia: comparte la variable de verdad. Aquí aprendes a guardar funciones en variables, a pasarlas como argumento y a fabricarlas.

¿De dónde vienen los nombres?

func = function (función)
La palabra para declarar funciones, con nombre o sin él. En PHP escribes function entera, o fn en las flechas.
closure = to close (cerrar)
Una función que «encierra» las variables que la rodean y se las lleva consigo. PHP usa la misma palabra: su clase se llama Closure.
cmp = compare (comparar)
Paquete con cmp.Compare(a, b), que devuelve -1, 0 o 1: el operador nave espacial <=> de PHP.
En 4 ideas
1/4

En Go las funciones son valores: se guardan en variables, se pasan como argumento y se devuelven, con un tipo como func(Tarea) bool. En PHP es el tipo callable o Closure.

1 · Funciones como valores

En Go una función es un valor más, como un número o un string. Puedes meterla en una variable, pasársela a otra función o devolverla. Es como una receta escrita en una tarjeta: la guardas, se la das a otro, y quien la tenga puede cocinarla cuando quiera.

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

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

$tareas = [
    new Tarea('Comprar pan'),
    new Tarea('Repasar Go', true),
    new Tarea('Llamar al banco'),
];

$esPendiente = fn (Tarea $t): bool => !$t->hecha;

$titulos = array_filter($tareas, $esPendiente)
    |> (fn (array $ts): array => array_map(fn (Tarea $t): string => $t->titulo, $ts))
    |> (fn (array $ts): array => array_map(strtoupper(...), $ts));

echo implode(', ', $titulos) . PHP_EOL;
Gomain.go
package main

import (
    "fmt"
    "strings"
)

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Filtrar recibe una función: es tu array_filter().
func Filtrar(ts []Tarea, f func(Tarea) bool) []Tarea {
    var res []Tarea
    for _, t := range ts {
        if f(t) {
            res = append(res, t)
        }
    }
    return res
}

func main() {
    ts := []Tarea{
        {Titulo: "Comprar pan"},
        {Titulo: "Repasar Go", Hecha: true},
        {Titulo: "Llamar al banco"},
    }

    // En PHP: $esPendiente = fn (Tarea $t): bool => !$t->hecha;
    esPendiente := func(t Tarea) bool {
        return !t.Hecha
    }

    // En PHP: strtoupper(...) (el nombre de la función, sin llamarla)
    mayusculas := strings.ToUpper

    var titulos []string
    for _, t := range Filtrar(ts, esPendiente) {
        titulos = append(titulos, mayusculas(t.Titulo))
    }
    fmt.Println(strings.Join(titulos, ", "))
}
  • func(t Tarea) bool { … } sin nombre es una función anónima: tu function (Tarea $t): bool { … }.
  • func(Tarea) bool es su tipo: recibe una Tarea y devuelve un bool. Mucho más preciso que el callable de PHP, que acepta cualquier cosa que se pueda llamar.
  • strings.ToUpper sin paréntesis es la función en sí, sin llamarla: el strtoupper(...) de PHP 8.1.

2 · Capturar variables sin use

En PHP una función anónima vive en una habitación cerrada: no ve nada de fuera hasta que le pasas las variables por la ventana con use. Y lo que pasa es una fotocopia: si luego cambias la original, la función sigue con la copia vieja.

En Go la función está en la misma habitación: ve las variables de alrededor sin pedirlas, y ve las de verdad, no una copia.

Gomain.go
package main

import "fmt"

func main() {
    prefijo := "[P1]"

    // En PHP: $formatear = function (string $titulo) use ($prefijo) { ... };
    formatear := func(titulo string) string {
        return prefijo + " " + titulo
    }
    fmt.Println(formatear("Comprar pan"))

    prefijo = "[P3]"
    // En PHP, con use ($prefijo), aquí seguiría saliendo [P1]
    fmt.Println(formatear("Comprar pan"))

    hechas := 0
    completar := func() {
        hechas++
    }
    completar()
    completar()
    // En PHP necesitarías use (&$hechas) para que esto diera 2
    fmt.Println("Hechas:", hechas)
}
PHPQué recibe la funciónGo
function () use ($x) { … }Una copia de $x hecha al crearlaNo existe
function () use (&$x) { … }La variable $x de verdadfunc() { … x … } (siempre así)
fn () => $xUna copia automática de $xNo existe

¿Por qué? · En PHP no existe

¿Por qué Go no necesita use? En PHP es obligatorio

En PHP cada función es un mundo aparte: no ve las variables de fuera, ni siquiera las globales sin global. Por eso las anónimas necesitan use, para decir qué dejan entrar. Y como copiar o compartir dan resultados distintos, PHP te obliga a elegir con &.

En Go todos los bloques (if, for, una función anónima) ven las variables de los bloques que los rodean. Una función anónima es un bloque más, así que ve lo mismo que vería un if en ese sitio. Sin lista que mantener y sin olvidarte de un &.

La contrapartida: como la variable es compartida, si la cambias fuera, la función lo nota. Cuando quieras una foto fija, cópiala tú antes: p := prefijo.

3 · Funciones que recuerdan: estado en una closure

Una función puede fabricar otra y devolverla. La de dentro se lleva las variables de la de fuera, y esas variables siguen vivas mientras la función exista. Es una máquina de tickets de la carnicería: cada vez que tiras, sale el siguiente número, y cada máquina lleva su propia cuenta.

Gomain.go
package main

import "fmt"

// NuevoGeneradorID devuelve una función que da 1, 2, 3...
func NuevoGeneradorID() func() int {
    ultimo := 0
    return func() int {
        ultimo++
        return ultimo
    }
}

func main() {
    idTareas := NuevoGeneradorID()
    idEtiquetas := NuevoGeneradorID()

    fmt.Println("Tarea", idTareas())
    fmt.Println("Tarea", idTareas())
    fmt.Println("Etiqueta", idEtiquetas())
    fmt.Println("Tarea", idTareas())
}

En PHP harías esto con una variable static dentro de una función (pero solo tendrías un contador para todo el programa) o con una clase con una propiedad private int $ultimo. En Go, una closure ya es un objeto pequeño con un único método.

4 · Métodos como valores y ordenar con una función

Un método también es un valor. Si escribes t.Resumen sin paréntesis, obtienes una función que ya recuerda a qué tarea pertenece: el $tarea->resumen(...) de PHP. Y muchas funciones de la biblioteca estándar te piden una función, como slices.SortFunc, que es tu usort().

Gomain.go
package main

import (
    "cmp"
    "fmt"
    "slices"
)

type Tarea struct {
    Titulo    string
    Prioridad int
}

func (t Tarea) Resumen() string {
    return fmt.Sprintf("[P%d] %s", t.Prioridad, t.Titulo)
}

func main() {
    ts := []Tarea{
        {Titulo: "Comprar pan", Prioridad: 1},
        {Titulo: "Pagar el alquiler", Prioridad: 3},
        {Titulo: "Repasar Go", Prioridad: 2},
    }

    // En PHP: usort($ts, fn ($a, $b) => $b->prioridad <=> $a->prioridad);
    slices.SortFunc(ts, func(a, b Tarea) int {
        return cmp.Compare(b.Prioridad, a.Prioridad)
    })

    // En PHP: $resumen = $ts[0]->resumen(...);
    resumen := ts[0].Resumen
    fmt.Println("La más urgente:", resumen())

    for _, t := range ts {
        fmt.Println(t.Resumen())
    }
}

Equivalencia POO · PHP → Go

Las closures de PHP tienen que pelearse con $this, static fn y Closure::bind. En Go no hay $this que atar: un método como valor ya lleva su receptor dentro.

PHPGoQué cambia
function () use ($x) { … }func() { … x … }Captura sola y comparte la variable, no la copia
fn (Tarea $t): bool => !$t->hechafunc(t Tarea) bool { return !t.Hecha }No hay forma corta: siempre func, llaves y return
$this dentro de una closuret.Resumen (método como valor)La función ya recuerda a qué tarea pertenece
strtoupper(...) / $tarea->resumen(...)strings.ToUpper / t.ResumenEl nombre sin paréntesis es la función
static fn () => … / Closure::bind()—No hace falta: no hay $this que atar ni desatar
callable / Closurefunc(Tarea) boolEl tipo dice qué recibe y qué devuelve
__invoke()type Filtro func(Tarea) boolUn tipo función con nombre, que además puede tener métodos

La pregunta que te vas a hacer

«Vale, pero… ¿y los middleware de mi framework?»

En Laravel o Slim, un middleware es una clase con un handle($request, $next). En Go es una función que recibe un manejador y devuelve otro, es decir, una closure: la de dentro registra, comprueba la sesión o mide el tiempo, y luego llama al manejador que recibió. Lo usarás en el módulo 07 con net/http.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Tu propio array_filter

Completa Filtrar(ts []Tarea, f func(Tarea) bool) []Tarea para que devuelva solo las tareas para las que f devuelve true, en el mismo orden. Es el array_filter() 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. Las funciones son valores con tipo, como func(Tarea) bool (en PHP, callable o Closure).
  2. Una función anónima ve sola las variables de alrededor (en PHP, use o el fn de PHP 7.4).
  3. Las comparte, no las copia: es siempre el use (&$x) de PHP.
  4. Una función que devuelve otra guarda estado entre llamadas (en PHP, una variable static o una propiedad privada).
  5. strings.ToUpper o t.Resumen sin paréntesis son la función misma (en PHP, strtoupper(...)).

Para recordarlo: «Go no pide use: lo ve todo y lo comparte»

Una closure de Go está en la misma habitación que sus variables: no hay ventana (use) ni fotocopia. Si quieres una foto fija, cópiala tú antes: p := prefijo.