Начало работы со строками в Go

Строка — это последовательность из одного или нескольких символов (буквы, числа, символы), которая может представлять собой константу или переменную. Строки составляются из символов Unicode и являются неизменяемыми последовательностями, т. е. порядок этой последовательности нельзя изменить.

Поскольку текст является широко распространенным типом данных, который мы используем каждый день, строковый тип данных имеет очень важное значение в программировании.

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

Строковые литералы

В Go строки добавляются либо внутри обратных кавычек ` (иногда их называют еще обратными метками) или внутри двойных кавычек ". В зависимости от того, какие кавычки вы использовать, строка будет иметь различные характеристики.

При использовании обратных кавычек, например, ` ```bar``` `, будет создаваться необработанный строковый литерал. В необработанном строковом литерале любой символ может появляться между кавычками, за исключением обратных кавычек. Ниже представлен пример необработанного строкового литерала:

`Say "hello" to Go!`

Обратный слеш не имеет специального значения внутри необработанных строковых литералов. Например, символ \n будет отображаться в виде обычных символов, обратного слеша \ и буквы n. В отличие от интерпретируемых строковых литералов, где \n будет добавлять перенос на новую строчку.

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

`Go is expressive, concise, clean, and efficient.
Its concurrency mechanisms make it easy to write programs
that get the most out of multi-core and networked machines,
while its novel type system enables flexible and modular
program construction. Go compiles quickly to machine code
yet has the convenience of garbage collection and the power
of run-time reflection. It's a fast, statically typed,
compiled language that feels like a dynamically typed,
interpreted language.`

Интерпретируемые строковые литералы — это последовательность символов внутри двойных кавычек, например, "bar". Внутри кавычек отображается любой символ, за исключением символа переноса строки и неэкранированных двойных кавычек.

"Say \"hello\" to Go!"

Практически всегда вы будете использовать интерпретируемые строковые литералы, поскольку они позволяют выполнять экранирование символов внутри строк.

Теперь, когда вы знаете, как выполняется форматирование строк в Go, давайте посмотрим, как вы можете выводить строки на экран в своих программах.

Вывод строк на экран

Вы можете вывести на экран строки с помощью пакета fmt из системной библиотеки и вызова функции Println():

fmt.Println("Let's print out this string.")

Output
Let's print out this string.

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

package main

import "fmt"

func main() {
	fmt.Println("Let's print out this string.")
}

Конкатенация строк

Конкатенация — это объединение строк для получения новой строки. Для выполнения конкатенации строк воспользуйтесь оператором +. Необходимо учитывать, что при работе с числами оператор + будет выполнять сложение, а при работе со строками будет выполняться конкатенация.

Давайте объединим строковые литералы "Sammy" и "Shark" с помощью выражения fmt.Println():

fmt.Println("Sammy" + "Shark")

Output
SammyShark

Если вам нужно поместить пробелы между двумя строками, вы можете просто включить в строку пробел. В этом примере пробел добавлен внутри кавычек после слова Sammy:

fmt.Println("Sammy " + "Shark")

Output
Sammy Shark

Оператор + не может использоваться для работы с двумя разными типами данных. Например, вы не сможете выполнить сложение строк и чисел. Если вы попытаетесь выполнить следующее:

fmt.Println("Sammy" + 27)

Вы получите следующие ошибки:

Output
cannot convert "Sammy" (type untyped string) to type int
invalid operation: "Sammy" + 27 (mismatched types string and int)

Если вы хотите создать строку "Sammy27", вы можете поместить число 27 в кавычки ("27"), в результате чего оно больше не будет числом, а превратится в строку. Преобразование чисел в строки для выполнения конкатенации может быть полезным при работе с почтовыми индексами или телефонными номерами. Например, вы не хотите выполнять сложение кода страны и кода города, а хотите поместить их рядом.

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

Хранение строк в переменных

Переменные — это символы, которые вы можете использовать для хранения данных в программе. Их можно сравнить с пустой коробкой, в которую вы помещаете данные или значение. Строки — это данные, а значит вы можете использовать их для заполнения переменной. Объявление строк в качестве переменных упрощает работу со строками в ваших программах Go.

Чтобы сохранить строку внутри переменной, нужно просто назначить переменную для строки. В нашем случае мы объявим s как переменную:

s := "Sammy likes declaring strings."

Теперь, когда у вас есть переменная s для нашей конкретной строки, вы можете вывести значение переменной на экран следующим образом:

fmt.Println(s)

Вы получите следующий вывод:

Output
Sammy likes declaring strings.

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

Заключение

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