Знакомство с пакетом Strings в Go

Введение

Пакет strings в Go позволяет использовать ряд функций для работы со строковым типом данных. Эти функции позволяют нам легко изменять строки и совершать с ними другие манипуляции. Функции можно сравнить с определенными действиями, которые мы совершаем с элементами нашего кода. Встроенные функции — это функции, которые определены в языке программирования Go и доступны для использования без каких-либо сложностей.

В этом обучающем руководстве мы рассмотрим несколько различных функций, которые мы можем использовать для работы со строками в Go.

Перевод строк в верхний и нижний регистр

Функции strings.ToUpper и strings.ToLower будут возвращать строку со всеми символами оригинальной строки, переведенными в верхний или нижний регистр. Поскольку строки — это неизменяемый тип данных, возвращенная строка будет представлять собой новую строку. Любые символы в строке, которые не являются буквам, останутся неизменными.

Для преобразования строки "Sammy Shark"в верхний регистр, используйте функцию strings.ToUpper:

ss := "Sammy Shark"
fmt.Println(strings.ToUpper(ss))

Output
SAMMY SHARK

Для преобразования строки в нижний регистр используйте следующий код:

fmt.Println(strings.ToLower(ss))

Output
sammy shark

Поскольку вы используете пакет strings, вам нужно предварительно импортировать его в программу. Программа для преобразования строки в строку с символами в верхнем и нижнем регистре будет выглядеть следующим образом:

package main

import (
	"fmt"
	"strings"
)

func main() {
	ss := "Sammy Shark"
	fmt.Println(strings.ToUpper(ss))
	fmt.Println(strings.ToLower(ss))
}

Функции strings.ToUpper и strings.ToLower упрощают оценку и сравнение строк, обеспечивая единообразие их регистра. Например, если пользователь пишет свое имя в нижнем регистре, мы все равно сможем определить, содержится ли его имя в нашей базе данных, проверив версию строки в верхнем регистре.

Функции поиска строки

Пакет strings имеет ряд функций, которые помогают определить, содержит ли строка конкретную последовательность символов.

Функции strings.HasPrefix и strings.HasSuffix позволяют проверить, начинается строка с определенного набора символов или заканчивается ли строка определенным набором символов.

Например, чтобы проверить, начинается ли строка "Sammy Shark" с Sammy и заканчивается ли она словом Shark:

ss := "Sammy Shark"
fmt.Println(strings.HasPrefix(ss, "Sammy"))
fmt.Println(strings.HasSuffix(ss, "Shark"))

Output
true
true

Вы можете использовать функцию strings.Contains для проверки того, содержит ли строка "Sammy Shark" последовательность символов Sh:

fmt.Println(strings.Contains(ss, "Sh"))

Output
true

Наконец, чтобы узнать, сколько раз символ S появляется в выражении Sammy Shark:

fmt.Println(strings.Count(ss, "S"))

Output
2

Использование символа s в нижнем регистре для подсчета количества появлений в строке Sammy Shark не дает тот же результат, что и использование символа S в верхнем регистре:

fmt.Println(strings.Count(ss, "s"))

Output
0

Так как S отличается от s, функция будет возвращать значение 0.

Функции для работы со строками оказываются полезны, когда вы хотите сопоставить строки или выполнить поиск строк в вашей программе.

Определение длины строки

Встроенная функция len()​​​ возвращает количество символов в строке. Эта функция полезна, когда вам нужно установить минимальную или максимальную длину пароля или установить определенный лимит для больших строк для использования сокращений.

Для демонстрации работы этой функции мы определим длину строки, которая содержит целое предложение:

import (
	"fmt"
	"strings"
)

func main() {
        openSource := "Sammy contributes to open source."
        fmt.Println(len(openSource))
}

Output
33

Мы задали переменную OpenSource, которая соответствует строке "Sammy contributes to open source.", а затем передали эту переменную в функцию len() с помощью конструкции len(openSource). В конечном итоге мы передали вывод нашей функции в функцию fmt.Println(), чтобы увидеть результат выполнения программы на экране.

Необходимо учитывать, что функция len() будет считать любые символы, которые содержатся внутри двойных кавычек, включая буквы, числа, символы пробела и специальные символы.

Функции для манипуляций со строками

Функции strings.Join, strings.Split и strings.ReplaceAll предоставляют ряд дополнительных методов манипуляций со строками в Go.

Функция strings.Join полезна для объединения набора строк в новую единую строку.

Для создания разделенной запятой строки из набора строк мы будем использовать эту функцию следующим образом:

fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))

Output
sharks,crustaceans,plankton

Если мы хотим добавлять запятую и пробел между значениями строк в нашей новой строке, мы можем просто перезаписать наше выражение с пробелом после запятой: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ")​​.

Так же, как мы можем объединять строки, мы можем и разбивать строки на несколько отдельных строк. Для этого мы можем использовать функцию strings.Split и выполнить разделение строки по пробелам:

balloon := "Sammy has a balloon."
s := strings.Split(balloon, " ")
fmt.Println(s)

Output
[Sammy has a balloon]

В результате мы получим набор строк. Поскольку мы использовали strings.Println, очень трудно сказать, какой мы получили результат, посмотрев на вывод. Чтобы убедиться, что мы получили набор строк, используйте функцию fmt.Printf с оператором %q, чтобы вывести строки:

fmt.Printf("%q", s)

Output
["Sammy" "has" "a" "balloon."]

Еще одной полезной функцией, помимо strings.Split, является функция strings.Fields. Разница между этими функциями состоит в том, что strings.Fields будет игнорировать все пробелы и разделять строку по реальным полям в строке:

data := "  username password     email  date"
fields := strings.Fields(data)
fmt.Printf("%q", fields)

Output
["username" "password" "email" "date"]

Функция strings.ReplaceAll получает оригинальную строку и возвращает обновленную строку с определенными изменениями.

Давайте представим, что Sammy потерял свой шарик. Поскольку у Sammy больше нет шарика, мы изменим подстроку "has" (есть) оригинальной строки ballon на "had" (был) в новой строке:

fmt.Println(strings.ReplaceAll(balloon, "has", "had"))

В скобках первым параметром указан balloon, переменная, которая хранит оригинальную строку; далее идет подстрока "has", которую мы хотим заменить, а третьим параметром идет "had", подстрока, которую мы хотим вставить в оригинальную строку. Наш вывод будет выглядеть следующим образом, когда мы добавим этот код в программу:

Output
Sammy had a balloon.

Использование функций strings.Join, strings.Split и strings.ReplaceAll позволяет получить дополнительные возможности для манипуляций со строками в Go.

Заключение

В этом обучающем руководстве мы изучили ряд стандартных функций пакета string для строковых данных, которые вы можете использовать для работы со строками в ваших программах Go.

Дополнительную информацию о других типах данных вы можете получить в статье Знакомство с типами данных, а узнать больше о строках можно из руководства Начало работы со строками.