Разбираемся вместе: строки в golang
Один из постов серии «Разбираемся вместе«: представляет из себя разбор определенной темы лично мной в целях улучшения понимания и возможно, получения фидбека от более опытных людей.
* Этот пост в совокупности с комментариями может помочь кому-то лучше понять разбираемую тему или сделать более подробный разбор на базе него.
* Этот пост не служит инструкцией, курсом или документацией, где гаранитируется 100% достоверная информация по озвученной теме — автор учится сам, так что ошибки возможны.
Строка (string) — это базовый (basic) тип данных, который представляет из себя неизменяемую последовательность байт, представленных в кодировке UTF-8.
Строки должны быть заключены в двойные кавычки.
Одинарные же кавычки представляют отдельный символ, который в Go представлен типом rune (псевдоним int32).
str := "A"
fmt.Println(str) // Выводит A
char := 'A'
fmt.Println(char) // Выводит 65 — символ это в первую очередь код Unicode
Про кодирование строк
Unicode — это стандарт, который определяет уникальные коды для каждого символа, независимо от используемой системы или языка.
Unicode — это также система кодирования символов, которая включает в себя огромный набор символов, каждый из которых имеет свой уникальный код. Эти коды называются Unicode code points.
UTF-8 (8-bit Unicode Transformation Format) — это один из способов (или схем) кодирования символов Unicode в последовательности байт.
Это позволяет эффективно хранить символы в памяти и передавать их по сети.
При кодировании в формате UTF-8 каждый символ может занимать от 1 до 4 байт, в зависимости от его позиции в стандарте Unicode.
Символы из ASCII (U+0000 до U+007F) кодируются одним байтом.
Символы из более широких диапазонов Unicode (например, кириллица, китайские иероглифы, эмодзи) могут занимать 2, 3 или 4 байта.
Индексация строк
Индексация строки по умолчанию работает с байтами, а не с символами.
При обращении по индексу, возвращается тип byte.
Это отлично работает для символов ASCII, которые занимают 1 байт.
Для символов других алфавитов (например, кириллицы) через индексацию возвращается только первый байт, что может вызвать искажения при выводе символов.
Подробнее
Символы английского алфавита (символы ASCII) занимают 1 байт пространства.
то есть числовое представление символа ASCII, его код Unicode, умещается в 1 байт.
Поэтому каждый отдельный символ ASCII (вернее его код) можно получить через индекс.
s := “string”
fmt.Println(s[0]) // Выводит 83 — код символа в Unicode тип byte
fmt.Println(string(s[0])) // Выводит s — символ алфавита тип string
Делается каст типа byte в строку, чтобы привести символ в человекочитаемый вид.
Символы других алфавитов (или эмодзи) могут занимать более 1 байта. Поэтому через индекс нельзя получить полностью код Unicode. Вернется лишь значение первого байта.
Например, символы кириллицы занимают 2 байта пространства — числовое представление символа кириллицы, его код в Unicode не вмещается в 1 байт, поэтому происходит разделение на 2 байта.
s := “Привет”
fmt.Println(s[0]) // вернет Ð — код непонятен для кодировки utf-8, так как первый байт символа содержит лишь часть кода Unicode
символ кириллицы занимает 2 байта, через индекс забирается только первый байт, что искажает целевой символ
если взять срез fmt.Println(s[0:2]) // возвращается П — забираются первые 2 байта, которые представляют из себя код и код автоматически декодируется в понятный человеку символ.
Как работать с символами строк
Чтобы корректно работать с символами, нужно преобразовать строку в срез типа []rune.
Срез []rune представляет строку как последовательность Unicode-кодов символов.
s := “Привет”
runes := []rune(s)
fmt.Println(runes[0]) // 1055 (код символа П в Unicode)
fmt.Println(string(runes[0])) // каст кода П в строку
теперь каждый символ кириллицы правильно переведен в тип rune, что представляет код Unicode
Длина строки
Так как строки в Go представлены как последовательность байт, и их длина измеряется в байтах.
Если передать строку в функцию len(s), функция вернет размер строки в байтах.
Каждый отдельный английский символ (ASCII) занимает 1 байт памяти и размер строки в байтах включающий только ASCII символы будет равен длине строки.
Может возникнуть неточность, если строка состоит из символов другого языка или включает эмодзи, в этом случае размер строки будет превышать фактическую длину, так как символы других алфавитов занимают больше 1 байта пространства.
Для того чтобы получить количество символов (вместо байтов), можно использовать пакет unicode/utf8.
import “unicode/utf8”
s := “Это строка”
fmt.Println(len(s)) // 19
fmt.Println(utf8.RuneCountInString(s)) // 10
Еще один способ получить длину строки (количество символов) это сделать каст строки в срез с элементами типа rune.
s := “Это строка”
fmt.Println(len([]rune(s))) // 10
Эти два способа гарантированно вернут правильное количество символов в строке, даже если в ней содержатся символы разных алфавитов.
Литералы строк
Литерал — это фиксированное значение, напрямую указанное в исходном коде программы.
Литерал представляет собой синтаксическую конструкцию, которая интерпретируется компилятором или интерпретатором как экземпляр определённого типа данных.
С помощью литерала компилятор или интерпретатор понимает, с каким типом данных работает, анализируя его синтаксическое представление (например, кавычки для строк, числовой формат для целых и вещественных чисел, фигурные скобки для коллекций и т.д.).
Литерал строки — это текст в исходном коде программы.
Кавычки, которые окружают литерал строки, — это синтаксическая часть языка Go, они нужны для обозначения строки.
С помощью двойных кавычек, компилятор golang поймет, что он работает со строкой.
Если в значении строки требуются двойные кавычки (например, для цитаты), их нужно явно указать и экранировать в самом литерале строки.
Значение строки — это результат выполнения программы, отображаемый в терминале или другом выходном потоке, без включения кавычек.
Управляющие символы
Для форматирования строк и работы с особыми символами в Go используются управляющие символы.
Управляющие символы начинаются с обратного слеша (\), за которым следует другой символ, определяющий их действие.
Они используются для добавления специальных символов, которые невозможно напрямую ввести в строку, либо для экранирования тех символов, которые иначе воспринимались бы как часть синтаксиса.
Примеры управляющих символов в Go:
\n — перевод строки
\t — символ табуляции
\f — подача страницы
\\ — обратный слеш
\" — экранирование двойной кавычки
\' — экранирование одинарной кавычки
Многострочная печать
Размещение строк в нескольких рядах делает текст более понятным и упорядоченным, позволяет форматировать его как письмо или сохранить разрывы строк в стихотворении или тексте песни.
Для создания строк, отображаемых на нескольких рядах, их нужно заключить в обратные апострофы.
В строках, заключенных в обратные апострофы, не требуется экранировать символы. Например, символы \ или кавычки (") можно использовать без обратного слэша.
Такие строки называют "сырыми" (raw string literals), так как они сохраняют текст в его исходном виде без обработки управляющих символов.
text := `This is a
multi-line string.
It preserves line breaks and spaces.`
Конкатенация
Оператор + используется для соединения двух строк.
s1 := "Hello, "
s2 := "world!"
s3 := s1 + s2
fmt.Println(s3) // "Hello, world!"
Эта операция создаёт новую строку, которая является результатом соединения исходных строк.
Важно понимать, что строки в Go неизменяемы, поэтому при использовании операции + возвращается новое значение, а не изменяется одна из исходных строк.
Пакет strings
Встроенный пакет, который предоставляет функции для работы со строками в кодировке utf-8.
с полным набором функций можно ознакомиться в документации пакета, тут разберем некоторые
strings.Contains()
Эта функция проверяет, содержится ли подстрока в строке.
Возвращает true, если строка найдена, и false — если не найдена.
import "strings"
s := "hello world"
fmt.Println(strings.Contains(s, "world")) // true
fmt.Println(strings.Contains(s, "go")) // false
strings.ToUpper() и strings.ToLower()
Эти функции позволяют преобразовать строку в верхний или нижний регистр.
import "strings"
s := "Hello"
fmt.Println(strings.ToUpper(s)) // "HELLO"
fmt.Println(strings.ToLower(s)) // "hello"
strings.Trim()
Функция strings.Trim() позволяет удалить указанный вторым параметром символы с начала и конца строки.
import "strings"
s := " Hello, world! "
fmt.Println(strings.Trim(s, " ")) // Выведет "Hello, world!"
strings.TrimSpace()
Можно также использовать strings.TrimSpace(), чтобы удалить только пробелы.
strings.Split()
Функция strings.Split() разделяет строку на подстроки по заданному разделителю и возвращает срез строк.
import "strings"
s := "a b c d"
result := strings.Split(s, " ")
fmt.Println(result) // [a b c d]
strings.Join()
Функция strings.Join() объединяет срез строк в одну строку с заданным разделителем.
import "strings"
slice := []string{"a", "b", "c", "d"}
result := strings.Join(slice, "")
fmt.Println(result) // "abcd"
strings.Replace()
Эта функция позволяет заменить все или ограниченное количество вхождений подстроки в строке на другую строку.
import "strings"
s := "hello world"
result := strings.Replace(s, "world", "Go", -1)
fmt.Println(result) // "hello Go"
-1 все вхождения
range
range — это ключевое слово для перебора коллекций в цикле.
При каждом проходе цикла range возвращает два значения:
индекс начального байта символа строки
индекс элемента (массив или срез)
ключ при работе с картами
и затем соответствующее значение из коллекции.
Со строками ключевое слово range используется для итерации и извлечения каждого символа (rune) из строки.
Это позволяет корректно обрабатывать многобайтовые символы в строках.
s := "string"
for i, r := range s {
fmt.Printf("%d: %c\n", i, r)
}
В этом примере i — это начальный индекс байта в строке, а r — это сам символ (rune).
fmt.Sprintf()
Аналог fmt.Printf(), но результат сохраняется в строку, а не выводится в консоль.
str := fmt.Sprintf("Hello, %s!", "world")
fmt.Println(str)