Lección 8 de 36 · El array de PHP en Go✦ WebMCP implementado
Maps: el array asociativo (sin orden)
9 min de lectura4 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).
Leer una clave que no está no falla: te da el valor cero (0, ""). Para saber si estaba, usa p, ok := m["pan"]: el ok es tu array_key_exists().
Un map no tiene orden. Al recorrerlo con range las claves salen cada vez en un orden distinto. PHP, en cambio, recuerda el orden en que las metiste.
Si quieres orden, ordena las claves: slices.Sorted(maps.Keys(m)) es tu ksort(). Y delete(m, "pan") es tu unset($m['pan']).
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».
package main
import"fmt"funcmain() {
// 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"funcmain() {
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 intnunca 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"funcmain() {
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 unafor vuelta := range3 {
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"
)
funcmain() {
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)
}
PHP
Go
Qué 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) + foreach
slices.Sorted(maps.Keys(m))
Las claves ordenadas
uksort / arsort
slices.SortedFunc(maps.Keys(m), fn)
Las claves con tu propio orden
$copia = $m;
maps.Clone(m)
Una copia independiente
$m == $otro
maps.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"
)
funcmain() {
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.
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
Pista. No asignes 1: súmale uno a lo que ya hubiera con conteo[e]++. Si la clave no estaba, vale 0 y pasa a 1.
Reto 2 de 4 · ✓ Resuelto
Prioridad por defecto
Completa PrioridadDe(prioridades map[string]int, titulo string) int: devuelve la prioridad de la tarea y, si la tarea no está en el map, 1 (media). Ojo: una prioridad 0 (baja) es válida y hay que devolverla tal cual. Es el $prioridades[$titulo] ?? 1 de PHP; en Go, con comma ok.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.p == 0 no distingue «prioridad baja» de «no está». Pide el segundo valor: p, ok := prioridades[titulo] y pregunta por ok.
Reto 3 de 4 · ✓ Resuelto
Títulos en orden
Completa TitulosOrdenados(prioridades map[string]int) []string, que devuelve los títulos (las claves) en orden alfabético. Por ejemplo, map[string]int{"Repasar Go": 1, "Comprar pan": 2} da ["Comprar pan", "Repasar Go"]. Es el array_keys() + sort() de PHP; en Go, slices.Sorted(maps.Keys(…)).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Importa maps y slices, y devuelve slices.Sorted(maps.Keys(prioridades)). Si lo haces a mano con un for … range y append, no olvides slices.Sort al final: el range sale desordenado.
Reto 4 de 4 · ✓ Resuelto
Agrupa por etiqueta
Completa Agrupar(etiquetaDe map[string]string) map[string][]string. Recibe título → etiqueta y devuelve etiqueta → títulos, con los títulos de cada etiqueta en orden alfabético. Por ejemplo, {"Regar plantas": "casa", "Fregar": "casa", "Repasar Go": "estudio"} da {"casa": ["Fregar", "Regar plantas"], "estudio": ["Repasar Go"]}. En PHP sería un foreach con $grupos[$etiqueta][] = $titulo; y un sort() por grupo.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Dos pasos. 1) Añade en vez de pisar: grupos[etiqueta] = append(grupos[etiqueta], titulo). 2) Como el range de un map no tiene orden, recorre después grupos y haz slices.Sort(grupos[etiqueta]).
Resumen
Lo que te llevas de esta lección
map[string]int es tu array asociativo con tipos fijos; delete(m, k) es unset($m[$k]).
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).
Un map no tiene orden y Go lo baraja adrede; PHP recuerda el orden de inserción.
slices.Sorted(maps.Keys(m)) es tu ksort() + foreach.
m[k]++ y m[k] = append(m[k], x) funcionan sin comprobar nada: son array_count_values y $m[$k][] = $x.
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].