Golang | Вопросы собесов

🤔 Что такое CI/CD?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие бывают способы оптимизации?

Оптимизация кода в Go может быть выполнена на нескольких уровнях:

🟠Оптимизация алгоритмов и структур данных
Использование более эффективных алгоритмов (например, O(log n) вместо O(n^2)). Выбор подходящих структур данных (например, map вместо срезов для поиска по ключу).

🟠Оптимизация работы с памятью
Снижение количества аллокаций (использование sync.Pool, предварительное выделение памяти). Использование []byte вместо string, если требуется частое изменение строки. Минимизация копирования данных, например, передача []byte по ссылке вместо копирования.

🟠Оптимизация работы с горутинами
Использование worker pool, чтобы избежать избыточного создания горутин. Ограничение количества параллельных задач (runtime.GOMAXPROCS). Использование каналов правильной ёмкости для минимизации блокировок.

🟠Оптимизация ввода-вывода (I/O)
Буферизация (bufio.Reader, bufio.Writer). Использование асинхронных операций при работе с файлами или сетью. Использование io.Pipe() для потоковой обработки данных.

🟠Использование профилирования и анализа производительности
pprof для анализа CPU, памяти и блокировок. race detector (-race флаг) для выявления проблем с конкурентным доступом. Инструменты трассировки (trace).

🚩Пример оптимизации работы с памятью

Пример неэффективного кода

func inefficient() []string {
    var result []string
    for i := 0; i < 1000; i++ {
        result = append(result, fmt.Sprintf("Item %d", i)) // Частые аллокации
    }
    return result
}

Оптимизированный вариант

func efficient() []string {
    result := make([]string, 0, 1000) // Выделяем память заранее
    for i := 0; i < 1000; i++ {
        result = append(result, fmt.Sprintf("Item %d", i))
    }
    return result
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как встроить стандартный профайлер в своё приложение?

Интегрируйте профайлер с помощью пакета net/http/pprof, добавив HTTP-сервер в приложение. После запуска профайлер будет доступен через веб-интерфейс.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему в TDD тесты пишутся прежде кода?

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

🚩Причины

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

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

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

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

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

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

🚩Пример процесса TDD

1⃣Написание теста

package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, but got %d", result)
    }
}

2⃣Запуск теста
На этом этапе тест не пройдет, так как функция Add еще не реализована.

3⃣Реализация кода

package main

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

4⃣Запуск теста снова
Теперь тест пройдет, так как функция Add реализована корректно.

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие типы данных можно использовать в ключах?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как избежать deadlock?

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

🚩Чтобы избежать deadlock, нужно следовать этим принципам

🟠Грамотно проектировать порядок блокировок
Если несколько горутин используют блокировки (например, через мьютексы), убедитесь, что все они захватывают их в одном и том же порядке.

func main() {
    var mu1, mu2 sync.Mutex

    go func() {
        mu1.Lock()
        defer mu1.Unlock()

        mu2.Lock()
        defer mu2.Unlock()
    }()

    go func() {
        mu2.Lock()
        defer mu2.Unlock()

        mu1.Lock()
        defer mu1.Unlock()
    }()
}

🟠Не блокировать каналы навсегда
Каналы должны всегда иметь возможность отправки и получения данных. Если одна сторона (отправитель или получатель) заблокирована навсегда, возникает deadlock.

func main() {
    ch := make(chan int)
    ch <- 42 // Deadlock, так как никто не читает из канала
}

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

ch := make(chan int)
close(ch) // Закрыт слишком рано
ch <- 42  // Паника

🟠Избегайте ситуаций с ожиданием себя
Иногда deadlock происходит, если горутина ждет сама себя.

func main() {
    ch := make(chan int)
    ch <- 1
    fmt.Println(<-ch) // Никогда не выполнится
}

🟠Использовать тайм-ауты и селекторы
Go позволяет избегать блокировок с помощью механизма тайм-аутов и оператора select. Если операция занимает слишком много времени, можно выполнить альтернативное действие.

func main() {
    ch := make(chan int)

    select {
    case data := <-ch:
        fmt.Println("Получены данные:", data)
    case <-time.After(1 * time.Second):
        fmt.Println("Тайм-аут, завершение")
    }
}

🟠Используйте инструменты анализа
Go предоставляет утилиту go run -race, которая помогает выявлять гонки данных и другие проблемы, связанные с синхронизацией.

go run -race main.go

Ставь 👍 и забирай 📚 Базу знаний

🔥 Скрытые вакансии с удаленной работой для Golang разработчика, которые нигде больше не публикуются. Напрямую от компаний, с контактами рекрутеров.

🔹 Golang Go Jobs | Вакансии

🔸 Все каналы с вакансиями

🤔 Какие типы каналов существуют?

В Go существует два типа каналов: буферизованные (buffered) и небуферизованные (unbuffered). Небуферизованные каналы требуют, чтобы отправляющая и принимающая горутина синхронизировались друг с другом, что делает их блокирующими. Буферизованные каналы имеют определённый размер буфера, и горутина может отправить сообщение в канал, не ожидая немедленного получения, пока буфер не заполнится. Оба типа каналов используются для передачи данных между горутинами и синхронизации их работы.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему нельзя брать ссылку на значение, хранящееся по ключу в map?

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

🚩Причины, почему нельзя брать ссылку на значение в карте

🟠Внутреннее устройство карты (map)
Карты реализованы на основе хеш-таблиц. Внутреннее устройство карты предполагает, что значения могут перемещаться в памяти при выполнении операций, таких как добавление или удаление элементов. Хеш-таблица может перераспределять (реорганизовывать) свои внутренние структуры для оптимизации доступа к элементам. Это может происходить, например, когда карта увеличивается в размере.

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

🚩Демонстрация проблемы

Здесь попытка взять ссылку на значение из карты могла бы привести к проблемам

package main

import "fmt"

func main() {
    m := map[string]int{"a": 1, "b": 2}

    // Нельзя делать так:
    // p := &m["a"]

    // Вместо этого можно работать с копией значения
    value := m["a"]
    p := &value

    fmt.Println("Value:", *p) // 1

    // Изменение карты
    m["c"] = 3

    // Ссылка на значение в карте могла бы стать недействительной
    // fmt.Println("Value after map change:", *p)
}

🚩Правильные способы работы со значениями карты

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

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

value := m["a"]   

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

value := m["a"]
value = value + 10
m["a"] = value   

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

   package main

   import "fmt"

   func main() {
       m := map[string]*int{"a": new(int), "b": new(int)}
       *m["a"] = 1
       *m["b"] = 2

       // Теперь можно брать указатели на значения
       p := m["a"]
       fmt.Println("Value:", *p) // 1

       // Изменение значения через указатель
       *p = 42
       fmt.Println("Updated Value:", *m["a"]) // 42
   }

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое моки (mocks)?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что может быть пустым интерфейсом?

Пустой интерфейс interface{} является универсальным контейнером, который может содержать значение любого типа. Это связано с тем, что в Go любой тип автоматически реализует пустой интерфейс, поскольку в нем нет методов, которые нужно реализовать.

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

🚩Примеры

Примитивные типы

package main

import "fmt"

func main() {
    var i interface{}
    i = 42
    fmt.Println(i) // Output: 42

    i = "hello"
    fmt.Println(i) // Output: hello

    i = true
    fmt.Println(i) // Output: true
}

Композитные типы

package main

import "fmt"

func main() {
    var i interface{}

    i = []int{1, 2, 3}
    fmt.Println(i) // Output: [1 2 3]

    i = map[string]int{"one": 1, "two": 2}
    fmt.Println(i) // Output: map[one:1 two:2]

    type Person struct {
        Name string
        Age  int
    }

    i = Person{Name: "Alice", Age: 30}
    fmt.Println(i) // Output: {Alice 30}
}

Функции

package main

import "fmt"

func main() {
    var i interface{}

    i = func() {
        fmt.Println("Hello from function")
    }

    if f, ok := i.(func()); ok {
        f() // Output: Hello from function
    }
}

Другие интерфейсы

package main

import "fmt"

type Stringer interface {
    String() string
}

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func main() {
    var i interface{}

    i = Person{Name: "Alice", Age: 30}

    if str, ok := i.(Stringer); ok {
        fmt.Println(str.String()) // Output: Alice (30 years old)
    }
}

🚩Проверка и приведение типа

Утверждение типа

package main

import "fmt"

func main() {
    var i interface{} = 42

    if v, ok := i.(int); ok {
        fmt.Println("Integer:", v) // Output: Integer: 42
    } else {
        fmt.Println("Not an integer")
    }
}

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

package main

import "fmt"

func printType(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Integer:", v)
    case bool:
        fmt.Println("Boolean:", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    printType("hello")      // Output: String: hello
    printType(42)           // Output: Integer: 42
    printType(true)         // Output: Boolean: true
    printType(3.14)         // Output: Unknown type: float64
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как устроена многозадачность в Go?

Go использует горутины — лёгкие, кооперативные потоки:
- Управляются внутренним планировщиком, а не ОС.
- Планировщик Go мапит большое количество горутин на малое количество системных потоков (M:N модель).
- Горутины создаются быстро, с минимальными ресурсами.
- Взаимодействуют через каналы и select.
Многозадачность реализуется через кооперативную конкуренцию и распределение задач по worker-потокам.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как наследование осуществлено в Golang?


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

🚩Композиция

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

package main

import "fmt"

// Определение структуры
type Engine struct {
    Power int
}

func (e Engine) Start() {
    fmt.Println("Engine started with power:", e.Power)
}

// Определение другой структуры, которая включает первую
type Car struct {
    Brand string
    Engine
}

func main() {
    myCar := Car{
        Brand: "Toyota",
        Engine: Engine{Power: 150},
    }

    fmt.Println("Car brand:", myCar.Brand)
    myCar.Start() // Вызов метода встроенной структуры
}

🚩Интерфейсы

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

package main

import "fmt"

// Определение интерфейса
type Drivable interface {
    Drive()
}

// Определение структуры, реализующей интерфейс
type Car struct {
    Brand string
}

func (c Car) Drive() {
    fmt.Println(c.Brand, "is driving")
}

// Еще одна структура, реализующая интерфейс
type Bike struct {
    Brand string
}

func (b Bike) Drive() {
    fmt.Println(b.Brand, "is driving")
}

// Функция, принимающая интерфейс
func StartDriving(d Drivable) {
    d.Drive()
}

func main() {
    car := Car{Brand: "Toyota"}
    bike := Bike{Brand: "Yamaha"}

    StartDriving(car)
    StartDriving(bike)
}

🚩Встраивание интерфейсов

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

package main

import "fmt"

// Определение базового интерфейса
type Printer interface {
    Print()
}

// Определение другого интерфейса, включающего первый
type AdvancedPrinter interface {
    Printer
    Scan()
}

// Реализация структуры, реализующей расширенный интерфейс
type MultiFunctionPrinter struct{}

func (m MultiFunctionPrinter) Print() {
    fmt.Println("Printing...")
}

func (m MultiFunctionPrinter) Scan() {
    fmt.Println("Scanning...")
}

func main() {
    mfp := MultiFunctionPrinter{}
    mfp.Print()
    mfp.Scan()
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие есть возможности у создания дочернего контекста данных?

1. Отмена операций:
- С помощью WithCancel можно отменить дочерние контексты при необходимости.
2. Управление временем выполнения:
- Установить тайм-аут или дедлайн для операций с WithTimeout или WithDeadline.
3. Передача данных:
- С WithValue можно передать данные (например, идентификаторы пользователя) между горутинами.
4. Изоляция задач:
- Дочерние контексты изолируют задачи, сохраняя независимость от других операций.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что делает HAVING?

HAVING — это оператор SQL, который фильтрует результаты после GROUP BY, аналогично WHERE, но работает с агрегатными функциями (COUNT(), SUM(), AVG(), MAX(), MIN()).

🚩Ключевая разница

WHERE фильтрует до GROUP BY (по отдельным строкам).
HAVING фильтрует после GROUP BY (по сгруппированным данным).

Пример 1: Фильтрация по HAVING
Задача: Вывести товары, у которых продано более 10 единиц.

SELECT product, SUM(quantity) as total_sold
FROM sales
GROUP BY product
HAVING SUM(quantity) > 10;

Пример 2: Разница между WHERE и HAVING

SELECT category, COUNT(*) as total_products
FROM products
WHERE price > 100    -- ❌ Убирает дешёвые товары ДО группировки
GROUP BY category
HAVING COUNT(*) > 5; -- ✅ Оставляет только категории с более 5 товаров

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое уровни изоляции транзакций?

Уровни изоляции определяют, насколько одна транзакция изолирована от других. Они влияют на читаемость данных и защищённость от конфликтов.
Стандартные уровни:
1. Read Uncommitted — минимальная изоляция, возможны "грязные" чтения.
2. Read Committed — читаются только зафиксированные данные.
3. Repeatable Read — одна и та же строка не изменяется другими транзакциями.
4. Serializable — максимальная изоляция, предотвращает все типы конфликтов, но снижает производительность.
Чем выше уровень — тем безопаснее, но медленнее.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие циклы есть в Go?

Существует один основной цикл — это цикл for. н может использоваться в различных формах, выполняя функции традиционных циклов while, do-while и классического for.

🚩Формы цикла

С тремя выражениями

      package main

   import "fmt"

   func main() {
       for i := 0; i < 5; i++ {
           fmt.Println(i)
       }
   }
   

Как while

      package main

   import "fmt"

   func main() {
       i := 0
       for i < 5 {
           fmt.Println(i)
           i++
       }
   }
   

Бесконечный

      package main

   import "fmt"

   func main() {
       i := 0
       for {
           if i >= 5 {
               break
           }
           fmt.Println(i)
           i++
       }
   }
   

С использованием range

      package main

   import "fmt"

   func main() {
       arr := []int{1, 2, 3, 4, 5}
       for index, value := range arr {
           fmt.Printf("Index: %d, Value: %d\n", index, value)
       }
   }
   
   

🚩Примеры

Итерация по массиву

      arr := [5]int{10, 20, 30, 40, 50}
   for i := 0; i < len(arr); i++ {
       fmt.Println(arr[i])
   }
   

Итерация по карте

      m := map[string]int{"a": 1, "b": 2, "c": 3}
   for key, value := range m {
       fmt.Printf("Key: %s, Value: %d\n", key, value)
   }
   

Итерация по строке

      s := "hello"
   for index, char := range s {
       fmt.Printf("Index: %d, Char: %c\n", index, char)
   }

Ставь 👍 и забирай 📚 Базу знаний