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

Maps: el array asociativo (sin orden)

9 min de lectura 4 retos

La otra mitad del array de PHP es el array asociativo: ['Comprar pan' => 2]. En Go se llama map. Funciona casi igual, con tres diferencias que te van a sorprender: todas las claves y valores son del mismo tipo, una clave que no está no da error y, sobre todo, no tiene orden.

¿De dónde vienen los nombres?

map = inglés map (mapa; en matemáticas, una correspondencia)
Una tabla que a cada clave le hace corresponder un valor: tu array asociativo de PHP.
comma ok = inglés coma ok: el nombre del truco v, ok := m[k]
Así lo llama la documentación oficial (Effective Go): después de la coma llega un ok que dice si la clave estaba. Tu array_key_exists().
delete = inglés delete (borrar)
Quita una clave del map: el unset($m['clave']) de PHP.
maps.Keys = keys (claves)
Las claves de un map, una a una: el array_keys() de PHP.
En 4 ideas
1/4

map[string]int es un array asociativo con las claves de un tipo y los valores de otro. m["pan"] = 2 es $m['pan'] = 2; y len(m) es count($m).

1 · Crear y usar un map

Un map es como la agenda de contactos del móvil: buscas por el nombre (la clave) y te da el teléfono (el valor). No puede haber dos contactos con el mismo nombre. El tipo se escribe map[TipoClave]TipoValor: map[string]int es «de string a int».

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

// Título de la tarea => prioridad (0 baja, 1 media, 2 alta)
$prioridades = ['Comprar pan' => 2, 'Repasar Go' => 1];
$prioridades['Regar plantas'] = 0;

echo $prioridades['Repasar Go'] . PHP_EOL;
echo count($prioridades) . PHP_EOL;

unset($prioridades['Comprar pan']);

foreach ($prioridades as $titulo => $prioridad) {
    echo "{$titulo}: {$prioridad}" . PHP_EOL;
}
Gomain.go
package main

import "fmt"

func main() {
    // Título de la tarea -> prioridad (0 baja, 1 media, 2 alta)
    prioridades := map[string]int{"Comprar pan": 2, "Repasar Go": 1}
    prioridades["Regar plantas"] = 0

    fmt.Println(prioridades["Repasar Go"])
    // En PHP: count($prioridades)
    fmt.Println(len(prioridades))

    // En PHP: unset($prioridades['Comprar pan']);
    delete(prioridades, "Comprar pan")

    // En PHP: foreach ($prioridades as $titulo => $prioridad)
    for titulo, prioridad := range prioridades {
        fmt.Printf("%s: %d\n", titulo, prioridad)
    }
}

Para crear un map vacío tienes dos formas, las dos valen: m := map[string]int{} o m := make(map[string]int).

2 · Claves que no están: comma ok

En PHP, leer $prioridades['Nadar'] cuando no existe te da un aviso y null. En Go no hay aviso ni null: te da el valor cero del tipo. Para un map[string]int, un 0.

Gomain.go
package main

import "fmt"

func main() {
    prioridades := map[string]int{"Comprar pan": 2, "Regar plantas": 0}

    // Las dos dan 0... ¿cuál existe y cuál no?
    fmt.Println(prioridades["Regar plantas"], prioridades["Nadar"])

    // comma ok: el segundo valor dice si la clave estaba.
    // En PHP: array_key_exists('Regar plantas', $prioridades)
    p, ok := prioridades["Regar plantas"]
    fmt.Println(p, ok)

    p, ok = prioridades["Nadar"]
    fmt.Println(p, ok)

    // La forma habitual: dentro de un if.
    // En PHP: if (array_key_exists('Comprar pan', $prioridades)) { ... }
    if p, ok := prioridades["Comprar pan"]; ok {
        fmt.Println("Comprar pan tiene prioridad", p)
    }

    // Un valor por defecto, como $prioridades['Nadar'] ?? 1
    prioridad, ok := prioridades["Nadar"]
    if !ok {
        prioridad = 1
    }
    fmt.Println("Nadar:", prioridad)
}

¿Por qué? · En PHP no existe

¿Por qué un 0 y no un error o un null? En PHP tienes isset y ??

Porque en Go un int nunca puede ser null: siempre tiene un número. Si la clave no está, Go te da el número «vacío», que es 0. Eso es muy cómodo para contar: conteo["casa"]++ funciona aunque "casa" no existiera (en PHP tendrías que escribir ($conteo['casa'] ?? 0) + 1).

El problema es que un 0 puede significar «prioridad baja» o «no está». Para no adivinar, Go te da el ok. Y aquí Go es más claro que PHP, que tiene una trampa conocida:

  • isset($m['x']) devuelve false si la clave existe pero vale null.
  • array_key_exists('x', $m) devuelve true en ese mismo caso.
  • En Go solo hay una pregunta y una respuesta: _, ok := m["x"] es true si la clave está, valga lo que valga.

3 · Un map no tiene orden

Esto es lo que más choca viniendo de PHP. Un array de PHP recuerda el orden en que metiste las claves, como una cola del súper. Un map de Go es como un cajón de calcetines: están todos, pero sin orden. Ejecuta esto un par de veces:

Gomain.go
package main

import "fmt"

func main() {
    prioridades := map[string]int{
        "Comprar pan":     2,
        "Repasar Go":      1,
        "Regar plantas":   0,
        "Llamar al banco": 2,
        "Sacar la basura": 1,
    }

    // Tres vueltas al mismo map: el orden puede cambiar en cada una
    for vuelta := range 3 {
        fmt.Print("Vuelta ", vuelta+1, ": ")
        for titulo := range prioridades {
            fmt.Print(titulo, " | ")
        }
        fmt.Println()
    }

    // fmt.Println sí ordena las claves al imprimir, para que se lea bien
    fmt.Println(prioridades)
}

¿Por qué? · En PHP no existe

¿Por qué Go desordena a propósito? PHP mantiene el orden

Un map por dentro es una tabla hash: calcula a partir de cada clave en qué cajón guardarla, para encontrarla al momento. Ese orden de cajones no tiene nada que ver con el orden en que metiste las claves, y además cambia cuando el map crece y se reorganiza.

En las primeras versiones de Go el orden «parecía» fijo, y la gente escribía programas que dependían de él sin darse cuenta. Cuando cambiaba algo por dentro, esos programas se rompían. Desde Go 1, el orden se baraja adrede en cada recorrido: si tu código depende del orden, lo descubres en tus pruebas y no en producción.

PHP sí guarda el orden, pero lo paga: cada array lleva por dentro una lista extra con el orden de inserción. Go prefiere que, si quieres orden, lo pidas tú.

4 · Recorrer en orden: maps.Keys y slices.Sorted

Si necesitas un orden, el truco es siempre el mismo: saca las claves a una slice, ordénala y recorre la slice. El paquete maps te da las claves y slices.Sorted las ordena en una sola línea.

Gomain.go
package main

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

func main() {
    prioridades := map[string]int{
        "Repasar Go":      1,
        "Comprar pan":     2,
        "Regar plantas":   0,
        "Llamar al banco": 2,
    }

    // En PHP: ksort($prioridades); foreach (...)
    for _, titulo := range slices.Sorted(maps.Keys(prioridades)) {
        fmt.Println(titulo, prioridades[titulo])
    }
    fmt.Println("---")

    // En PHP: arsort($prioridades); de más prioridad a menos,
    // y a igual prioridad, por título
    porPrioridad := slices.SortedFunc(maps.Keys(prioridades), func(a, b string) int {
        if prioridades[a] != prioridades[b] {
            return cmp.Compare(prioridades[b], prioridades[a])
        }
        return cmp.Compare(a, b)
    })
    fmt.Println(porPrioridad)
}
PHPGoQué hace
array_keys($m)slices.Collect(maps.Keys(m))Las claves en una slice (sin orden)
array_values($m)slices.Collect(maps.Values(m))Los valores en una slice (sin orden)
ksort($m) + foreachslices.Sorted(maps.Keys(m))Las claves ordenadas
uksort / arsortslices.SortedFunc(maps.Keys(m), fn)Las claves con tu propio orden
$copia = $m;maps.Clone(m)Una copia independiente
$m == $otromaps.Equal(m, otro)Mismas claves con los mismos valores

maps.Keys(m) no devuelve una slice sino un iterador: algo que va entregando las claves de una en una, como un yield de PHP. slices.Sorted y slices.Collect las recogen en una slice. Verás los iteradores a fondo más adelante en el curso.

5 · Contar y agrupar

Gracias al valor cero, contar y agrupar en Go es más corto que en PHP: no hace falta comprobar si la clave ya existía.

Gomain.go
package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    etiquetas := []string{"casa", "trabajo", "casa", "recados", "casa"}

    // Contar. En PHP: array_count_values($etiquetas)
    conteo := map[string]int{}
    for _, e := range etiquetas {
        // Si "casa" no estaba, vale 0 y pasa a 1
        conteo[e]++
    }
    fmt.Println(conteo)

    // Agrupar títulos por etiqueta: un map de slices.
    // En PHP: $porEtiqueta['casa'][] = 'Regar plantas';
    porEtiqueta := map[string][]string{}
    porEtiqueta["casa"] = append(porEtiqueta["casa"], "Regar plantas")
    porEtiqueta["casa"] = append(porEtiqueta["casa"], "Fregar")
    porEtiqueta["trabajo"] = append(porEtiqueta["trabajo"], "Enviar informe")

    for _, e := range slices.Sorted(maps.Keys(porEtiqueta)) {
        fmt.Println(e, porEtiqueta[e])
    }
}

porEtiqueta["casa"] vale nil la primera vez (el valor cero de una slice), y append sobre nil funciona. Así que m[k] = append(m[k], x) es el $m[$k][] = $x; de PHP, línea por línea.

La pregunta que te vas a hacer

«Vale, pero… ¿y mi json_encode()?»

En PHP, json_encode(['pan' => 2]) saca {"pan":2} y json_encode(['pan', 'leche']) saca ["pan","leche"]. En Go es igual de directo y sin sorpresas: el paquete encoding/json convierte un map en un objeto JSON (con las claves ordenadas) y una slice en una lista JSON. Nunca más una lista que sale como objeto por culpa de un hueco.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Cuenta por estado

Completa Contar(estados []string) map[string]int, que cuenta cuántas veces aparece cada estado. Por ejemplo, ["hecha", "pendiente", "hecha"] da map[hecha:2 pendiente:1]. Es el array_count_values() 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. map[string]int es tu array asociativo con tipos fijos; delete(m, k) es unset($m[$k]).
  2. Una clave que no está da el valor cero; v, ok := m[k] es tu array_key_exists() (y sin la trampa del isset con null).
  3. Un map no tiene orden y Go lo baraja adrede; PHP recuerda el orden de inserción.
  4. slices.Sorted(maps.Keys(m)) es tu ksort() + foreach.
  5. m[k]++ y m[k] = append(m[k], x) funcionan sin comprobar nada: son array_count_values y $m[$k][] = $x.
  6. Un map se comparte al pasarlo a una función, como un objeto de PHP; maps.Clone si quieres copia.

Para recordarlo: «Cajón de calcetines»

Un map es un cajón de calcetines: encuentras cualquiera al momento, pero nunca salen en orden. Si quieres orden, sácalos y ordénalos (slices.Sorted(maps.Keys(m))). Y antes de fiarte de un 0, pregunta si el calcetín estaba: v, ok := m[k].