Lección 7 de 36 · El array de PHP en Go✦ WebMCP implementado
Slices a fondo: de array_* al paquete slices
9 min de lectura4 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.
El paquete slices trae el resto: slices.Contains es in_array, slices.Index es array_search, slices.Sort es sort y slices.SortFunc es usort con cmp.Compare como tu <=>.
Un trozo de slice comparte la memoria con la original. Un append sobre el trozo puede pisar datos de la otra. En PHP, asignar un array siempre te da una copia.
Para tener una copia de verdad usa slices.Clone(t), el equivalente de $copia = $tareas; en PHP.
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:
PHP
Go
Ojo
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 + append
Lo ves en la siguiente sección
array_filter($t, fn)
for + if + append
Sin 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 === $b
slices.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
<?phpdeclare(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"
)
funcmain() {
tareas := []string{"comprar pan", "repasar go", "llamar al banco", "regar plantas"}
// Las que empiezan por «r», en mayúsculasvar conR []stringfor _, 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 forse 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"
)
funcmain() {
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"funcmain() {
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"
)
funcmain() {
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…
Go
En PHP
Una copia entera
slices.Clone(t)
$copia = $t;
Una copia de un trozo
slices.Clone(t[1:3])
array_slice($t, 1, 2)
Un trozo que no pise al crecer
t[:2:2]
No hace falta
Copiar sobre una slice que ya tengo
copy(destino, origen)
Un foreach asignando
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
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
Pista. El for ya está. Solo falta transformar cada t antes de añadirlo: strings.ToUpper(t).
Reto 2 de 4 · ✓ Resuelto
Filtra por prefijo
Completa ConPrefijo(titulos []string, prefijo string) []string, que devuelve solo los títulos que empiezan por prefijo, en el mismo orden. Por ejemplo, con ["Comprar pan", "Repasar Go", "Comprar leche"] y "Comprar" da ["Comprar pan", "Comprar leche"]. Es el array_filter() con str_starts_with() de PHP; en Go, strings.HasPrefix.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Dos fallos: strings.Contains busca en cualquier sitio (usa strings.HasPrefix) y la función devuelve la lista de entrada en vez de resultado.
Reto 3 de 4 · ✓ Resuelto
Ordena sin tocar la original
Completa PorLongitud(titulos []string) []string, que devuelve los títulos ordenados de más corto a más largo (y, si miden lo mismo, por orden alfabético) sin cambiar la slice que recibe. Por ejemplo, ["Repasar Go", "Pan", "Gym"] da ["Gym", "Pan", "Repasar Go"]. Es el usort() de PHP con <=>, pero sobre una copia: slices.Clone + slices.SortFunc + cmp.Compare.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Primero copia := slices.Clone(titulos). Luego slices.SortFunc(copia, func(a, b string) int { … }): si las longitudes son distintas, compara len(a) con len(b); si no, compara a con b. Recuerda importar cmp.
Reto 4 de 4 · ✓ Resuelto
Las de hoy, sin pisar
Hoy(tareas []string, n int, extra string) []string devuelve las n primeras tareas más una tarea extra al final. El código de partida parece funcionar, pero pisa la tarea n de la lista original. Arréglalo para que la original no cambie. Por ejemplo, con ["a", "b", "c"], 2 y "x" devuelve ["a", "b", "x"] y la original sigue siendo ["a", "b", "c"]. En PHP, [...array_slice($tareas, 0, $n), $extra] nunca toca $tareas.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.tareas[:n] tiene hueco detrás (su cap es mayor que n) y append escribe en él. Haz antes una copia con slices.Clone(tareas[:n]), o limita la capacidad con tareas[:n:n].
Resumen
Lo que te llevas de esta lección
array_map y array_filter son un for con append (y sin array_values(): no hay huecos).
slices.Contains es in_array; slices.Index es array_search, pero con -1 en vez de false.
slices.SortFunc(t, fn) es usort; cmp.Compare(a, b) es tu <=>. Ordena la misma slice.
Un trozo comparte el array de fondo: un append sobre él puede pisar la original. En PHP, array_slice copia.
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.