❓ Что такое указатели (pointers) в Go

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

Определение и инициализация
Указатель создается с помощью символа * перед типом. Например, var x *int объявляет указатель на переменную типа int.
Для получения адреса переменной используется оператор &. Например, &y вернет указатель на переменную y.

➡️ Dereferencing (разыменование)
Чтобы получить значение переменной, на которую ссылается указатель, используется снова символ *. Если x — это указатель на переменную y, то *x вернет значение переменной y.

➡️ Nil указатели
Указатель может быть nil, что означает, что он не указывает на какую-либо область памяти. Попытка разыменовать nil указатель приведет к ошибке во время выполнения.

➡️ Указатели в функциях
Все параметры в Go по умолчанию передаются по значению. Чтобы изменять значения переменных в функции, необходимо передавать указатели.

➡️ Указатели на структуры
В Go часто используют указатели на структуры для оптимизации и изменения данных без копирования. Для доступа к полям структуры через указатель можно использовать . (точку), например, pointerToStruct.FieldName, без необходимости разыменовывать указатель.

➡️ Осторожность с указателями
Неправильное использование указателей может привести к ошибкам, таким как разыменование nil указателя или возникновение «висячих» указателей.

🐸 Библиотека Go для собеса

❓ Зачем и для чего нужен GOMAXPROCS в Go

GOMAXPROCS — это переменная окружения и функция в Go, которая ограничивает максимальное количество системных потоков, которые могут одновременно выполнять Go-код.

Как работает

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

Значение по умолчанию

По умолчанию GOMAXPROCS устанавливается равным числу доступных ядер процессора, что является оптимальным для большинства приложений.

Изменение GOMAXPROCS

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

Как это влияет на производительность

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

Инструмент от Uber — automaxprocs, который автоматически настраивает GOMAXPROCS в соответствии с квотой процессора в Linux-контейнерах.

🐸 Библиотека Go для собеса

❓ В каких случаях использовать указатели вместо копирования значений в Go

1️⃣ Работа с большими структурами или срезами
Передача указателей экономит память и улучшает производительность, избегая копирования больших объектов.

type LargeStruct struct {
    Field1 [1000]int
    Field2 [1000]int
}

func modify(s *LargeStruct) {
    s.Field1[0] = 42
}

func main() {
    ls := LargeStruct{}
    modify(&ls) // Передаем указатель, избегая копирования
}

2️⃣ Изменение значений внутри функции
Для изменения значения переменной в функции и отражения этих изменений за пределами функции необходимо использовать указатель.

func increment(x *int) {
    *x++
}

func main() {
    num := 10
    increment(&num) // Изменение переменной через указатель
    fmt.Println(num) // 11
}

3️⃣ Работа с nil-значениями и создание пустых объектов
Указатели позволяют работать с nil значениями, что полезно для создания пустых объектов или значений по умолчанию.

type User struct {
    Name string
}

func createUser() *User {
    return nil // Возвращаем nil, если пользователь не найден
}

func main() {
    user := createUser()
    if user == nil {
        fmt.Println("User not found")
    }
}

4️⃣ Управление памятью и взаимодействие с системными ресурсами
Указатели необходимы для работы с системными ресурсами или низкоуровневыми API, такими как через cgo.

/*
#include <stdlib.h>

void modify(int *x) {
    *x = 42;
}
*/
import "C"

func main() {
    var num int
    C.modify((*C.int)(&num)) // Используем указатель для передачи в C-функцию
    fmt.Println(num) // 42
}

5️⃣ Ссылки на изменяемые данные в горутинах
Указатели удобны для совместного использования данных в горутинах, но требуют синхронизации для предотвращения гонок.

func incrementCounter(counter *int) {
    *counter++
}

func main() {
    counter := 0
    go incrementCounter(&counter)
    fmt.Println(counter) // Возможно увеличение
}

🐸 Библиотека Go для собеса

❓ Какие функции включены в стандартную библиотеку Go и как они упрощают разработку

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

➡️ Основные инструменты Go:

go fmt — форматирует ваш код в соответствии с установленными стандартами Go. Это помогает поддерживать единый стиль в проекте, улучшая читаемость и уменьшая количество ошибок, связанных с форматированием.

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

go test — инструмент для запуска тестов. С его помощью можно легко проверить, что ваш код работает как ожидалось, и гарантировать его надежность.

go build — компилирует ваш исходный код и создает исполняемый файл. Это один из самых важных инструментов для перехода от кода к работающей программе.

go run — помогает быстро запустить программу Go без явной компиляции. Это удобный способ для быстрого прототипирования и тестирования кода.

go doc — позволяет получить документацию для пакетов и функций прямо из командной строки, что экономит время на поиске и упрощает понимание API.

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

go mod — управляет зависимостями в вашем проекте. Он упрощает работу с модулями и пакетами, позволяет обновлять их, следить за версиями и создавать чистую и стабильную среду для разработки.

🐸 Библиотека Go для собеса

❓ Какие способы ручного управления сборщиком мусора доступны в Go

В Go сборщик мусора (GC) автоматически управляет памятью, но бывают ситуации, когда нужно вмешаться и настроить его работу под свои нужды.

➡️ Управление сборщиком мусора

Принудительный запуск GC
Хотя сборщик мусора обычно работает автоматически, мы можем вручную запустить его с помощью функции runtime.GC(). Однако в большинстве случаев лучше оставить это на усмотрение Go.

Отключение и включение GC
Можно временно отключить сборщик мусора, установив debug.SetGCPercent(-1). Чтобы вернуть его в нормальный режим, используйте debug.SetGCPercent(100), где 100 — это значение по умолчанию.

➡️ Что такое GOGC

GOGC — это переменная окружения, которая регулирует частоту запуска сборщика мусора. Она определяет, сколько процентов от текущего объема памяти может быть выделено до следующего запуска GC.

GOGC = 100 (значение по умолчанию) означает, что сборка мусора произойдет, когда объем выделенной памяти увеличится на 100% по сравнению с предыдущей сборкой.
GOGC = 50 ускоряет сборку мусора, позволяя ей запускаться чаще — после 50% увеличения памяти.
GOGC = -1 отключает сборщик мусора.

➡️ Настройка GOGC

Вы можете установить значение GOGC перед запуском программы через команду:

GOGC = 50 ./your-program

Или изменить его внутри программы с помощью debug.SetGCPercent().

➡️ Влияние на производительность
Настройка частоты работы сборщика мусора напрямую влияет на производительность. Увеличение значения GOGC уменьшит частоту сборок мусора, но увеличит потребление памяти. Снижение GOGC заставит GC работать чаще, что может снизить потребление памяти, но повысит нагрузку на процессор.

❕Важно помнить: правильная настройка сборщика мусора может существенно повлиять на производительность вашего приложения. Иногда стоит поэкспериментировать с параметрами GOGC для достижения оптимального баланса между использованием памяти и процессорным временем.

🐸 Библиотека Go для собеса

❓ Какие переменные окружения в Go наиболее важны

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

➖ Ниже список наиболее часто используемых переменных окружения:

GOEXPERIMENTAL: Включает или отключает экспериментальные возможности компилятора.
GOARCH: Определяет архитектуру целевой системы (например, amd64, arm).
GOBIN: Указывает директорию, в которую будут установлены скомпилированные исполняемые файлы при использовании go install.
GOEXE: Устанавливает расширение для исполняемых файлов в зависимости от операционной системы.
GOFLAGS: Устанавливает флаги по умолчанию для всех команд Go.
GOOS: Определяет операционную систему для сборки (например, linux, darwin).
GOPATH: Указывает расположение рабочего окружения Go.
GOPROXY: Устанавливает URL прокси-сервера для скачивания Go-модулей.
GOROOT: Указывает путь к месту хранения бинарных файлов Go и исходных кодов.
GOSUMDB: Настроивает базу данных контрольных сумм для модулей и, если необходимо, открытый ключ и URL.
GOTMPDIR: Определяет директорию для хранения временных файлов во время сборки.
GOVCS: Настроит разрешенные системы контроля версий для определенных модулей.
GO111MODULE: Управляет режимом работы модулей (например, включение или выключение поддержки Go-модулей).

🐸 Библиотека Go для собеса

❓ Есть ли в Go механизм для автоматического переключения контекста между горутинами

Планировщик Go автоматически управляет переключением контекста между горутинами, чтобы они могли эффективно выполняться на доступных системных потоках. Однако, если вы хотите «подсказать» планировщику, когда нужно приостановить текущую горутину в пользу другой, можно использовать функцию runtime.Gosched().

Предположим, у нас есть две горутины: одна выполняет сложные вычисления, а другая просто выводит текст. Если горутина с вычислениями вызывает runtime.Gosched(), планировщик может переключиться на горутину, которая выводит текст, давая ей шанс быстрее завершить свою работу.

Пример:

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Вычисления:", i)
            runtime.Gosched()  // Подсказка планировщику для переключения
        }
    }()

    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Печать текста:", i)
            time.Sleep(10 * time.Millisecond)
        }
    }()

    time.Sleep(1 * time.Second)
}

➡️ Работа планировщика
Горутины планируются и выполняются в порядке их готовности (FIFO). Исполнение горутины может быть прервано, если она блокируется, например, при системном вызове или при использовании синхронизирующих объектов. Однако горутины не имеют квантов времени — они не возвращаются в очередь автоматически. Для этого нужно вручную вызвать runtime.Gosched().

➡️ Иногда стоит использовать runtime.Gosched(), чтобы долгоживущие горутины не задерживали выполнение других горутин. Это позволяет улучшить отклик приложения, особенно в случае, когда требуется выполнить несколько задач параллельно, и важно избежать блокировки.

🐸 Библиотека Go для собеса

❓ Какие задачи можно решить с помощью конструкции ‘…’ в Go

Синтаксическая конструкция ‘…’ в Go используется в нескольких контекстах, в частности для:

1️⃣Определение функции с переменным количеством аргументов (вариативная функция)
Она позволяет функции принимать неопределенное количество аргументов одного типа.
Синтаксис: параметр функции определяется с использованием ... перед типом.

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

2️⃣Передача среза как отдельных аргументов функции
Когда вы хотите передать все элементы среза как отдельные аргументы функции, используется ... .
Синтаксис: при вызове функции с срезом используется ... после имени среза.

nums := []int{1, 2, 3, 4}
fmt.Println(sum(nums...)) // Вывод: 10

3️⃣Определение массивов с неизвестной заранее длиной
Когда необходимо создать массив, длина которого будет определена на основе количества элементов.
Синтаксис: при инициализации массива используется ... вместо явного указания длины.

x := [...]int{1, 2, 3}// Go определит длину массива автоматически

🐸 Библиотека Go для собеса

❓ Какие особенности связаны с неиспользуемыми переменными и импортами в Go

1️⃣Неиспользуемая локальная переменная

• Если вы объявляете локальную переменную, но не используете её в коде, это приведет к ошибке компиляции.

package main

import "fmt"

func main() {
    x := 10
    fmt.Println("Hello, World!")
}

Компилятор выдаст ошибку: x declared but not used

2️⃣Неиспользуемое возвращаемое значение

• Если функция возвращает значение, и вы его не используете, компиляция не вызовет ошибку.
• Однако, если вы присваиваете возвращаемое значение переменной, но не используете эту переменную, компилятор сообщит о проблеме.

package main

import "errors"

func doSomething() (int, error) {
    return 42, errors.New("an error occurred")
}

func main() {
    doSomething() // Это допустимо
    result, err := doSomething() // 
}

Это вызовет ошибку, так как result и err не используются

3️⃣Неиспользуемый импорт

• Когда вы импортируете пакет, но не используете его, компилятор также выдаст ошибку.

package main

import "math"

func main() {
    // Ничего не делаем
}

Компилятор выдаст ошибку: "math" imported and not used.

❕Исключения

• Это правило не касается неиспользуемых параметров функций или глобальных переменных. Они могут быть не использованы, но код всё равно скомпилируется.

package main

import "fmt"

var globalVar int

func greet(name string, age int) {
    fmt.Println("Hello,", name)
}

func main() {
    greet("Alice", 25)
    fmt.Println("Hello, World!")
}

Глобальная переменная globalVar не используется, но код скомпилируется без ошибок.

🐸 Библиотека Go для собеса

❓ Что такое обратный индекс и где его используют

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

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

Пример структуры данных для обратного индекса в Go:

package main

import "fmt"

type InvertedIndex map[string][]int

func addToIndex(index InvertedIndex, term string, docID int) {
    index[term] = append(index[term], docID)
}

func main() {
    index := make(InvertedIndex)

    // Добавление в индекс
    addToIndex(index, "hello", 1)
    addToIndex(index, "world", 1)
    addToIndex(index, "go", 2)

    // Печать результата
    fmt.Println(index)
}

В этом примере создается обратный индекс, где слово «hello» встречается в документе 1, «world» — в документе 1, а «go» — в документе 2.

🐸 Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

Добейте 7 бустов, плиз, иначе вопросов с собесов не будет 🚬

❓ Что такое паттерн «Декоратор» и как его реализовать

Декоратор — это способ добавить новую логику к объекту, не меняя его код. В Go это удобно делать через интерфейсы. Один объект «оборачивает» другой и выполняет дополнительную работу до или после вызова.

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

Простой пример: логирование вызова метода

type Handler interface {
    Handle(msg string) string
}

type SimpleHandler struct{}

func (h SimpleHandler) Handle(msg string) string {
    return "Handled: " + msg
}

Теперь сделаем обёртку:

type LoggingHandler struct {
    next Handler
}

func (l LoggingHandler) Handle(msg string) string {
    fmt.Println("Запрос:", msg)
    result := l.next.Handle(msg)
    fmt.Println("Ответ:", result)
    return result
}

Использование:

func main() {
    base := SimpleHandler{}
    withLog := LoggingHandler{next: base}

    fmt.Println(withLog.Handle("тест"))
}

🐸 Библиотека Go для собеса

❓ В чем особенность неиспользуемых переменных и импортов в Go

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

➡️ Если в коде есть неиспользуемая локальная переменная, такой код не скомпилируется.

package main

import "fmt"

func main() {
    x := 10
    fmt.Println("Hello, World!")
}

Компилятор выдаст ошибку: x declared but not used

➡️ Если функция возвращает значения, но значения не используются, компилятор не выдаст ошибку.
Однако если значения присваиваются переменным, которые затем не используются, это вызовет ошибку компиляции.

package main

import "errors"

func doSomething() (int, error) {
    return 42, errors.New("an error occurred")
}

func main() {
    doSomething()  // Это допустимо
    result, err := doSomething()  // Ошибка, так как result и err не используются
}

➡️ Если в коде присутствует импорт, который не используется, компилятор выдаст ошибку: "math" imported and not used

package main

import "math"  // Ошибка, импорт не используется

func main() {
    // Ничего не делаем
}

❕Правило не касается неиспользуемых параметров функций и глобальных переменных. Код скомпилируется:

package main

import "fmt"

var globalVar int  // Глобальная переменная, которая не используется

func greet(name string, age int) {  // Параметры функции также могут не использоваться
    fmt.Println("Hello,", name)
}

func main() {
    greet("Alice", 25)  // Параметры функции 'name' и 'age' не используются
    fmt.Println("Hello, World!")
}

🐸 Библиотека Go для собеса

❓ Если вы зашьёте в код приватный токен и скомпилируете код — можно ли будет извлечь токен

Когда вы компилируете исходный код в бинарный файл, все данные, включая строки, токены, конфигурации, остаются в самом бинарном файле.

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

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

Так что да, токен можно будет прочитать.

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

• В переменных окружения.

• В защищённых хранилищах секретов, например, HashiCorp Vault, AWS Secrets Manager, Azure Key Vault.

• Шифрованных конфигурационных файлах.

🐸 Библиотека Go для собеса

❓ Как создать простой веб-сервер на Go с использованием стандартной библиотеки

Базовый пример:

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    http.ListenAndServe(":8080", nil)
}

1️⃣ Подключаем fmt для форматированного вывода и net/http для работы с HTTP.

2️⃣ Обработчик запросов: функция helloHandler отвечает на все запросы сообщением "Hello, World!".

3️⃣ С помощью http.HandleFunc регистрируем обработчик на корневой эндпоинт ("/hello").

4️⃣ http.ListenAndServe(":8080", nil) запускает сервер на порту 8080.

➡️ После запуска кода при переходе по адресу https://localhost:8080/hello вы получите ответ: "Hello, World!"

Также можно использовать http.FileServer:

package main

import "net/http"

func main() {
    port := ":8080"
    handler := http.FileServer(http.Dir("."))
    http.ListenAndServe(port, handler)
}

Аналог python -m http.server — раздаёт текущую директорию по HTTP.

🐸 Библиотека Go для собеса

❓ Чем является rune в Go и как он связан с символами Unicode

Работа со строками в Go не ограничивается ASCII-символами, в текстах часто встречаются символы других языков и эмодзи. Для корректной обработки таких символов используется тип rune.

rune — это псевдоним для int32, предназначенный для хранения Unicode-кода одного символа.

При переборе строки с помощью конструкции for range, Go обходит строку по символам Unicode, автоматически преобразуя её в последовательность rune.

Примеры:

• Объявление и инициализация руны:

var r rune = 'A'

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

s := "Привет"
runes := []rune(s)

• Итерация по рунам в строке:

for _, r := range "Привет" {
    fmt.Printf("%c ", r)
}
// Вывод: П р и в е т 

• Обратное преобразование среза рун в строку:

runes := []rune{'П', 'р', 'и', 'в', 'е', 'т'}
s := string(runes) // "Привет"

• Получение Unicode-кода руны:

r := 'A'
code := int32(r) // 65

• Проверка длины строки в рунах:

s := "Привет"
length := utf8.RuneCountInString(s) // 6

🐸 Библиотека Go для собеса

❓ Как Go реализует обработку ошибок

1️⃣ Явная обработка — в Go нет исключений.
Функции, которые могут завершиться с ошибкой, возвращают её как отдельное значение наряду с результатом.

2️⃣ Множественные возвращаемые значения — стандартный шаблон:

val, err := someFunction()
if err != nil {
    // обработка ошибки
}

3️⃣ Кастомные ошибки — через пакет errors можно определять собственные типы ошибок и добавлять к ним полезную информацию.

4️⃣ Обогащение контекста — с Go 1.13 доступны errors.Is, errors.As и fmt.Errorf(... %w ...) для оборачивания ошибок с сохранением исходной причины.

func DoSomething() error {
    if err := someOperation(); err != nil {
        return fmt.Errorf("someOperation failed: %w", err)
    }
    return nil
}

5️⃣ Нет finally — очистка ресурсов выполняется через defer.

6️⃣ Panic и recover — используются только для критических непредвиденных ситуаций, например выхода за границы массива.

🐸 Библиотека Go для собеса

❓ Расскажите о механизме мьютексов в Go и укажите существующие типы

Mutex (mutual exclusion — взаимное исключение) — примитив синхронизации для защиты критической секции программы. Он предотвращает гонки данных и deadlock’и, обеспечивая эксклюзивный доступ к ресурсу.

Критическая секция — участок кода, где одновременно может работать только одна горутина.

➡️ sync.Mutex — эксклюзивная блокировка
Только одна горутина может захватить мьютекс и получить доступ к ресурсу.

var mu sync.Mutex

func increment() {
    mu.Lock()
    count++
    mu.Unlock()
}

Здесь мы рассматриваем защиту глобальной переменной count при инкременте из множества горутин.

➡️ sync.RWMutex — концептуально то же самое, что и Mutex, но дает вам немного больше контроля над памятью.
Позволяет:
RLock — множеству горутин читать одновременно.
Lock — только одному писателю, без читателей.

var mu sync.RWMutex

func set(key, value string) {
    mu.Lock()
    cache[key] = value
    mu.Unlock()
}

func get(key string) string {
    mu.RLock()
    defer mu.RUnlock()
    return cache[key]
}

Дает безопасный доступ к кэшу — много читателей, один писатель.

🐸 Библиотека Go для собеса

❓ Что собой представляет «затенение» переменной (shadowing) в Go

➖ В Go «затенение» (shadowing) происходит, когда переменная, объявленная в локальной области видимости, имеет такое же имя, как и переменная во внешней области видимости. Внутренняя переменная «затеняет» внешнюю, делая её недоступной.

package main

import (
    "fmt"
)

func main() {
    x := 10
    
    if true {
        x := 5 // затенение внешней переменной x
        fmt.Println(x) // выводит 5
    }

    fmt.Println(x) // выводит 10
}

➖ «Затенение» может быть особенно запутывающим, когда оно касается переменных, полученных из результатов функций, таких как err. Пример часто встречающегося кода в Go:

value, err := someFunction()
if err != nil {
    // обработка ошибки
}

// ...

value2, err := anotherFunction() // новое затенение переменной err
if err != nil {
    // обработка ошибки
}

Если использовать := вместо =, вы создадите новую переменную err, которая «затенит» переменную err из внешней области видимости. Это может привести к неправильной обработке ошибок, так как внешняя ошибка будет проигнорирована.

❕Обнаружение затенения:

1. go vet -shadow ./...
2. golangci-lint run --enable shadow
3. Использование инструмента shadow:

$ go get -u golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
$ go vet -vettool=$(which shadow)

🐸 Библиотека Go для собеса

❓ Как минимизировать использование памяти в Go при работе с большими структурами данных

➡️ Избегайте глобальных переменных, они остаются в памяти на весь срок работы программы.

➡️ Выбирайте правильные типы данных используйте int8, int16 вместо int, если диапазон позволяет.

➡️ Используйте sync.Pool для повторного использования часто создаваемых объектов.

➡️ Ленивая инициализация, инициализируйте данные только по мере необходимости.

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

➡️ Срезы против массивов — используйте массивы, если размер данных известен заранее.

➡️ Освобождение ресурсов, присваивайте nil неиспользуемым структурам.

➡️ Используйте буферизацию, она снижает количество выделений памяти.

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

🐸 Библиотека Go для собеса