Lección 6 de 36 · El array de PHP en Go✦ WebMCP implementado
De array a slice: arrays y slices
8 min de lectura3 retos
En PHP, el array lo hace todo: es lista, diccionario, pila y cola a la vez. Go lo reparte en piezas más pequeñas y cada una hace una sola cosa. En esta lección ves la primera: la lista, que en Go se escribe con arrays y, sobre todo, con slices.
¿De dónde vienen los nombres?
slice = inglés slice (rebanada, porción)
Una rebanada de una lista más grande: una ventana sobre unos cuantos elementos seguidos. Es lo que usarás siempre en lugar del array de lista de PHP.
len = length (longitud)
Cuántos elementos hay: el count() de PHP.
cap = capacity (capacidad)
Cuántos elementos caben antes de que Go tenga que buscar un sitio más grande. PHP no te lo enseña nunca.
append = inglés append (añadir al final)
Añade al final y te devuelve la slice nueva: tu $tareas[] = "…"; o array_push().
make = inglés make (fabricar)
Fabrica una slice (o un map) con el tamaño que le pidas. En PHP lo más parecido es array_fill().
En 4 ideas
1/4
El array de PHP es lista y diccionario a la vez. Go lo reparte: slices para listas, maps para claves y valor (lección 3) y strings para el texto (lección 4).
Un array de Go, como [7]int, tiene un tamaño fijo que forma parte de su tipo y no puede crecer. Se usa poco: es más parecido a un SplFixedArray de PHP que a un array.
Una slice, como []string, es la lista que crece: tareas = append(tareas, "Repasar Go") es tu $tareas[] = "Repasar Go"; y len(tareas) es tu count($tareas).
tareas[1:3] saca un trozo, como array_slice($tareas, 1, 2), pero sin copiar: es una ventana sobre la misma lista. Y leer fuera de la lista no da un aviso y null: para el programa.
1 · Un array para todo (en PHP)
Piensa en el array de PHP como una navaja suiza: lleva cuchillo, tijeras, sacacorchos y destornillador. Sirve para todo, pero ninguna herramienta es la mejor en lo suyo. Go te da una caja de herramientas: cada pieza hace una sola cosa y la hace bien.
Lo que haces en PHP
Ejemplo PHP
En Go
Una lista ordenada
['pan', 'leche']
Slice: []string{"pan", "leche"}
Una lista de tamaño fijo
new SplFixedArray(7)
Array: [7]int
Claves con su valor
['pan' => 2]
Map: map[string]int{"pan": 2} (lección 3)
Un texto letra a letra
mb_str_split($titulo)
[]rune(titulo) (lección 4)
Un objeto sin clase
['id' => 1, 'titulo' => 'pan']
Un struct (módulo 04)
Además, en Go todos los elementos de una lista son del mismo tipo. Una []string solo guarda strings. Si intentas meter un número, no compila.
package main
import"fmt"funcmain() {
// []string: una slice de strings. Solo strings.
tareas := []string{"Comprar pan", "Llamar al banco"}
// En PHP: $tareas[] = 'Repasar Go';
tareas = append(tareas, "Repasar Go")
// En PHP: echo count($tareas);
fmt.Println(len(tareas))
for i, titulo := range tareas {
fmt.Printf("%d: %s\n", i, titulo)
}
// tareas = append(tareas, 42) no compilaría:// cannot use 42 (untyped int constant) as string value in argument to append
}
¿Por qué? · En PHP no existe
¿Por qué tantas piezas? En PHP con un array basta
Porque el array todoterreno de PHP esconde sorpresas. Mira esta: tienes una lista y le quitas las tareas hechas con array_filter().
array_filter(['pan', 'hecha', 'leche'], …) te deja las claves 0 y 2: un hueco en medio.
Si ahora haces json_encode(), ya no sale una lista ["pan","leche"] sino un objeto {"0":"pan","2":"leche"}. Tu frontend se rompe.
Por eso en PHP acabas escribiendo array_values() por todas partes, por si acaso.
En Go una slice no tiene claves: tiene posiciones del 0 al len-1, siempre seguidas. No puede tener huecos ni volverse un diccionario sin querer. Y como cada pieza tiene su tipo, el compilador sabe qué hay dentro y te avisa si te equivocas.
2 · Arrays: tamaño fijo
Un array de Go es como una huevera: tiene 6 huecos o 12, y no puedes añadir un séptimo huevo a la de 6. El tamaño se escribe entre corchetes, antes del tipo: [7]int es «7 enteros».
Gomain.go
package main
import"fmt"funcmain() {
// Tareas pendientes por día de la semana: siempre 7 días.// Nace con su valor cero: siete 0.var semana [7]int
semana[0] = 3
semana[4] = 5
fmt.Println(semana)
fmt.Println("Días:", len(semana))
// También con valores; [...] le pide a Go que los cuente.
prioridades := [...]string{"Baja", "Media", "Alta"}
fmt.Println(prioridades[2], len(prioridades))
}
Tres cosas que no pasan en PHP:
El array nace lleno con el valor cero de su tipo: siete 0, o tres "". No existe la posición «sin definir».
El tamaño es parte del tipo: [3]string y [4]string son tipos distintos. No puedes asignar uno al otro.
Si te sales con un número fijo, ni compila: semana[7] = 3 da invalid argument: index 7 out of bounds [0:7].
3 · Slices: la lista que crece
Una slice se escribe igual que un array pero sin número: []string. Es tu lista de PHP de siempre: empieza con lo que quieras y crece con append.
Gomain.go
package main
import"fmt"funcmain() {
// Una slice vacía: todavía no hay tareas.var tareas []string
fmt.Println(len(tareas), tareas)
// En PHP: $tareas[] = 'Comprar pan';
tareas = append(tareas, "Comprar pan")
// append admite varios elementos de golpe, como array_push()
tareas = append(tareas, "Llamar al banco", "Repasar Go")
// En PHP: foreach ($tareas as $i => $titulo)for i, titulo := range tareas {
fmt.Println(i+1, titulo)
}
// Leer y cambiar por posición, como en PHP
tareas[0] = "Comprar pan integral"
fmt.Println(tareas[0], "| total:", len(tareas))
}
Fíjate en tareas = append(tareas, …). En PHP, $tareas[] = … cambia la lista directamente. En Go, appendte devuelve la lista nueva y tú la guardas. Si se te olvida guardarla, el compilador te para: append(tareas, "Repasar Go") (value of type []string) is not used.
La pregunta que te vas a hacer
«Vale, pero… ¿y mi $_POST['etiquetas'][]?»
En PHP, un formulario con varios <input name="etiquetas[]"> te llega como un array en $_POST['etiquetas']. En Go, los datos de un formulario son un url.Values, que por dentro es un map de strings a slices de strings: r.Form["etiquetas"] ya es una []string con todos los valores, sin corchetes en el nombre.
Para sacar un trozo de una slice escribes tareas[desde:hasta]. Coge desde la posición desdehasta antes dehasta: como contar los peldaños de una escalera sin pisar el último.
Gomain.go
package main
import"fmt"funcmain() {
tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go", "Sacar la basura"}
// En PHP: array_slice($tareas, 1, 2)
fmt.Println(tareas[1:3])
// En PHP: array_slice($tareas, 0, 2)
fmt.Println(tareas[:2])
// En PHP: array_slice($tareas, 2)
fmt.Println(tareas[2:])
// La última, en PHP: $tareas[count($tareas) - 1] o end($tareas)
fmt.Println(tareas[len(tareas)-1])
}
Go
Qué coge
En PHP
t[1:3]
Posiciones 1 y 2
array_slice($t, 1, 2)
t[:2]
Las 2 primeras
array_slice($t, 0, 2)
t[2:]
De la 2 al final
array_slice($t, 2)
t[:]
Todas
$t
t[len(t)-1]
La última
end($t)
¿Por qué? · En PHP no existe
¿Por qué el programa se para si me salgo de la lista? En PHP solo es un aviso
En PHP, $tareas[5] en una lista de 3 te da un Warning: Undefined array key 5 y sigue con null. Ese null viaja por tu código y acaba como un hueco vacío en la pantalla o en la base de datos, lejos de donde nació el fallo.
Go prefiere pararse en la línea exacta del error, con un mensaje claro (eso se llama panic, pánico):
panic: runtime error: index out of range [5] with length 3
Así el fallo no se esconde. Si la posición puede no existir, compruébalo antes con if i < len(tareas).
5 · make, len y cap
Una slice es una ventana sobre un array escondido por debajo (el array de fondo). Piensa en una mochila: len es cuántas cosas llevas dentro y cap es cuántas caben. Cuando se llena, Go compra una mochila más grande, pasa todo y tira la vieja.
Gomain.go
package main
import"fmt"funcmain() {
var tareas []stringfor i := range5 {
tareas = append(tareas, fmt.Sprintf("Tarea %d", i+1))
fmt.Printf("len=%d cap=%d\n", len(tareas), cap(tareas))
}
// Si ya sabes cuántas van a ser, pide la mochila buena desde el principio:// longitud 0, capacidad 100.
pendientes := make([]string, 0, 100)
fmt.Println(len(pendientes), cap(pendientes))
// make con longitud 3: tres "" ya puestos.// En PHP: array_fill(0, 3, '')
huecos := make([]string, 3)
fmt.Printf("%q\n", huecos)
}
La capacidad va dando saltos (2, 4, 8…) porque Go reserva de más cada vez que se llena, para no mudarse en cada append. No tienes que gestionarlo tú: solo saber que existe.
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
Una tarea más
Añade Sacar la basura al final de la lista con append y haz que el programa imprima 4 [Comprar pan Llamar al banco Repasar Go Sacar la basura]. Es tu $tareas[] = 'Sacar la basura'; de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.append no cambia la slice: te devuelve una nueva. Escribe tareas = append(tareas, "Sacar la basura").
Reto 2 de 3 · ✓ Resuelto
Tareas de la semana
Completa TotalSemana(semana [7]int) int, que recibe cuántas tareas hay cada día de la semana y devuelve la suma. Por ejemplo, [7]int{3, 0, 2, 0, 5, 0, 1} da 11. Es el array_sum() de PHP, con un for … range.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.range 6 solo da 6 vueltas (del 0 al 5) y se deja el domingo. Recorre el array entero con for _, tareas := range semana.
Reto 3 de 3 · ✓ Resuelto
Las primeras de la lista
Completa Primeras(tareas []string, n int) []string, que devuelve las n primeras tareas. Si n es mayor que la lista, devuelve la lista entera (sin pánico). Por ejemplo, Primeras([]string{"a", "b", "c"}, 2) da [a b]. Es el array_slice($tareas, 0, $n) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Trocea con tareas[:n]. Pero antes comprueba si n > len(tareas): salirte de la capacidad provoca un panic, no un aviso como en PHP.
Resumen
Lo que te llevas de esta lección
El array de PHP se reparte en Go: slices para listas, maps para claves y strings para texto.
[7]int es un array de tamaño fijo (en PHP, SplFixedArray); []string es una slice que crece (en PHP, tu array de lista).
tareas = append(tareas, x) es $tareas[] = x; no olvides guardar lo que devuelve.
len(t) es count($t) y t[1:3] es array_slice($t, 1, 2), pero sin copiar.
Salirte de la lista para el programa (panic) en vez de darte un aviso y un null.
Para recordarlo: «Sin número, crece»
[7]Con número [7]int (array fijo)
[ ]Sin número []string (slice que crece)
Si entre los corchetes hay un número, es una huevera de tamaño fijo (array). Si no hay número, es una mochila que crece con append (slice). Y para trocear: «desde entra, hasta no» (t[desde:hasta]).