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

De array a slice: arrays y slices

8 min de lectura 3 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).

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 PHPEjemplo PHPEn Go
Una lista ordenada['pan', 'leche']Slice: []string{"pan", "leche"}
Una lista de tamaño fijonew SplFixedArray(7)Array: [7]int
Claves con su valor['pan' => 2]Map: map[string]int{"pan": 2} (lección 3)
Un texto letra a letramb_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.

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

$tareas = ['Comprar pan', 'Llamar al banco'];
$tareas[] = 'Repasar Go';

echo count($tareas) . PHP_EOL;
foreach ($tareas as $i => $titulo) {
    echo "{$i}: {$titulo}" . PHP_EOL;
}

// Nadie te impide mezclar tipos:
$tareas[] = 42;
Gomain.go
package main

import "fmt"

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

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

  1. El array nace lleno con el valor cero de su tipo: siete 0, o tres "". No existe la posición «sin definir».
  2. El tamaño es parte del tipo: [3]string y [4]string son tipos distintos. No puedes asignar uno al otro.
  3. 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"

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

4 · Trocear: tareas[desde:hasta]

Para sacar un trozo de una slice escribes tareas[desde:hasta]. Coge desde la posición desde hasta antes de hasta: como contar los peldaños de una escalera sin pisar el último.

Gomain.go
package main

import "fmt"

func main() {
    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])
}
GoQué cogeEn PHP
t[1:3]Posiciones 1 y 2array_slice($t, 1, 2)
t[:2]Las 2 primerasarray_slice($t, 0, 2)
t[2:]De la 2 al finalarray_slice($t, 2)
t[:]Todas$t
t[len(t)-1]La últimaend($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"

func main() {
    var tareas []string
    for i := range 5 {
        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

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

Resumen

Lo que te llevas de esta lección

  1. El array de PHP se reparte en Go: slices para listas, maps para claves y strings para texto.
  2. [7]int es un array de tamaño fijo (en PHP, SplFixedArray); []string es una slice que crece (en PHP, tu array de lista).
  3. tareas = append(tareas, x) es $tareas[] = x; no olvides guardar lo que devuelve.
  4. len(t) es count($t) y t[1:3] es array_slice($t, 1, 2), pero sin copiar.
  5. 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]).