Strings en Golang: Split, Join, Contains, Replace y más

Un string de Go es una secuencia inmutable de bytes, normalmente texto UTF-8. Los operadores trabajan con el propio string (+, ==, <, indexar, recortar), y todo lo demás vive en el paquete estándar strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Dividir strings

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

El caso de Split("", ",") pilla a mucha gente: una entrada vacía da un slice de longitud 1, no 0. Al dividir la entrada del usuario, Fields o comprobar antes s == "" evita un elemento vacío fantasma.

strings.Cut es la forma más limpia de dividir pares como key=value o user@host. Go 1.24 añadió además versiones con iterador, strings.SplitSeq y strings.FieldsSeq, que producen las partes de una en una sin construir un slice.

Buscar

Todas las búsquedas distinguen mayúsculas y minúsculas salvo EqualFold. Para buscar sin distinguirlas, pasa los dos lados a minúsculas o usa EqualFold para comparar strings completos.

Transformar

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

Una trampa: Trim, TrimLeft y TrimRight reciben un conjunto de caracteres, no un prefijo. strings.TrimLeft("abcab", "ab") quita todas las a y b del principio y devuelve "cab". Para quitar un prefijo o un sufijo exactos, usa TrimPrefix y TrimSuffix.

Concatenación y strings.Builder

+ une strings, y fmt.Sprintf formatea valores en uno. Los dos reservan un string nuevo cada vez, porque los strings son inmutables. Está bien para un puñado de operaciones y es lento en un bucle, donde cada += copia todo lo construido hasta ese momento. Usa strings.Builder:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

Un strings.Builder a cero está listo para usar. Implementa io.Writer, así que fmt.Fprintf escribe directamente en él. Llama antes a b.Grow(n) si sabes más o menos lo grande que será el resultado. No copies un Builder después de escribir en él; pasa un puntero.

Strings multilínea y raw strings

Go tiene dos tipos de literal de string:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

Los strings entre comillas dobles procesan escapes (\n, \t, \", \\, \u00e9) y tienen que caber en una línea. Los raw strings entre comillas invertidas lo toman todo literalmente, incluidos los saltos de línea, lo que los convierte en la forma de escribir strings multilínea, expresiones regulares, JSON y rutas de Windows. Un raw string no puede contener una comilla invertida, y los retornos de carro que haya dentro se descartan. Fíjate en que la consulta de arriba empieza con un salto de línea, porque el literal empieza justo después de la comilla invertida de apertura.

Longitud, índices y substrings

len(s) es el número de bytes. s[i] es un byte, y s[i:j] es un substring por posiciones en bytes:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï y é ocupan dos bytes cada una, así que el string tiene 12 bytes y 10 caracteres. Recortar por bytes es seguro siempre que las posiciones vengan de strings.Index o funciones parecidas, que devuelven desplazamientos en bytes en los límites de los caracteres. Para tomar "los primeros n caracteres", convierte antes a []rune. La página de runes y bytes explica UTF-8 a fondo.

Los strings son inmutables

No puedes cambiar un byte en el sitio: s[0] = 'H' es un error de compilación (cannot assign to s[0] (neither addressable nor a map index expression)). Cada función de strings devuelve un string nuevo. Para editar, convierte a []byte o []rune, cambia el slice y vuelve a convertir:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

La inmutabilidad es también la razón de que los substrings sean baratos: s[2:5] comparte memoria con s en lugar de copiarla. La otra cara es que un substring pequeño de un string enorme mantiene vivo el string enorme entero. Usa strings.Clone (Go 1.20) cuando te quedes con un trozo corto de una entrada grande.

Comparar strings

== y != comparan el contenido, y < y > comparan byte a byte, lo que equivale al orden alfabético en ASCII. strings.Compare existe pero rara vez hace falta; slices.Sort sobre un []string usa <. Para ordenar texto en otros idiomas respetando sus reglas, usa golang.org/x/text/collate.

Convertir otros tipos

Los números se convierten en strings con strconv.Itoa, strconv.FormatFloat o fmt.Sprintf, y los strings en números con strconv.Atoi y strconv.ParseFloat. No escribas string(42): produce el carácter con code point 42, "*". La página de conversión de tipos tiene la tabla completa.

query := `SELECT id, name
FROM users
WHERE active = true`