В чем разница между буферизированными и небуферизированными каналами ?
Спросят с вероятностью 25%

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

Небуферизированные каналы

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

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

ch := make(chan int) // Создание небуферизированного канала
go func() {
    val := <-ch // Блокируется, ожидая данные
    fmt.Println("Received:", val)
}()
ch <- 3 // Блокируется, пока данные не будут получены

Буферизированные каналы

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

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

ch := make(chan int, 2) // Создание буферизированного канала с емкостью 2
ch <- 1 // Отправка данных без блокировки
ch <- 2 // Отправка данных без блокировки
go func() {
    val := <-ch // Получение данных без блокировки
    fmt.Println("Received:", val)
}()

Основные различия:

1️⃣Синхронизация: Небуферизированные каналы обеспечивают точную синхронизацию между отправителем и получателем, так как каждая операция передачи требует готовности обеих сторон. Буферизированные каналы снижают необходимость немедленной готовности получателя за счет введения буфера.

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

3️⃣Использование: Выбор между ними зависит от задачи — небуферизированные каналы идеальны для точной синхронизации, в то время как буферизированные хороши при потоковой передаче данных или когда порядок и время получения не критичны.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что будет, если попытатся писать в закрытом канале ?
Спросят с вероятностью 25%

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

Вот пример кода, который вызывает панику при попытке отправки в закрытый канал:

package main

import "fmt"

func main() {
    ch := make(chan int)
    close(ch) // закрытие канала
    ch <- 1   // попытка записи в закрытый канал вызовет панику
}

Запуск этого кода приведет к следующему выводу:

panic: send on closed channel

Обработка такой ситуации

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

1️⃣Четкая ответственность: Одна горутина или чётко определенный набор горутин должен быть ответственен за закрытие канала. Это помогает избежать ситуаций, когда один поток данных пытается записать в канал после его закрытия другим потоком.

2️⃣Использование синхронизации: С помощью механизмов синхронизации, таких как мьютексы или условные переменные (sync.Cond), можно координировать доступ к каналу, чтобы обеспечить его безопасное закрытие.

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как работает Map ?
Спросят с вероятностью 58%

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

Основы работы

Создание и инициализация

Map можно создать с помощью встроенной функции make или через литерал map. Вот примеры обоих методов:

// Создание map с помощью функции make
m := make(map[string]int)

// Создание map с помощью литерала
n := map[string]int{"foo": 1, "bar": 2}

В этих примерах m и n являются map, где ключи — это строки, а значения — целые числа.

Добавление или изменение элемента в map происходит путем присваивания значения ключу:

m["baz"] = 3

В этом примере ключу "baz" присваивается значение 3. Если ключ уже существует, его значение будет перезаписано.

Для получения значения по ключу используется следующий синтаксис:

value := m["baz"]

Если ключ существует, value будет содержать соответствующее значение. Если ключа нет в map, value получит нулевое значение для типа данных значения (например, 0 для int, "" для string и так далее).

Проверка существования ключа

Чтобы проверить, существует ли ключ в map и избежать нулевых значений, можно использовать второе возвращаемое значение при доступе к элементу:

value, ok := m["baz"]
if ok {
    fmt.Println("Value:", value)
} else {
    fmt.Println("Key not found")
}

Для удаления элемента из map используется встроенная функция delete:

delete(m, "baz")

Это удаляет элемент с ключом "baz" из map m.

Как map реализован

Внутренне, map реализован как хеш-таблица. Хеш-таблицы обеспечивают очень быстрый доступ к данным по ключу за среднее время O(1), что делает их идеальными для использования в ситуациях, где требуется частое извлечение или изменение данных по ключу.

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

Map — это мощный и эффективный инструмент для работы с ключ-значение данными, который обеспечивает быстрый доступ и удобные механизмы для управления данными. Проще говоря, map можно сравнить с шкафом с ящиками, где на каждом ящике написаны метки (ключи), и вы можете быстро найти нужный ящик (значение) по метке.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое репликация ?
Спросят с вероятностью 25%

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

Цели:

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

2️⃣Распределение нагрузки: Может помочь распределить запросы чтения между несколькими узлами, тем самым уменьшая нагрузку на один сервер и улучшая время отклика в приложениях.

3️⃣Геораспределение: Реплик в разных географических локациях может улучшить время доступа к данным для пользователей, которые находятся ближе к одной из реплик.

4️⃣Обеспечение безопасности данных: Данных на разные физические места уменьшает риски, связанные с потерей данных в случае катастроф.

Типы:

1️⃣Синхронная репликация
Данные одновременно записываются в основную и реплицированную базы данных. Транзакция считается завершенной только после успешной записи на всех репликах. Это обеспечивает высокую степень согласованности данных, но может снижать производительность из-за задержек, связанных с ожиданием подтверждения от всех реплик.

2️⃣Асинхронная репликация
Изменения данных первоначально записываются на основной сервер, и только после этого асинхронно передаются на репликационные серверы. Это метод быстрее, поскольку основная система не ждёт подтверждения от реплик перед завершением транзакции. Однако это также увеличивает риск несогласованности данных между репликами.

Репликация активно используется в распределённых базах данных, таких как Cassandra или MongoDB, а также в реляционных СУБД. В каждой из этих систем реализация репликации может иметь свои особенности, но основная цель — обеспечение доступности и надёжности данных — остаётся неизменной.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как устроен Map в Go ?
Спросят с вероятностью 42%

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

Внутренняя структура

Map реализуется через хеш-таблицу, что позволяет достигать средней временной сложности операций вставки, поиска и удаления O(1). Вот ключевые компоненты, на которые стоит обратить внимание:

1️⃣Хеш-функция: Ключ, который вы используете в map, преобразуется с помощью хеш-функции, которая определяет, в каком "bucket" (или "корзине") будет храниться значение. Хеш-функция в Go спроектирована так, чтобы минимизировать коллизии (где разные ключи имеют один и тот же хеш).

2️⃣Buckets (Корзины): Хеш-таблица разделена на несколько корзин. Каждый бакет может содержать несколько пар ключ-значение, которые имеют один и тот же или близкий хеш. Это помогает организовать данные таким образом, чтобы операции с map были максимально эффективными.

3️⃣Обработка коллизий: Коллизии в хеш-таблице (когда два ключа дают одинаковый хеш) решаются с помощью метода цепочек, где каждый элемент в бакете содержит указатель на следующий элемент с тем же хешем. Это позволяет нескольким элементам быть связанными в одном бакете.

4️⃣Рост и перехеширование: По мере того как элементы добавляются в map, количество корзин может увеличиваться для поддержания производительности операций. Когда фактор загрузки (отношение количества элементов к количеству корзин) достигает определенного порога, происходит процесс, называемый перехешированием, в котором элементы распределяются заново среди нового, большего количества корзин.

Поскольку map является встроенным типом, его использование не требует специальных библиотек:

m := make(map[string]int) // Создание map
m["apple"] = 5            // Добавление элемента
m["banana"] = 10          // Добавление другого элемента

value, exists := m["apple"] // Проверка существования ключа и получение значения
if exists {
    fmt.Println("Value:", value)
}

delete(m, "apple") // Удаление элемента

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как строки работают в Golang внутри ?
Спросят с вероятностью 42%

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

1️⃣Неизменяемость

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

2️⃣Структура строки

Внутренне строка представлена структурой, которая содержит два поля:
✅Указатель на массив байтов: Это указатель на первый элемент массива байт, который фактически хранит символы строки в кодировке UTF-8.
✅Длина: Количество байт в строке, а не количество рун или символов. Это важное различие, поскольку в UTF-8 один символ может занимать от 1 до 4 байт.

3️⃣UTF-8 как стандартная кодировка

Go использует UTF-8 как стандартную кодировку для строк. Это позволяет эффективно работать с международным текстом, поддерживая широкий спектр символов без сложностей, связанных с другими кодировками. Однако это также означает, что операции, такие как получение длины строки в рунах (символах) или доступ к отдельному символу, могут потребовать дополнительных вычислений для обработки многобайтовых символов.

4️⃣Срезы строк

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

5️⃣Производительность и память

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

Вот простой пример демонстрирующий работу со строками:

s := "Hello, world"      // Создание строки
t := s[7:]               // Срез строки, создает новую строку "world"

fmt.Println(s)           // Выводит: Hello, world
fmt.Println(t)           // Выводит: world

Строки — это эффективные и безопасные с точки зрения типов структуры данных, оптимизированные для работы с текстом в кодировке UTF-8. Их неизменяемость и структура с указателем и длиной делают их одновременно быстрыми в обработке и безопасными при передаче между различными частями программы.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чем ключевое различие слайса от массива ?
Спросят с вероятностью 25%

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

Основные различия:

1️⃣Размер:
✅Массивы имеют фиксированный размер, который определяется при их объявлении и не может быть изменен.
✅Слайсы являются динамическими, их размер может изменяться во время выполнения программы с помощью операций, таких как добавление элементов в конец слайса.

2️⃣Определение и инициализация:
✅Массивы определяются с указанием размера:

          var a [5]int
     
   - Слайсы чаще создаются с помощью встроенной функции make или на основе массива:
          s := make([]int, 0, 5) // слайс int с начальной длиной 0 и вместимостью 5
     t := []int{1, 2, 3}    // слайс, инициализированный с помощью литерала
     

3️⃣Работа с памятью:
✅Массивы выделяют один непрерывный блок памяти размером, достаточным для хранения всех его элементов.
✅Слайсы состоят из трех компонентов: указателя на элемент массива, длины (количество элементов в слайсе) и вместимости (максимальное количество элементов, которое слайс может содержать до следующего расширения). Слайсы, таким образом, используют "под капотом" массивы, но предоставляют большую гибкость через динамическое управление размером.

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

5️⃣Использование:
✅Массивы полезны, когда вам нужна предсказуемость в размере и вы хотите полностью контролировать объем занимаемой памяти.
✅Слайсы идеально подходят для ситуаций, когда вы работаете с набором данных, который может изменяться по размеру, или когда вы не знаете заранее, какой объем данных вам потребуется обработать.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

В чем разница процесса и потока в рамках операционной системы ?
Спросят с вероятностью 33%

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

Процесс

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

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

Поток (Thread)

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

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

Основные различия

1️⃣Изоляция: Процессы изолированы друг от друга, в то время как потоки делят состояние и ресурсы внутри одного процесса.
2️⃣Память: Каждый процесс имеет собственное адресное пространство, в то время как все потоки внутри процесса делят его адресное пространство.
3️⃣Создание и управление: Создание нового процесса более ресурсоемко, чем создание потока внутри существующего процесса.
4️⃣Взаимодействие: Взаимодействие между процессами требует использования межпроцессного взаимодействия (IPC), такого как сокеты, разделяемая память, очереди сообщений и т. д. Потоки внутри процесса могут общаться друг с другом напрямую через общую память.
5️⃣Надежность и безопасность: Ошибка в одном процессе обычно не влияет на другие процессы, но ошибка в одном потоке может привести к сбою всего процесса.

Примеры использования

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое mutex, какие они бывают и как их использовать ?
Спросят с вероятностью 25%

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

Какие бывают Mutex

1️⃣Блокирующие Mutex (Blocking Mutexes):
Это наиболее распространённый тип мьютексов. При попытке захватить мьютекс, если он уже занят другим потоком, поток блокируется и ожидает, пока мьютекс не будет освобождён.

2️⃣Неблокирующие Mutex (Non-blocking or Spinlocks):
Вместо блокирования потока, потоки активно проверяют состояние мьютекса в цикле. Это может быть эффективно, если мьютекс захватывается на очень короткое время, так как избегается затрата времени на блокировку и разблокировку потока.

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

Стандартная библиотека предоставляет мьютекс в пакете sync. Вот пример того, как можно использовать мьютекс для синхронизации доступа к общему ресурсу:

package main

import (
    "fmt"
    "sync"
)

var (
    balance int
    mutex   sync.Mutex
)

func deposit(value int, wg *sync.WaitGroup) {
    mutex.Lock() // Захват мьютекса перед изменением переменной balance
    fmt.Printf("Depositing %d to account with balance: %d\n", value, balance)
    balance += value
    mutex.Unlock() // Освобождение мьютекса после изменения
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go deposit(100, &wg)
    go deposit(200, &wg)
    wg.Wait()
    fmt.Printf("New Balance %d\n", balance)
}

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

Рекомендации по использованию:

✅Минимизируйте время захвата мьютекса: Держите код внутри защищённой секции как можно более коротким, чтобы избежать замедления работы других потоков, ожидающих доступа к ресурсу.
✅Избегайте вложенных мьютексов: Это может привести к взаимоблокировкам, если мьютексы захватываются в разном порядке.
✅Будьте осторожны с условиями гонки: Помните, что мьютексы защищают только блоки кода, для которых они явно захватываются. Доступ к тем же данным за пределами защищённого блока может привести к условиям гонки.
✅Предпочтите более высокоуровневые абстракции: Если это возможно, используйте каналы или другие средства синхронизации, которые могут быть более идиоматичными.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как работает Select ?
Спросят с вероятностью 33%

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

Основная механика

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

Давайте рассмотрим пример, где select используется для ожидания данных от двух каналов:

func process(ch1, ch2 <-chan int) {
    for {
        select {
        case v1 := <-ch1:
            fmt.Println("Received from ch1:", v1)
        case v2 := <-ch2:
            fmt.Println("Received from ch2:", v2)
        }
    }
}

В этом примере функция process будет ожидать данные из двух каналов: ch1 и ch2. Как только один из этих каналов отправит данные, соответствующий case будет выполнен.

Обработка таймаутов

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

select {
case v := <-someChannel:
    fmt.Println("Received:", v)
case <-time.After(5 * time.Second):
    fmt.Println("Timeout occurred, no data received within 5 seconds")
}

Здесь, если данные по каналу someChannel не поступают в течение 5 секунд, будет выполнен второй case, который обрабатывает таймаут.

Особенности

1️⃣Неблокирующий вариант: Можно использовать select для неблокирующего чтения или записи в канал, добавив default случай, который выполнится, если все другие каналы заблокированы:

      select {
   case v := <-ch:
       fmt.Println("Received", v)
   default:
       fmt.Println("No data received")
   }
   

2️⃣Равноправие случаев: Если несколько каналов готовы к выполнению операции, select случайным образом выберет один из них для выполнения, обеспечивая тем самым справедливость распределения ресурсов.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как устроены контексты в Go ?
Спросят с вероятностью 33%

Контексты (context.Context) представляют собой интерфейс, который используется для передачи мета-данных, управления сроками действия и отменой операций в иерархии вызовов функций. Основная цель контекста — обеспечение способа для остановки выполнения программы (например, запросов или подпроцессов) по требованию. Это особенно полезно в сетевых приложениях, где вам может потребоваться прервать выполнение операции, которая больше не требуется или занимает слишком много времени.

Ключевые особенности:

1️⃣Пропаганда по горутинам: Контекст предназначен для безопасной передачи по горутинам, что означает, что он может быть передан между различными частями вашей программы, выполняющимися в разных горутинах.

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

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

4️⃣Значения: Контексты могут нести значения — пары ключ-значение, которые можно устанавливать и получать. Эти значения обычно используются для передачи данных, специфичных для запроса, таких как идентификаторы сессий или токены авторизации.

Создание и использование контекста

Есть несколько способов создания контекста, включая базовые функции из пакета context:

✅context.Background(): Возвращает пустой контекст, который никогда не отменяется. Обычно используется в основной функции и при инициализации.
✅context.TODO(): Используется для указания, что должен быть предоставлен подходящий контекст. Обычно применяется в разработке и при рефакторинге.
✅context.WithCancel(parent Context) (ctx Context, cancel CancelFunc): Создает новый контекст с возможностью отмены.
✅context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc): Создает контекст, который автоматически отменяется в указанный deadline.
✅context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc): Аналогичен WithDeadline, но устанавливает время жизни контекста на основе заданного таймаута.

Пример:

func operation1(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("operation1 completed")
    case <-ctx.Done():
        fmt.Println("operation1 cancelled")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    go operation1(ctx)

    // Дожидаемся завершения или отмены операции
    <-ctx.Done()
    if err := ctx.Err(); err != nil {
        fmt.Println("main:", err)
    }
}

В этом примере функция operation1 прерывается, если контекст отменяется до истечения времени ожидания в 5 секунд.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Зачем нужны транзакции ?
Спросят с вероятностью 33%

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

Основные принципы:

Они базируются на четырёх основных принципах, известных как свойства ACID:

1️⃣Атомарность (Atomicity): Гарантирует, что все операции в рамках одной транзакции либо полностью выполнены, либо не выполнены вовсе. Если какая-либо часть транзакции не может быть завершена, вся транзакция откатывается (возвращается к исходному состоянию).

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

3️⃣Изолированность (Isolation): Позволяет транзакциям выполняться независимо друг от друга, изолируя их промежуточные состояния и управляя видимостью изменений данных других транзакций.

4️⃣Долговечность (Durability): Гарантирует, что результаты успешно завершённой транзакции будут устойчивы к системным сбоям, сохраняясь в постоянной памяти.

Зачем они нужны?

1️⃣Целостность данных: Транзакции обеспечивают целостность данных, автоматически управляя ошибками и несогласованностями, которые могут возникнуть в процессе выполнения операций. Например, при переводе средств между банковскими счетами транзакция гарантирует, что если с одного счёта деньги были сняты, то они будут зачислены на другой счёт.

2️⃣Обработка ошибок: В случае ошибок во время выполнения транзакции (таких как сбои оборудования или исключения в программном обеспечении) система управления базой данных может автоматически откатить все изменения, возвращая данные в исходное состояние, что предотвращает потерю или неправильное распределение данных.

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

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

Пример

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Ребят, напоминаю, что все вопросы, которые здесь публикуются можно посмотреть списком вместе с видео-ответами на моем сайте easyoffer.ru

В чем разница TCP и UDP ?
Спросят с вероятностью 25%

TCP (Transmission Control Protocol) и UDP (User Datagram Protocol) являются двумя основными транспортными протоколами, используемыми в сети Интернет для передачи данных между устройствами. Они выполняют одну и ту же основную задачу — доставку данных — но делают это разными способами, подходящими для различных типов приложений.

TCP (Transmission Control Protocol)

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

Основные характеристики:
✅Надежность: Гарантирует доставку данных, автоматически повторяя запросы в случае потери пакетов.
✅Управление потоком: Предотвращает переполнение сети, автоматически регулируя скорость передачи данных в зависимости от загруженности сети.
✅Управление перегрузками: Уменьшает скорость передачи данных при обнаружении перегрузок в сети, чтобы избежать потери пакетов.
✅Порядок данных: Обеспечивает доставку данных в том порядке, в котором они были отправлены.

UDP (User Datagram Protocol)

Это протокол без установления соединения, который не гарантирует доставку, порядок данных или их проверку на наличие ошибок. Он просто отправляет пакеты данных (датаграммы) в надежде, что они достигнут получателя.

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

Примеры:

TCP лучше подходит для:
✅Веб-браузеров (загрузка веб-страниц)
✅Передачи файлов
✅Электронной почты
✅Любых других приложений, где важна точность и полнота передаваемых данных

UDP лучше подходит для:
✅Стриминговых мультимедийных сервисов (видео или аудио)
✅Онлайн-игр
✅VoIP (голосовое общение через интернет)

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое context в Go ?
Спросят с вероятностью 25%

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

Основные особенности

1️⃣Управление временем жизни: Позволяет задавать сроки жизни для операций. Это может быть полезно, например, при обработке HTTP-запросов, доступе к базам данных или любых других операциях, которые должны быть ограничены по времени.

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

3️⃣Передача данных: Хотя это не основное его предназначение, он может использоваться для передачи запроса-специфичной информации через границы API, такие как идентификаторы транзакций, токены аутентификации и т.д.

Основные методы и функции

✅WithCancel(parent Context) (ctx Context, cancel CancelFunc): Создает новый контекст, который можно отменить. Возвращает функцию cancel, которая при вызове отменит этот контекст и все производные от него.
✅WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc): Создает контекст, который автоматически отменяется по достижении указанного времени (deadline).
✅WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc): Аналогично WithDeadline, но срок действия контекста задается через время ожидания (timeout).
✅WithValue(parent Context, key, val interface{}) Context: Создает контекст, который несет пару ключ-значение. Это может использоваться для передачи данных в границах запроса.

Пример:

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    go func() {
        select {
        case <-time.After(1 * time.Second):
            fmt.Println("operation succeeded")
        case <-ctx.Done():
            fmt.Println("operation canceled")
        }
    }()

    time.Sleep(3 * time.Second) // Delay sufficient to exceed the timeout of the context
}

В этом примере контекст с таймаутом используется для ограничения времени выполнения горутины. Если операция внутри горутины не завершится до истечения таймаута, контекст будет отменен, и программа выведет "operation canceled".

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие типы каналов существуют ?
Спросят с вероятностью 33%

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

1️⃣Небуферизованные каналы

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

ch := make(chan int)

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

2️⃣Буферизованные каналы

Имеют внутренний буфер определённого размера. Отправка в буферизованный канал блокируется только тогда, когда буфер заполнен. Аналогично, получение из буферизованного канала блокируется, когда буфер пуст. Буферизованный канал создаётся так:

ch := make(chan int, 5)

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

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

3️⃣Однонаправленные каналы

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

✅Каналы только для отправки:

ch := make(chan<- int)

✅Каналы только для получения:

ch := make(<-chan int)

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

👾 Ребят, напоминаю, у нас есть приватные группы где мы делимся реальными собеседованиями и тестовыми заданиями. Чтобы попасть в эти в группы воспользуйтесь ботами:
🤖 Доступ к базе собесов
🤖 Доступ к базе тестовых заданий

Как слайсы работают ?
Спросят с вероятностью 33%

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

Структура:

Слайс состоит из трёх основных компонентов:
1️⃣Указатель: Это указатель на первый элемент слайса внутри массива, который он представляет.
2️⃣Длина (Length): Количество элементов в слайсе. Длина не может превышать вместимость.
3️⃣Вместимость (Capacity): Общее количество элементов в массиве, начиная с первого элемента слайса. Вместимость указывает, насколько слайс может расти перед тем, как потребуется выделение новой области памяти.

Создание и инициализация слайсов

Слайс можно создать разными способами:
✅Через литерал:

    s := []int{1, 2, 3}
  

✅Через функцию make:

    s := make([]int, 5) // Создает слайс длиной 5 и вместимостью 5
  

✅Как срез массива:

    arr := [5]int{1, 2, 3, 4, 5}
  s := arr[1:4] // Создает слайс, который включает элементы arr[1], arr[2], arr[3]
  

Динамичность слайсов

Основная особенность слайсов заключается в их динамичности:
✅Изменение размера: Слайсы могут быть увеличены с помощью встроенной функции append:

    s := make([]int, 0, 5)
  s = append(s, 1, 2, 3, 4, 5) // Добавление элементов в слайс
  
  Если при добавлении элементов текущая вместимость слайса оказывается недостаточной, Go автоматически создает новый массив с большей вместимостью и копирует элементы старого массива в новый.

Работа с памятью

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

Пример:

func main() {
    fruits := []string{"apple", "orange", "banana", "grape", "plum"}
    fmt.Println(fruits[1:4]) // выводит ["orange", "banana", "grape"]

    fruitsSlice := fruits[2:]
    fruitsSlice[0] = "strawberry" // изменяет исходный массив fruits

    fmt.Println(fruits) // выводит ["apple", "orange", "strawberry", "grape", "plum"]
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какая средняя сложность поиска по слайсу и по map ?
Спросят с вероятностью 8%

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

Сложность поиска по слайсу

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

package main
import "fmt"

func findInSlice(slice []int, value int) bool {
    for _, v := range slice {
        if v == value {
            return true
        }
    }
    return false
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println(findInSlice(slice, 3))  // выводит true
    fmt.Println(findInSlice(slice, 6))  // выводит false
}

Сложность поиска по маппе

Это коллекция пар ключ-значение, реализованная с использованием хэш-таблиц. Средняя сложность поиска элемента по ключу в маппе составляет O(1) (амортизированное время). Это означает, что поиск по маппе происходит очень быстро и не зависит от количества элементов, так как ключи хешируются, и доступ к значению по ключу происходит практически мгновенно.

package main
import "fmt"

func main() {
    myMap := map[string]int{
        "apple":  5,
        "banana": 3,
        "orange": 10,
    }
    value, exists := myMap["banana"]
    if exists {
        fmt.Println("banana count:", value)  // выводит 3
    } else {
        fmt.Println("banana not found")
    }
}

Сравнение сложностей

✅Слайс: Поиск по значению имеет сложность O(n), так как в худшем случае необходимо просмотреть все элементы.
✅Маппа: Поиск по ключу имеет среднюю сложность O(1), благодаря использованию хэш-таблиц.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие БД бывают ?
Спросят с вероятностью 25%

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

1️⃣Реляционные базы данных (SQL)

Используют строгую схему и основаны на табличной модели, где данные организованы в строки и столбцы. Они поддерживают SQL (Structured Query Language), язык запросов, который позволяет выполнять сложные запросы и операции над данными. Примеры реляционных СУБД включают:
✅MySQL
✅PostgreSQL
✅Oracle Database
✅Microsoft SQL Server

2️⃣Нереляционные базы данных (NoSQL)

Отличаются от реляционных тем, что они могут хранить данные в различных форматах и не требуют фиксированной схемы. Эти базы данных часто используются для работы с большими объёмами разнообразных данных. Нереляционные базы данных могут быть классифицированы на несколько типов:
✅Документо-ориентированные: MongoDB, CouchDB
✅Ключ-значение: Redis, DynamoDB
✅Графовые: Neo4j, ArangoDB
✅Столбцовые: Cassandra, HBase

3️⃣Объектно-ориентированные базы данных

Хранят данные в виде объектов, как в объектно-ориентированных языках программирования. Эти базы данных лучше всего подходят для приложений, где необходимо тесное взаимодействие с объектно-ориентированным кодом. Примеры включают db4o и ObjectDB.

4️⃣Иерархические базы данных

Организуют данные в форме дерева, где каждый элемент хранит ссылки на своих детей, а элементы без родителей считаются корнями. Примеры таких систем — это ранние версии IBM IMS.

5️⃣Сетевые базы данных

Позволяют представлять сложные отношения между данными с помощью графа, где узлы представляют записи, а рёбра — связи. Примеры включают CA-IDMS и Raima Database Manager.

6️⃣Временные ряды

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

7️⃣Базы данных в памяти

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое WaitGroup ?
Спросят с вероятностью 25%

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

Как он работает

Использует счётчик, который инкрементируется для каждой новой задачи и декрементируется, когда задача завершается. Когда счётчик достигает нуля, это сигнализирует о том, что все задачи завершены. Вот основные методы:

1️⃣Add: Увеличивает счётчик на заданное число. Этот метод следует вызывать перед запуском горутины или набора горутин.
2️⃣Done: Уменьшает счётчик на единицу, сигнализируя о завершении горутины. Обычно вызывается в конце горутины.
3️⃣Wait: Блокирует выполнение, пока его счётчик не станет равен нулю, т.е. пока все горутины не завершат выполнение.

Давайте рассмотрим пример, который демонстрирует его использование для синхронизации нескольких горутин:

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // Вызов Done в defer гарантирует, что счётчик уменьшится при выходе из функции

    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second) // Имитация продолжительной работы
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    numWorkers := 3
    wg.Add(numWorkers) // Установка счётчика на количество работников

    for i := 1; i <= numWorkers; i++ {
        go worker(i, &wg) // Запуск каждого работника в отдельной горутине
    }

    wg.Wait() // Ожидание завершения всех горутин
    fmt.Println("All workers completed")
}

В этом примере мы создаём три горутины, каждая из которых выполняет функцию worker. С помощью WaitGroup мы синхронизируем завершение всех горутин, прежде чем печатаем сообщение "All workers completed".

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых