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

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

➡️ Модель M:N — в Go используется модель M:N, при которой M горутин могут быть назначены на N потоках ОС. Это позволяет создавать тысячи горутин с минимальными накладными расходами, связанными с управлением реальными потоками операционной системы.

➡️ G, M и P:
• G (goroutine) — горутина, выполняющаяся в рамках Go-программы
• M (machine thread) — поток ОС, который выполняет горутины
• P (processor) — контекст выполнения, который управляет очередью горутин и другими необходимыми данными. Обычно количество P соответствует числу ядер процессора.

➡️ Работа планировщика — во время выполнения горутины, она захватывает P и привязывается к M. Если горутина блокируется (например, из-за ожидания ввода/вывода), P освобождается и может быть назначен другой горутине, которая готова к выполнению.

➡️ Адаптация под нагрузку — планировщик динамически увеличивает или уменьшает количество потоков ОС (M) в зависимости от текущей нагрузки и блокировок.

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

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

❓ Что представляют собой дженерики в языке Go и в чем их преимущества

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

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

➡️ Преимущества:

• Уменьшение дублирования кода с помощью дженериков можно создать одну функцию или структуру, которая будет работать с любыми типами данных.

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

• Увеличение производительности, избавление от преобразования типов позволяет улучшить скорость выполнения.

➡️ До дженериков

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

func MinInts(arr []int) int { /*...*/ }
func MinFloats(arr []float64) float64 { /*...*/ }

➡️ С дженериками

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

func Min[T comparable](arr []T) T { /*...*/ }

Здесь T — это параметр типа, а comparable указывает, что тип должен поддерживать операцию сравнения.

➡️ Пример с обобщенной структурой данных

Допустим, вам нужно создать структуру данных типа очередь (Queue).

Без дженериков:

type Queue struct {
    data []interface{}
}

Использование interface{} требует преобразования типов, что снижает производительность.

С дженериками:

type Queue[T any] struct {
    data []T
}

Здесь T может быть любым типом, и нет необходимости в преобразованиях.

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

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

❓ В чем заключается принцип работы Escape analysis в Go

Escape analysis — это техника компилятора Go, предназначенная для определения оптимального местоположения переменных: в стеке или в куче. Этот процесс критичен для повышения производительности программы и эффективного использования памяти.

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

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

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

➡️ Переменная остается в рамках функции (стек):

func sum(a, b int) int {
    result := a + b 
    return result
}

В данном случае переменная result остается в области видимости функции, поэтому она будет размещена на стеке.

➡️ Переменная выходит за пределы функции (куча):

func newInt() *int {
    result := 42 
    return &result
}

Здесь переменная result выходит за пределы функции, потому что возвращается указатель на неё. Поэтому она будет размещена в куче.

➡️ Переменная сохраняется в глобальной переменной (куча):

var globalVar *int

func setGlobalVar() {
    x := 100  
    globalVar = &x
}

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

Escape analysis помогает управлять памятью, решая, где лучше хранить переменные — в стеке или в куче.

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

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

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

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

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

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

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

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

➡️ Иерархия файловой системы как пример
Представим, что мы строим структуру файловой системы, которая состоит из директорий, содержащих как файлы, так и другие директории. Такая система может быть многоуровневой, где каждая директория может включать в себя другие элементы (файлы и подкаталоги).

Чтобы реализовать этот паттерн, мы будем использовать интерфейс Element, который будет представлять как файлы, так и директории. Каждая структура должна реализовывать два метода:
1. display — для отображения информации о текущем элементе.
2. clone — для создания копии элемента.

➡️ Пример 1: Файл (Document)
Файл в нашей файловой системе может быть представлен типом Document. Он имеет имя (например, Doc1), и когда мы хотим его клонировать, мы добавляем к имени суффикс "_copy" (например, Doc1_copy).

➡️ Пример 2: Директория (Directory)
Директория представляет собой коллекцию элементов, таких как файлы или другие директории. Она может содержать несколько вложенных объектов и поддерживает тот же интерфейс Element. Когда мы клонируем директорию, мы создаем копию самой директории, а также клонируем все ее элементы.

➡️ Принцип работы клонирования
Клонирование объекта вызывает метод клонирования для объекта, создает новый объект того же типа, копируя все значения оригинала. В случае с директориями это включает клонирование всех вложенных файлов и подкаталогов.

Рекурсивное клонирование — объект является директорией, клонирует не только саму директорию, но и все ее элементы, повторяя этот процесс для каждой вложенной директории и ее элементов.

Суффикс "_copy" — клон получает суффикс "_copy" в своем имени, что позволяет легко отличить оригинальный объект от его копии. (Doc1 → Doc1_copy)

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

❓ Что подразумевается под inlining в Go и какова его цель

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

Пример:

func add(a, b int) int {
    return a + b
}

func main() {
    result := add(3, 4)
    fmt.Println(result)
}

После inlining код может выглядеть так:

func main() {
    result := 3 + 4
    fmt.Println(result)
}

Основные моменты:
1️⃣Автоматическое решение компилятора, Go сам решает, следует ли выполнить inlining для функции, основываясь на её размере и сложности.
2️⃣Основное преимущество — это ускорение работы программы за счет снижения накладных расходов при многократных вызовах функции.
3️⃣Ограничения: не все функции можно встроить. Большие функции или те, что вызывают другие функции, скорее всего, не будут встроены. Чрезмерное использование inlining может увеличить размер исполняемого файла.
4️⃣Как увидеть решения компилятора — с помощью флага -gcflags="-m" можно увидеть, какие оптимизации и встраивания принял компилятор.

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

❓Как в Go передаются параметры в функцию

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

Чтобы работать с оригинальной переменной, а не с её копией, нужно передавать адрес этой переменной. Однако сам указатель будет передан по значению.

Передача базовых типов данных (int, string, bool и т.д.)

func modifyValue(x int) {
    x = x * 2
}

func main() {
    num := 10
    modifyValue(num)
    fmt.Println(num) // 10
}

В примере значение переменной num не изменяется, потому что в функцию передается копия этого значения.

Передача срезов и мап

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

func modifySlice(s []int) {
    s[0] = 100
}

func main() {
    numbers := []int{1, 2, 3}
    modifySlice(numbers)
    fmt.Println(numbers) // [100 2 3]
}

Передача указателей

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

func modifyWithPointer(x *int) {
    *x = *x * 2
}

func main() {
    num := 10
    modifyWithPointer(&num)
    fmt.Println(num) // 20
}

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

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

❓ Что представляет собой оператор select в Go и как он взаимодействует с каналами

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

➡️ Ключевые особенности select

• Ожидание нескольких каналов — select позволяет ожидать данные сразу из нескольких каналов или проверять возможность отправки данных в канал.

• Неблокирующий, если ни один канал не готов к операции, можно использовать default, чтобы избежать блокировки и продолжить выполнение программы.

• Рандомный выбор, если несколько каналов готовы к операции одновременно, select выберет один из них случайным образом.

Пример select

select {
case msg1 := <-ch1:
    fmt.Println("Received", msg1)
case msg2 := <-ch2:
    fmt.Println("Received", msg2)
case ch3 <- 3:
    fmt.Println("Sent 3 to ch3")
default:
    fmt.Println("No communication")
}

В этом примере select будет ждать, пока не получит сообщение из одного из каналов ch1 или ch2, или не сможет отправить значение в канал ch3. Если ни одно из этих условий не выполнится, будет выполнен блок default, который сообщает о том, что нет доступной коммуникации.

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

❓ Что такое указатели (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 бустов, плиз, иначе вопросов с собесов не будет 🚬