Строки в Golang: Split, Join, Contains, Replace и другие

Строка в Go это неизменяемая последовательность байтов, обычно текст в UTF-8. Операторы работают с самой строкой (+, ==, <, индексация, срезы), а всё остальное находится в стандартном пакете 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   ") + "!")
}

Разбиение строк

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

Случай Split("", ",") ловит многих: пустой ввод даёт слайс длины 1, а не 0. При разбиении пользовательского ввода Fields или предварительная проверка s == "" избавляют от фантомного пустого элемента.

strings.Cut самый чистый способ разбить пары вроде key=value или user@host. В Go 1.24 также появились версии-итераторы, strings.SplitSeq и strings.FieldsSeq, которые выдают части по одной, не создавая слайс.

Поиск

Любой поиск учитывает регистр, кроме EqualFold. Чтобы искать без учёта регистра, приведите обе стороны к нижнему регистру или используйте EqualFold для сравнения строк целиком.

Преобразование

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

Одна ловушка: Trim, TrimLeft и TrimRight принимают набор символов, а не префикс. strings.TrimLeft("abcab", "ab") убирает все ведущие a и b и возвращает "cab". Чтобы убрать точный префикс или суффикс, используйте TrimPrefix и TrimSuffix.

Конкатенация и strings.Builder

+ склеивает строки, а fmt.Sprintf форматирует значения в одну строку. Оба каждый раз создают новую строку, потому что строки неизменяемы. Для нескольких операций это нормально, а в цикле медленно: каждый += копирует всё, что уже собрано. Вместо этого используйте 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, ", "))
}

Нулевой strings.Builder готов к работе. Он реализует io.Writer, поэтому fmt.Fprintf пишет в него напрямую. Если примерно знаете размер результата, сначала вызовите b.Grow(n). Не копируйте Builder после записи в него; передавайте указатель.

Многострочные и сырые строки

В Go два вида строковых литералов:

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

Строки в двойных кавычках обрабатывают escape-последовательности (\n, \t, \", \\, \u00e9) и должны помещаться на одной строке. Сырые строки в обратных кавычках берут всё буквально, включая переводы строк, поэтому так пишут многострочный текст, регулярные выражения, JSON и пути Windows. Сырая строка не может содержать обратную кавычку, а символы возврата каретки внутри неё отбрасываются. Обратите внимание: запрос выше начинается с перевода строки, потому что литерал начинается сразу после открывающей обратной кавычки.

Длина, индексация и подстроки

len(s) это число байтов. s[i] это байт, а s[i:j] это подстрока по позициям в байтах:

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
}

ï и é занимают по два байта, поэтому в строке 12 байтов и 10 символов. Срез по байтам безопасен, пока позиции берутся из strings.Index и подобных функций, которые возвращают смещения в байтах на границах символов. Чтобы взять «первые n символов», сначала преобразуйте строку в []rune. UTF-8 подробно объясняется на странице о рунах и байтах.

Строки неизменяемы

Изменить байт на месте нельзя: s[0] = 'H' это ошибка компиляции (cannot assign to s[0] (neither addressable nor a map index expression)). Каждая функция из strings возвращает новую строку. Чтобы редактировать, преобразуйте в []byte или []rune, измените слайс и преобразуйте обратно:

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

Неизменяемость также делает подстроки дешёвыми: s[2:5] разделяет память с s, а не копирует её. Обратная сторона: маленькая подстрока огромной строки держит в памяти всю огромную строку. Используйте strings.Clone (Go 1.20), когда сохраняете короткий кусок большого ввода.

Сравнение строк

== и != сравнивают содержимое, а < и > сравнивают побайтно, что для ASCII означает алфавитный порядок. strings.Compare существует, но нужна редко; slices.Sort для []string использует <. Для сортировки текста не на английском с учётом локали используйте golang.org/x/text/collate.

Преобразование других типов

Числа превращаются в строки через strconv.Itoa, strconv.FormatFloat или fmt.Sprintf, а строки в числа через strconv.Atoi и strconv.ParseFloat. Не пишите string(42): это даёт символ с кодовой точкой 42, "*". Полная таблица на странице о преобразовании типов.

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