Lección 9 de 36 · El array de PHP en Go✦ WebMCP implementado
Strings, bytes y runes: adiós a mb_*
9 min de lectura4 retos
En PHP tienes dos juegos de funciones para el texto: strlen, substr, strtoupper… y sus primas mb_* para cuando hay tildes y eñes. En Go no hay mb_*: un string son bytes, y cuando quieres letras usas runes. En esta lección aprendes cuándo usar cada cosa, el paquete strings y cómo construir textos largos sin desperdiciar memoria.
¿De dónde vienen los nombres?
byte = inglés byte (la unidad de 8 bits)
Un trocito de 8 bits. Una letra sin tilde ocupa 1 byte; una é o una ñ, 2; un emoji, 4. strlen() en PHP cuenta bytes.
rune = inglés rune (runa, letra de los alfabetos germánicos antiguos)
Una letra o símbolo Unicode. El nombre viene de Plan 9, el sistema operativo de los Bell Labs donde Ken Thompson y Rob Pike, que crearon UTF-8 y después Go, ya llamaban así a un carácter. Es lo que cuentan las funciones mb_* de PHP.
utf8 = UTF-8 (Unicode Transformation Format, en trozos de 8 bits)
El paquete para contar y recorrer letras dentro de los bytes. Go guarda su código y sus textos siempre en UTF-8, sin mb_internal_encoding().
Builder = inglés builder (constructor, el que construye)
Va juntando trozos de texto sin crear un string nuevo en cada paso. Tu .= dentro de un bucle.
En 4 ideas
1/4
Un string de Go es una fila de bytes que no se puede cambiar. len("Café") da 5, igual que strlen('Café') en PHP, porque la é ocupa 2 bytes.
Una rune es una letra. utf8.RuneCountInString(s) es tu mb_strlen(), for _, r := range s recorre letra a letra (tu mb_str_split()) y []rune(s) te deja trocear por letras como mb_substr().
El paquete strings es tu caja de str_*: Contains es str_contains, Split es explode, Join es implode, TrimSpace es trim. Y ToUpper ya entiende tildes, como mb_strtoupper.
Un string no se puede cambiar. Para ir juntando muchos trozos usa strings.Builder: es tu $texto .= … dentro de un foreach, sin crear un string nuevo en cada vuelta.
1 · len cuenta bytes, no letras
Imagina un tren: cada vagón es un byte. Las letras sin tilde viajan en un vagón. La é y la ñ necesitan dos vagones; un emoji, cuatro. len cuenta vagones, no viajeros. Es justo lo que hace strlen() en PHP.
package main
import (
"fmt""unicode/utf8"
)
funcmain() {
titulo := "Café"// En PHP: strlen($titulo)
fmt.Println(len(titulo))
// En PHP: mb_strlen($titulo)
fmt.Println(utf8.RuneCountInString(titulo))
// En PHP: substr($titulo, 0, 4); corta bytes
fmt.Printf("%q\n", titulo[:4])
// En PHP: mb_substr($titulo, 0, 4); corta letras
fmt.Println(string([]rune(titulo)[:4]))
}
titulo[:4] corta por bytes y se queda con media é: %q la enseña como \xc3, un byte suelto que no es ninguna letra. Para cortar por letras, primero conviertes a []rune.
¿Por qué? · En PHP no existe
¿Por qué len cuenta bytes y no letras? Sería más cómodo al revés
Porque contar bytes es instantáneo: Go guarda la longitud en bytes junto al string y len solo la lee. Contar letras obliga a recorrer el texto entero, vagón a vagón, para ver dónde empieza cada una. Go no quiere que algo que parece gratis (len) sea lento a escondidas.
Además, la mayoría de las veces quieres bytes: para guardar en la base de datos, enviar por la red o comparar. Y cuando quieres letras, lo pides con un nombre que lo dice claro: utf8.RuneCountInString.
La diferencia con PHP es que en Go no hay que elegir codificación: el código fuente y los strings son siempre UTF-8. Se acabó el mb_internal_encoding('UTF-8') y las sorpresas con latin1.
2 · Runes: letra a letra
Una rune es una letra (en realidad, un número que identifica una letra en Unicode). Hay dos formas de trabajar con ellas: recorrer el string con range, o convertirlo entero a []rune.
Gomain.go
package main
import (
"fmt""strings"
)
funcmain() {
titulo := "Añadir té"// range sobre un string da letras (runes), no bytes.// i es la posición en BYTES donde empieza cada letra: fíjate cómo salta.// En PHP: foreach (mb_str_split($titulo) as $letra)for i, letra := range titulo {
fmt.Printf("%d:%c ", i, letra)
}
fmt.Println()
// []rune: una slice de letras. Ahora sí, una posición por letra.
letras := []rune(titulo)
// En PHP: mb_strlen($titulo)
fmt.Println(len(letras))
// En PHP: mb_substr($titulo, 0, 6)
fmt.Println(string(letras[:6]))
// En PHP: mb_strtoupper($titulo); ToUpper ya entiende la ñ y la é
fmt.Println(strings.ToUpper(titulo))
}
PHP
Go
Qué hace
strlen($s)
len(s)
Cuenta bytes
mb_strlen($s)
utf8.RuneCountInString(s)
Cuenta letras
substr($s, 0, 4)
s[:4]
Corta bytes (puede romper una letra)
mb_substr($s, 0, 4)
string([]rune(s)[:4])
Corta letras
mb_str_split($s)
for _, r := range s o []rune(s)
Letra a letra
mb_strtoupper($s)
strings.ToUpper(s)
Mayúsculas, con tildes
3 · El paquete strings: tus str_*
Casi todas las funciones de texto de PHP tienen su gemela en el paquete strings. La diferencia: el texto va siempre primero (en PHP cada función pone los argumentos en un orden distinto).
Gomain.go
package main
import (
"fmt""strings"
)
funcmain() {
// En PHP: trim()
titulo := strings.TrimSpace(" Comprar pan y leche ")
// En PHP: str_contains() y str_starts_with()
fmt.Println(strings.Contains(titulo, "pan"), strings.HasPrefix(titulo, "Comprar"))
// En PHP: str_replace('leche', 'huevos', $titulo)
fmt.Println(strings.ReplaceAll(titulo, "leche", "huevos"))
// En PHP: explode(',', ...) e implode(' | ', ...)
etiquetas := strings.Split("casa,trabajo,recados", ",")
fmt.Println(len(etiquetas), strings.Join(etiquetas, " | "))
// En PHP: preg_split('/\s+/', trim($s)); parte por espacios, sin huecos
fmt.Printf("%q\n", strings.Fields(" repasar go hoy "))
// En PHP: explode(':', $s, 2); corta por el primer «:»
etiqueta, tarea, ok := strings.Cut("casa:Regar plantas", ":")
fmt.Println(etiqueta, "|", tarea, "|", ok)
}
PHP
Go
Ojo
str_contains($s, 'x')
strings.Contains(s, "x")
—
str_starts_with / str_ends_with
strings.HasPrefix / strings.HasSuffix
—
str_replace($a, $b, $s)
strings.ReplaceAll(s, a, b)
El texto va primero
explode(',', $s)
strings.Split(s, ",")
Separador al final
implode(', ', $t)
strings.Join(t, ", ")
Recibe una []string
trim($s)
strings.TrimSpace(s)
strings.Trim(s, "-") para otros caracteres
strtolower / mb_strtolower
strings.ToLower(s)
Ya entiende tildes
strpos($s, 'x')
strings.Index(s, "x")
Posición en bytes; -1 si no está
substr_count($s, 'x')
strings.Count(s, "x")
—
str_repeat('=', 10)
strings.Repeat("=", 10)
—
sprintf(...)
fmt.Sprintf(...)
Del paquete fmt
4 · Strings que no cambian y strings.Builder
Un string de Go es como un texto grabado en piedra: lo puedes leer, copiar o trocear, pero no cambiar una letra. Si intentas titulo[0] = 'C', el compilador responde: cannot assign to titulo[0] (neither addressable nor a map index expression). Para «cambiarlo», creas un string nuevo.
¿Por qué? · En PHP no existe
¿Por qué no se puede cambiar un string? En PHP $titulo[0] = 'C' funciona
Porque así se puede compartir sin miedo. ¿Recuerdas la trampa del append de la lección 2, donde un trozo de slice pisaba la original? Con strings no puede pasar: titulo[:7] también comparte memoria con titulo (y por eso es gratis), pero como nadie puede escribir en ella, da igual quién la mire.
Lo mismo vale cuando varias partes del programa (o varias tareas a la vez, en el módulo 08) usan el mismo texto: nadie se lo puede cambiar a nadie.
El precio: s += "más" crea un string nuevo y copia todo lo anterior. En un bucle de mil vueltas son mil copias cada vez más largas. En PHP, .= suele ampliar el mismo string por dentro; en Go, para eso está strings.Builder.
Gomain.go
package main
import (
"fmt""strconv""strings"
)
funcmain() {
tareas := []string{"Comprar pan", "Repasar Go", "Regar plantas"}
// Un Builder vacío, listo para usar (su valor cero ya sirve)var b strings.Builderfor i, t := range tareas {
// En PHP: $lista .= ($i + 1) . '. ' . $t . "\n";
b.WriteString(strconv.Itoa(i + 1))
b.WriteString(". ")
b.WriteString(t)
b.WriteString("\n")
}
// Al final, String() te da el texto completo
fmt.Print(b.String())
}
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Bytes y letras
El título Café con leche tiene 15 bytes y 14 letras. Haz que el programa imprima 15 14: primero los bytes (tu strlen) y después las letras (tu mb_strlen).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. El segundo len cuenta bytes otra vez. Importa unicode/utf8 y usa utf8.RuneCountInString(titulo) (o len([]rune(titulo))).
Reto 2 de 4 · ✓ Resuelto
Etiquetas desde un texto
Completa Etiquetas(texto string) []string: parte el texto por comas, quita los espacios de cada trozo y descarta los vacíos. Por ejemplo, "casa, trabajo ,,urgente" da ["casa", "trabajo", "urgente"]. En PHP sería explode() + trim() + array_filter().
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Recorre strings.Split(texto, ","), limpia cada trozo con strings.TrimSpace y solo haz append si no queda vacío.
Reto 3 de 4 · ✓ Resuelto
Iniciales con eñe
Completa Iniciales(titulo string) string, que devuelve la primera letra de cada palabra, en mayúsculas. Por ejemplo, "comprar pan" da "CP" y "ñandú étnico" da "ÑÉ". El código de partida funciona sin tildes pero rompe la ñ: es el clásico substr($p, 0, 1) que debería ser mb_substr($p, 0, 1).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.palabra[:1] es el primer byte, y la ñ ocupa dos. Coge la primera letra con []rune(palabra)[0] y conviértela en string con string(...) antes de strings.ToUpper.
Reto 4 de 4 · ✓ Resuelto
Lista numerada con Builder
Completa Lista(titulos []string) string, que devuelve las tareas numeradas, una por línea y cada una terminada en \n. Por ejemplo, ["Comprar pan", "Repasar Go"] da "1. Comprar pan\n2. Repasar Go\n", y una lista vacía da "". Es tu foreach con $lista .= … de PHP; en Go, con strings.Builder.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Declara var b strings.Builder, recorre los títulos y escribe cada línea con fmt.Fprintf(&b, "%d. %s\n", i+1, t) (o con b.WriteString). Devuelve b.String().
Resumen
Lo que te llevas de esta lección
len(s) cuenta bytes, como strlen(); utf8.RuneCountInString(s) cuenta letras, como mb_strlen().
for _, r := range s recorre letras (runes) y []rune(s) trocea por letras: tu mb_str_split() y mb_substr().
s[i] es un byte, no una letra: con tildes y eñes, pasa antes por []rune.
strings.Split / Join / Contains / TrimSpace son explode / implode / str_contains / trim, y ToUpper ya entiende tildes.
Los strings no se pueden cambiar; para juntar muchos trozos, strings.Builder (tu .= en un bucle).
Para recordarlo: «len cuenta vagones, range cuenta viajeros»
Un string es un tren de bytes (vagones) que lleva letras (viajeros); la é y la ñ viajan en dos vagones. len y s[i] cuentan vagones, como strlen. range, []rune y utf8.RuneCountInString cuentan viajeros, como mb_*.