Строки

Что из себя представляет тип данных `string` в языке Go?

string — это неизменяемая последовательность байтов, которая используется для представления текста.

Основные характеристики:

Неизменяемость:
- Строки в Go неизменяемы; однажды созданные, их содержимое не может быть изменено.
Представление:
- Строки представляют собой последовательность байтов, что позволяет хранить текст в формате UTF-8.
- Каждый элемент строки — это байт (тип byte).
Создание и инициализация:
- Строки можно создавать с использованием строковых литералов, заключенных в двойные кавычки.
- Пример:
```
var s string = "Hello, Go!"
```
Длина:
- Длину строки можно получить с помощью функции len.
- Пример:
```
length := len(s)  // Возвращает количество байтов в строке
```
Конкатенация:
- Строки можно объединять с помощью оператора +.
- Пример:
```
s1 := "Hello, "
s2 := "Go!"
result := s1 + s2  // "Hello, Go!"
```

Можно ли изменить определенный символ в строке?

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

Пример:

Преобразование строки в слайс рун:

s := "hello"
runes := []rune(s)
runes[0] = 'H'
newStr := string(runes)
fmt.Println(newStr)  // Вывод: Hello

Преобразование строки в слайс байтов (если работаешь с ASCII):

s := "hello"
bytes := []byte(s)
bytes[0] = 'H'
newStr := string(bytes)
fmt.Println(newStr)  // Вывод: Hello

Таким образом, для изменения символа в строке в Go нужно преобразовать строку в изменяемую структуру данных (слайс рун или байтов), внести изменения и создать новую строку.

Что происходит при склеивании строк?

При склеивании (конкатенации) строк в Go создается новая строка, содержащая последовательность байтов из всех исходных строк. Исходные строки остаются неизменными.

Пример:

s1 := "Hello, "
s2 := "Go!"
result := s1 + s2
fmt.Println(result)  // Вывод: Hello, Go!

Процесс:

Выделение памяти: Выделяется новая память для хранения объединенной строки.
Копирование байтов: Байты из всех исходных строк копируются в новый выделенный участок памяти.
Создание новой строки: Формируется новая строка, представляющая результат конкатенации.

Особенности:

Неизменяемость: Исходные строки не изменяются.
Новая память: Каждая операция конкатенации создает новую строку, что может влиять на производительность при частых операциях склеивания.

Как можно оперировать строками?

Операции со строками в Go:

Конкатенация:

Объединение строк с помощью оператора +.

s1 := "Hello, "
s2 := "Go!"
result := s1 + s2
fmt.Println(result)  // Вывод: Hello, Go!

Длина строки:
- Получение длины строки с помощью функции len.
```
s := "Hello"
length := len(s)
fmt.Println(length)  // Вывод: 5
```
Доступ к символам:
- Доступ к символам строки через индексацию (возвращает байт).
```
s := "Hello"
firstChar := s[0]
fmt.Printf("%c\\n", firstChar)  // Вывод: H
```
Срезы строк:
- Извлечение подстрок с помощью срезов.
```
s := "Hello, Go!"
substr := s[7:]
fmt.Println(substr)  // Вывод: Go!
```
Преобразование строки в слайс рун:
- Для работы с символами Unicode.
```
s := "Hello, 世界"
runes := []rune(s)
fmt.Println(string(runes))  // Вывод: Hello, 世界
```
Сравнение строк:
- Использование операторов == и != для сравнения строк.
```
s1 := "Hello"
s2 := "World"
fmt.Println(s1 == s2)  // Вывод: false
```

Поиск подстроки:

Использование функций из пакета strings.

import "strings"
s := "Hello, Go!"
contains := strings.Contains(s, "Go")
fmt.Println(contains)  // Вывод: true

Что будет если сложить строки?

При сложении (конкатенации) строк в Go создается новая строка, содержащая последовательность байтов из всех исходных строк. Исходные строки остаются неизменными.

Пример:

s1 := "Hello, "
s2 := "Go!"
result := s1 + s2
fmt.Println(result)  // Вывод: Hello, Go!

Что происходит:

Выделение памяти: Выделяется новая память для хранения объединенной строки.
Копирование байтов: Байты из всех исходных строк копируются в новый участок памяти.
Создание новой строки: Формируется новая строка, представляющая результат конкатенации.

Как определить количество символов для строки?

Сначала уточните единицу подсчета: len(s) считает байты, len([]rune(s)) или utf8.RuneCountInString(s) — кодовые точки. Один видимый символ (графема), например эмодзи с модификатором, может состоять из нескольких кодовых точек.

Пример:

s := "Hello, hi"
runes := []rune(s)
length := len(runes)
fmt.Println(length)  // Вывод: 9

Объяснение:

len(s): Возвращает количество байтов в строке (не подходит для символов Unicode).
[]rune(s): декодирует UTF-8 в кодовые точки. Некорректные последовательности заменяются на U+FFFD; одна руна не всегда равна одному видимому символу.
len(runes): возвращает число кодовых точек после декодирования.

Какие есть нюансы при итерации по строке?

Нюансы при итерации по строке в Go:

Итерация по байтам:
- Используя индекс, можно итерировать по байтам строки.
- Пример:
```
s := "Hello, hi"
for i := 0; i < len(s); i++ {
    fmt.Printf("%c ", s[i])
}
// Вывод: H e l l o ,   hi
```
Итерация по рунам:
- Используя цикл range, можно итерировать по рунам (символам Unicode).
- Пример:
```
s := "Hello, hi"
for _, r := range s {
    fmt.Printf("%c ", r)
}
// Вывод: H e l l o ,   hi
```
Индексы в цикле range:
- Цикл range возвращает индекс в байтах, а не в символах.
- Пример:
```
s := "Hello, 世界"
for i, r := range s {
    fmt.Printf("Index: %d, Rune: %c\\n", i, r)
}
```

Как эффективно склеивать строки (конкатенация строк)?

Для эффективной конкатенации строк используйте пакет strings и тип strings.Builder.

Пример:

import (
    "strings"
    "fmt"
)

func main() {
    var sb strings.Builder

    sb.WriteString("Hello, ")
    sb.WriteString("World")
    sb.WriteString("!")

    result := sb.String()
    fmt.Println(result)  // Вывод: Hello, World!
}

Почему использовать `strings.Builder`:

Эффективность: Минимизирует количество выделений памяти и копирований при конкатенации.
Простота: Предоставляет удобные методы для построения строки.