Stringhe in Golang: Split, Join, Contains, Replace e altro

Una stringa Go è una sequenza immutabile di byte, di solito testo UTF-8. Gli operatori lavorano sulla stringa stessa (+, ==, <, indicizzazione, slicing), e tutto il resto sta nel pacchetto standard 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   ") + "!")
}

Dividere le stringhe

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)
}

Il caso Split("", ",") inganna molti: un input vuoto dà uno slice di lunghezza 1, non 0. Quando dividi l'input dell'utente, Fields oppure un controllo preventivo di s == "" evita un elemento vuoto fantasma.

strings.Cut è il modo più pulito per dividere coppie come key=value, user@host e simili. Go 1.24 ha aggiunto anche versioni con iteratori, strings.SplitSeq e strings.FieldsSeq, che producono le parti una alla volta senza costruire uno slice.

Cercare

Tutte le ricerche distinguono tra maiuscole e minuscole tranne EqualFold. Per cercare senza questa distinzione, porta in minuscolo entrambi i lati oppure usa EqualFold per confrontare stringhe intere.

Trasformare

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 trappola: Trim, TrimLeft e TrimRight accettano un insieme di caratteri, non un prefisso. strings.TrimLeft("abcab", "ab") rimuove ogni a e b iniziale e restituisce "cab". Per rimuovere un prefisso o un suffisso esatto usa TrimPrefix e TrimSuffix.

Concatenazione e strings.Builder

+ unisce le stringhe, e fmt.Sprintf formatta dei valori in una stringa. Entrambi allocano ogni volta una nuova stringa, perché le stringhe sono immutabili. Va bene per poche operazioni ed è lento in un ciclo, dove ogni += copia tutto ciò che hai costruito fino a quel momento. Usa invece 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, ", "))
}

Uno strings.Builder al valore zero è pronto all'uso. Implementa io.Writer, quindi fmt.Fprintf ci scrive direttamente. Chiama prima b.Grow(n) se sai più o meno quanto sarà grande il risultato. Non copiare un Builder dopo averci scritto; passa un puntatore.

Stringhe su più righe e stringhe raw

Go ha due tipi di letterale stringa:

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)
}

Le stringhe tra doppi apici interpretano le sequenze di escape (\n, \t, \", \\, \u00e9) e devono stare su una riga. Le stringhe raw tra backtick prendono tutto alla lettera, compresi i ritorni a capo, e sono quindi il modo per scrivere stringhe su più righe, espressioni regolari, JSON e percorsi Windows. Una stringa raw non può contenere un backtick, e i ritorni carrello al suo interno vengono eliminati. Nota che la query qui sopra inizia con un ritorno a capo, perché il letterale comincia subito dopo il backtick di apertura.

Lunghezza, indicizzazione e sottostringhe

len(s) è il numero di byte. s[i] è un byte, e s[i:j] è una sottostringa per posizioni in byte:

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
}

ï ed é occupano due byte ciascuno, quindi la stringa è lunga 12 byte e 10 caratteri. Tagliare per byte è sicuro finché le posizioni arrivano da strings.Index o simili, che restituiscono offset in byte sui confini dei caratteri. Per prendere "i primi n caratteri", converti prima in []rune. La pagina su rune e byte spiega UTF-8 in dettaglio.

Le stringhe sono immutabili

Non puoi cambiare un byte sul posto: s[0] = 'H' è un errore di compilazione (cannot assign to s[0] (neither addressable nor a map index expression)). Ogni funzione di strings restituisce una nuova stringa. Per modificarla, converti in []byte o []rune, cambia lo slice e riconverti:

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

L'immutabilità è anche il motivo per cui le sottostringhe costano poco: s[2:5] condivide la memoria con s invece di copiarla. Il rovescio della medaglia è che una piccola sottostringa di una stringa enorme tiene in vita tutta la stringa enorme. Usa strings.Clone (Go 1.20) quando conservi un pezzo breve di un input grande.

Confrontare le stringhe

== e != confrontano il contenuto, e <, > confrontano byte per byte, cioè in ordine alfabetico per l'ASCII. strings.Compare esiste ma serve raramente; slices.Sort su un []string usa <. Per un ordinamento che rispetti le regole locali dei testi non inglesi, usa golang.org/x/text/collate.

Convertire altri tipi

I numeri diventano stringhe con strconv.Itoa, strconv.FormatFloat o fmt.Sprintf, e le stringhe diventano numeri con strconv.Atoi e strconv.ParseFloat. Non scrivere string(42): produce il carattere con code point 42, cioè "*". La pagina sulla conversione di tipo ha la tabella completa.

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