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 7 de 36 · El array de PHP en Go ✦ WebMCP implementado

Slices a fondo: de array_* al paquete slices

9 min de lectura 4 retos

En PHP tienes más de 70 funciones array_*. En Go tienes un for y el paquete slices, y con eso haces lo mismo. En esta lección traduces tus array_map, array_filter, in_array y usort de siempre, y descubres la trampa más famosa de Go: el append que pisa datos de otra slice.

¿De dónde vienen los nombres?

slices = plural de slice (rebanada)
El paquete con las funciones para trabajar con slices: tu caja de array_*. Llegó a la biblioteca estándar en Go 1.21.
cmp = compare (comparar)
Paquete con cmp.Compare(a, b), que devuelve -1, 0 o 1: el operador nave espacial <=> de PHP.
SortFunc = Sort (ordenar) + Func (función)
Ordena usando una función tuya que compara dos elementos: el usort() de PHP.
Clone = inglés clone (clonar)
Hace una copia independiente de una slice. Lo que en PHP pasa solo al asignar un array.
En 4 ideas
1/4

Go no tiene array_map ni array_filter: se escribe un for que va haciendo append a una slice nueva. Tres líneas que se leen de un vistazo.

1 · Tus funciones array_* en Go

Esta tabla es tu chuleta. A la izquierda lo que escribes en PHP; a la derecha, su versión en Go con una slice t:

PHPGoOjo
count($t)len(t)—
in_array($x, $t, true)slices.Contains(t, x)Compara siempre estricto, como ===
array_search($x, $t)slices.Index(t, x)Devuelve -1 si no está, nunca false
array_map(fn, $t)for + appendLo ves en la siguiente sección
array_filter($t, fn)for + if + appendSin huecos en las posiciones
sort($t)slices.Sort(t)Ordena la misma slice, no devuelve otra
usort($t, fn)slices.SortFunc(t, fn)fn devuelve un int, como con <=>
array_reverse($t)slices.Reverse(t)Le da la vuelta a la misma slice
max($t)slices.Max(t)Hace panic si la slice está vacía
array_merge($a, $b)append(a, b...)Los ... desparraman b, como el ...$b de PHP
array_unique($t)slices.Sort(t) + slices.Compact(t)Compact quita los repetidos que van seguidos
$a === $bslices.Equal(a, b)a == b no compila con slices
$copia = $t;copia := slices.Clone(t)La sección 4 te cuenta por qué
implode(', ', $t)strings.Join(t, ", ")Del paquete strings (lección 4)

2 · array_map y array_filter: un for

En PHP encadenas array_filter y array_map (y en PHP 8.5, con el operador pipe |>). En Go haces lo mismo con un solo for: recorres, decides y vas metiendo en una slice nueva.

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

$tareas = ['comprar pan', 'repasar go', 'llamar al banco', 'regar plantas'];

// Las que empiezan por «r», en mayúsculas
$conR = $tareas
    |> (fn(array $t): array => array_filter($t, fn(string $x): bool => str_starts_with($x, 'r')))
    |> array_values(...)
    |> (fn(array $t): array => array_map(strtoupper(...), $t));

print_r($conR);
Gomain.go
package main

import (
    "fmt"
    "strings"
)

func main() {
    tareas := []string{"comprar pan", "repasar go", "llamar al banco", "regar plantas"}

    // Las que empiezan por «r», en mayúsculas
    var conR []string
    for _, t := range tareas {
        // En PHP: array_filter con str_starts_with()
        if strings.HasPrefix(t, "r") {
            // En PHP: array_map con strtoupper()
            conR = append(conR, strings.ToUpper(t))
        }
    }

    fmt.Println(conR)
}

Fíjate en lo que no hace falta en Go: el array_values(). Como una slice no tiene claves, al filtrar no quedan huecos.

¿Por qué? · En PHP no existe

¿Por qué Go no trae Map ni Filter? En PHP los usas a diario

Cuando se diseñó el paquete slices, el equipo de Go decidió dejarlos fuera a propósito. Las razones:

  • Un for de tres líneas se lee igual de bien y cualquiera de Go lo entiende sin conocer ninguna función.
  • En el for se ve el trabajo: cuántas vueltas da y cuántas slices crea. Una cadena array_filter → array_values → array_map crea tres arrays de paso sin que lo notes.
  • Dentro del for puedes filtrar y transformar a la vez, salir antes con break o devolver un error. Con callbacks eso cuesta más.

Al principio echarás de menos array_map. A la semana escribirás el for sin pensar.

3 · El paquete slices

Para buscar, ordenar y comparar no hace falta escribir el for: el paquete slices lo trae hecho.

Gomain.go
package main

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

func main() {
    tareas := []string{"Repasar Go", "Comprar pan", "Llamar al banco"}

    // En PHP: in_array('Comprar pan', $tareas, true)
    fmt.Println(slices.Contains(tareas, "Comprar pan"))

    // En PHP: array_search(...) devuelve la clave o false
    fmt.Println(slices.Index(tareas, "Llamar al banco"), slices.Index(tareas, "Nadar"))

    // En PHP: sort($tareas); ordena la misma lista
    slices.Sort(tareas)
    fmt.Println(tareas)

    // En PHP: usort($tareas, fn($a, $b) => strlen($a) <=> strlen($b));
    slices.SortFunc(tareas, func(a, b string) int {
        return cmp.Compare(len(a), len(b))
    })
    fmt.Println(tareas)

    // En PHP: max([2, 0, 1])
    prioridades := []int{2, 0, 1}
    fmt.Println(slices.Max(prioridades))
}

La función que le pasas a SortFunc recibe dos tareas a y b y devuelve un número: negativo si a va antes, 0 si da igual y positivo si a va después. Exactamente lo que devuelve <=> en PHP. cmp.Compare te lo calcula.

4 · La trampa: append comparte el array de fondo

Recuerda la mochila de la lección anterior: una slice es una ventana sobre un array escondido (el array de fondo). Cuando troceas con tareas[:2], no copias nada: abres una ventana más pequeña sobre el mismo array. Ahora mira qué pasa al hacer append sobre ese trozo:

Gomain.go
package main

import "fmt"

func main() {
    tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go"}

    // Las 2 primeras son las de hoy...
    hoy := tareas[:2]
    // ...y hoy añado otra
    hoy = append(hoy, "Regar plantas")

    fmt.Println("hoy:   ", hoy)
    // ¡«Repasar Go» ha desaparecido de la lista original!
    fmt.Println("tareas:", tareas)
}

¿Qué ha pasado? hoy tenía len 2, pero su cap era 3: detrás de la ventana todavía quedaba un hueco del array de fondo… ocupado por "Repasar Go". append vio sitio libre y escribió ahí. Las dos slices miran al mismo array, así que tareas también cambia.

Gomain.go
// Una slice por dentro son 3 datos (más o menos así):
//   puntero -> dónde empieza dentro del array de fondo
//   len     -> cuántos elementos ves
//   cap     -> cuántos caben hasta el final del array de fondo
//
// array de fondo: ["Comprar pan", "Llamar al banco", "Repasar Go"]
// tareas        :  [-------------- len 3, cap 3 --------------]
// hoy           :  [------ len 2, cap 3 -------]  <- append escribe en el 3.º

¿Por qué? · En PHP no existe

¿Por qué Go comparte la memoria? En PHP array_slice te da una copia

En PHP, $hoy = array_slice($tareas, 0, 2); crea un array nuevo. Y $copia = $tareas; también se comporta como una copia: PHP solo duplica de verdad cuando uno de los dos cambia (copy-on-write, copiar al escribir). Es seguro, pero cada copia cuesta memoria y tiempo.

Go elige la velocidad: trocear es gratis porque no copia nada, solo crea una ventana nueva de tres datos. Con listas de millones de elementos se nota muchísimo. El precio es que tienes que saber cuándo dos slices comparten array.

Lo traicionero es que no siempre pisa: si el trozo ya estaba lleno (len == cap), append se muda a una mochila nueva y la original queda intacta. Por eso el fallo aparece unas veces sí y otras no.

5 · Copiar de verdad: slices.Clone

Cuando vayas a hacer append sobre un trozo, o vayas a devolverlo y no sabes qué hará otro con él, haz una copia. Es tu $copia = $tareas; de PHP.

Gomain.go
package main

import (
    "fmt"
    "slices"
)

func main() {
    tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go"}

    // Copia independiente de las 2 primeras: su propio array de fondo
    hoy := slices.Clone(tareas[:2])
    hoy = append(hoy, "Regar plantas")

    fmt.Println("hoy:   ", hoy)
    fmt.Println("tareas:", tareas)

    // Otra forma: un tercer número en el trozo limita la capacidad.
    // tareas[:2:2] = desde 0, hasta 2, capacidad hasta 2.
    // Sin hueco libre, append se muda y no pisa nada.
    manana := tareas[:2:2]
    manana = append(manana, "Ir al gimnasio")
    fmt.Println("manana:", manana)
    fmt.Println("tareas:", tareas)
}
Quiero…GoEn PHP
Una copia enteraslices.Clone(t)$copia = $t;
Una copia de un trozoslices.Clone(t[1:3])array_slice($t, 1, 2)
Un trozo que no pise al crecert[:2:2]No hace falta
Copiar sobre una slice que ya tengocopy(destino, origen)Un foreach asignando

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Todas en mayúsculas

Completa EnMayusculas(titulos []string) []string, que devuelve una slice nueva con cada título en mayúsculas. Por ejemplo, ["pan", "leche"] da ["PAN", "LECHE"]. Es el array_map(strtoupper(...), $titulos) de PHP: un for con strings.ToUpper y append.

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. array_map y array_filter son un for con append (y sin array_values(): no hay huecos).
  2. slices.Contains es in_array; slices.Index es array_search, pero con -1 en vez de false.
  3. slices.SortFunc(t, fn) es usort; cmp.Compare(a, b) es tu <=>. Ordena la misma slice.
  4. Un trozo comparte el array de fondo: un append sobre él puede pisar la original. En PHP, array_slice copia.
  5. slices.Clone(t) es tu $copia = $t;: úsalo antes de hacer append sobre algo que no es solo tuyo.

Para recordarlo: «Si no es tuya, clónala»

Un trozo de slice es una ventana, no una fotocopia. Antes de hacer append sobre una slice que te han pasado o que has troceado, piensa: ¿es solo mía? Si no lo es, slices.Clone.