Stringi w Golang: Split, Join, Contains, Replace i więcej

String w Go to niezmienny ciąg bajtów, zwykle tekst w UTF-8. Operatory działają na samym stringu (+, ==, <, indeksowanie, wycinanie), a cała reszta znajduje się w standardowym pakiecie 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   ") + "!")
}

Dzielenie stringów

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

Przypadek Split("", ",") łapie wiele osób: puste wejście daje slice o długości 1, a nie 0. Przy dzieleniu danych od użytkownika Fields albo wcześniejsze sprawdzenie s == "" pozwala uniknąć fantomowego pustego elementu.

strings.Cut to najczystszy sposób na podzielenie key=value, user@host i podobnych par. Go 1.24 dodało też wersje z iteratorami, strings.SplitSeq i strings.FieldsSeq, które zwracają części po jednej, bez budowania slice'a.

Wyszukiwanie

Każde wyszukiwanie rozróżnia wielkość liter, z wyjątkiem EqualFold. Aby szukać bez rozróżniania wielkości liter, zamień obie strony na małe litery albo użyj EqualFold do porównania całych stringów.

Przekształcanie

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

Jedna pułapka: Trim, TrimLeft i TrimRight przyjmują zestaw znaków, a nie prefiks. strings.TrimLeft("abcab", "ab") usuwa każde początkowe a i b i zwraca "cab". Aby usunąć dokładny prefiks lub sufiks, użyj TrimPrefix i TrimSuffix.

Łączenie i strings.Builder

+ łączy stringi, a fmt.Sprintf formatuje wartości w jeden string. Oba za każdym razem alokują nowy string, bo stringi są niezmienne. Przy kilku operacjach to nie problem, ale w pętli jest wolne, bo każde += kopiuje wszystko, co zbudowano do tej pory. Użyj zamiast tego 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, ", "))
}

Zerowy strings.Builder jest gotowy do użycia. Implementuje io.Writer, więc fmt.Fprintf zapisuje do niego bezpośrednio. Najpierw wywołaj b.Grow(n), jeśli z grubsza wiesz, jak duży będzie wynik. Nie kopiuj Builder po zapisaniu do niego danych; przekazuj wskaźnik.

Wieloliniowe i surowe stringi

Go ma dwa rodzaje literałów stringów:

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

Stringi w podwójnych cudzysłowach przetwarzają sekwencje ucieczki (\n, \t, \", \\, \u00e9) i muszą mieścić się w jednej linii. Surowe stringi w backtickach biorą wszystko dosłownie, łącznie ze znakami nowej linii, więc tak zapisuje się wieloliniowe stringi, wyrażenia regularne, JSON i ścieżki Windows. Surowy string nie może zawierać backticka, a znaki powrotu karetki są z niego usuwane. Zauważ, że powyższe zapytanie zaczyna się od znaku nowej linii, bo literał zaczyna się zaraz po otwierającym backticku.

Długość, indeksowanie i podciągi

len(s) to liczba bajtów. s[i] to bajt, a s[i:j] to podciąg według pozycji w bajtach:

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
}

ï i é zajmują po dwa bajty, więc string ma 12 bajtów i 10 znaków. Wycinanie po bajtach jest bezpieczne, o ile pozycje pochodzą z strings.Index lub podobnych funkcji, które zwracają przesunięcia w bajtach na granicach znaków. Aby wziąć „pierwsze n znaków”, najpierw zamień string na []rune. Strona o runach i bajtach szczegółowo wyjaśnia UTF-8.

Stringi są niezmienne

Nie możesz zmienić bajtu w miejscu: s[0] = 'H' to błąd kompilacji (cannot assign to s[0] (neither addressable nor a map index expression)). Każda funkcja z strings zwraca nowy string. Aby edytować, zamień na []byte lub []rune, zmień slice i zamień z powrotem:

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

Niezmienność sprawia też, że podciągi są tanie: s[2:5] współdzieli pamięć z s zamiast ją kopiować. Druga strona medalu: mały podciąg ogromnego stringa utrzymuje przy życiu cały ogromny string. Użyj strings.Clone (Go 1.20), gdy zachowujesz krótki fragment dużego wejścia.

Porównywanie stringów

== i != porównują zawartość, a <, > porównują bajt po bajcie, co dla ASCII oznacza kolejność alfabetyczną. strings.Compare istnieje, ale rzadko jest potrzebne; slices.Sort na []string używa <. Do sortowania tekstu w innych językach z uwzględnieniem reguł lokalnych użyj golang.org/x/text/collate.

Konwersja innych typów

Liczby zamieniasz na stringi przez strconv.Itoa, strconv.FormatFloat lub fmt.Sprintf, a stringi na liczby przez strconv.Atoi i strconv.ParseFloat. Nie pisz string(42): daje to znak o punkcie kodowym 42, czyli "*". Pełną tabelę znajdziesz na stronie o konwersji typów.

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