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

Strings, bytes y runes: adiós a mb_*

9 min de lectura 4 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.

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.

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

$titulo = 'Café';

// Bytes: la «é» ocupa 2
echo strlen($titulo) . PHP_EOL;

// Letras
echo mb_strlen($titulo) . PHP_EOL;

// substr corta bytes: deja media «é» rota
var_dump(substr($titulo, 0, 4));

// mb_substr corta letras
echo mb_substr($titulo, 0, 4) . PHP_EOL;
Gomain.go
package main

import (
    "fmt"
    "unicode/utf8"
)

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

func main() {
    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))
}
PHPGoQué 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"
)

func main() {
    // 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)
}
PHPGoOjo
str_contains($s, 'x')strings.Contains(s, "x")—
str_starts_with / str_ends_withstrings.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_strtolowerstrings.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"
)

func main() {
    tareas := []string{"Comprar pan", "Repasar Go", "Regar plantas"}

    // Un Builder vacío, listo para usar (su valor cero ya sirve)
    var b strings.Builder
    for 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

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

Resumen

Lo que te llevas de esta lección

  1. len(s) cuenta bytes, como strlen(); utf8.RuneCountInString(s) cuenta letras, como mb_strlen().
  2. for _, r := range s recorre letras (runes) y []rune(s) trocea por letras: tu mb_str_split() y mb_substr().
  3. s[i] es un byte, no una letra: con tildes y eñes, pasa antes por []rune.
  4. strings.Split / Join / Contains / TrimSpace son explode / implode / str_contains / trim, y ToUpper ya entiende tildes.
  5. 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_*.