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

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

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

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

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

type Handler interface {
    Handle(msg string) string
}

type SimpleHandler struct{}

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

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

type LoggingHandler struct {
    next Handler
}

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

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

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

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

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

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

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

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

package main

import "fmt"

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

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

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

package main

import "errors"

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

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

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

package main

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

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

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

package main

import "fmt"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package main

import (
    "fmt"
    "net/http"
)

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

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

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

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

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

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

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

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

package main

import "net/http"

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

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

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

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

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

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

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

Примеры:

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

var r rune = 'A'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var mu sync.Mutex

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

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

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

var mu sync.RWMutex

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

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

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

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

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

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

package main

import (
    "fmt"
)

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

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

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

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

// ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

❓ Что включает в себя набор примитивов синхронизации пакета sync в Go

Примитивы синхронизации — инструменты (в основном из пакета sync), которые обеспечивают безопасную работу с общими данными и координацию горутин.

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

• sync.RWMutex — вариант мьютекса с разделением на блокировку для чтения и записи:
Одновременно могут выполняться несколько операций чтения.
Запись возможна только при полном исключении доступа.

• sync.WaitGroup — позволяет дождаться завершения группы горутин. Удобен для синхронного старта/остановки процессов.

• sync.Once — гарантирует однократное выполнение кода, даже при множественных вызовах из разных горутин.

• sync.Cond — условная переменная, при помощи которой горутина может "заснуть" до наступления определённого события.

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

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

❓ Что такое гонка данных и как она проявляется в языке Go

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

➡️ Состояние гонки (Race Condition) описывает ситуацию, когда поведение программы зависит от порядка выполнения операций. Гонка данных — это тип состояния гонки.

Пример гонки данных, которая может привести к сбоям и повреждению памяти:

func main() {
    c := make(chan bool)
    m := make(map[string]string)
    go func() {
        m["1"] = "a" // Первый конфликтный доступ
        c <- true
    }()
    m["2"] = "b" // Второй конфликтный доступ
    <-c
    for k, v := range m {
        fmt.Println(k, v)
    }
}

➡️ Для диагностики таких ошибок Go предоставляет встроенный детектор гонок данных. Для его использования достаточно добавить флаг -race при запуске команд:

$ go test -race mypkg   
$ go run -race mysrc.go
$ go build -race mycmd 
$ go install -race mypkg

➡️ Переменная окружения GORACE позволяет настроить параметры детектора гонок, например:

$ GORACE="log_path=/tmp/race/report Strip_path_prefix=/my/go/sources/" go test -race

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

❓ Для чего в Go применяется пустой идентификатор

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

1️⃣ Игнорирование возвращаемых значений функции: если функция возвращает несколько значений, но нужно только одно из них.

value, _ := someFunction()

2️⃣Игнорирование элементов в range: при переборе элементов среза или карты, когда нужен только ключ или только значение.

for k, _ := range myMap {
    fmt.Println(k)
}
   
for _, v := range mySlice {
    fmt.Println(v)
}

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

import _ "image/png"

4️⃣ Игнорирование переменных в множественном присваивании:

_, y := getCoordinates()

5️⃣ Игнорирование ошибок: можно использовать для игнорирования ошибок, но это не рекомендуется.

result, _ := strconv.Atoi("123")

6️⃣ Использование в анонимных структурах: при создании анонимной структуры, когда не нужно имя для одного из полей.

person := struct {
    Name string
    _ int 
}{"Alice", 30}

➡️ Пустой идентификатор полезен, но злоупотреблять им не следует, особенно для игнорирования ошибок.

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

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

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

• В Go есть возможность доступа к состоянию внешней функции из анонимных функций, даже после завершения внешней функции. Это позволяет создавать замыкания.
Замыкание — это функция, которая сохраняет доступ к переменным внешней функции после её завершения.

Пример с функцией incrementer, которая создает анонимную функцию для увеличения значения переменной i:

func incrementer() func() int {
    i := 0

    return func() int {
        i++
        return i
    }
}

При вызове incrementer создается новая копия переменной i, и возвращенная функция увеличивает её значение. Каждый последующий вызов incrementer создает свою копию переменной i.

func main() {
    increment := incrementer()
    fmt.Println(increment()) // 1
    fmt.Println(increment()) // 2
    fmt.Println(increment()) // 3

    newIncrement := incrementer()
    fmt.Println(newIncrement()) // 1
}

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

❓ Как проверить тип данных переменной в Go во время выполнения программы

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

Пример, который проверяет, является ли значение интерфейса i типом int или string:

func do(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Double %v is %v\n", v, v*2)
    case string:
        fmt.Printf("%q is %v bytes long\n", v, len(v))
    default:
        fmt.Printf("I don't know type %T!\n", v)
    }
}

func main() {
    do(21)
    do("hello")
    do(true)
}

Результат:

Double 21 is 42
"hello" is 5 bytes long
I don't know type bool!

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

❓ Опишите принцип работы стека и приведите реализацию на Go

Стек — тип данных, основанный на принципе LIFO (last in — first out, «последним пришёл — первым вышел»).

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

Операции:
push — добавление элемента,
pop — удаление верхнего элемента,
peek — возврат верхнего элемента без удаления.

Реализация на Go через срез:

type Stack struct {
    items []int
}

func (s *Stack) Push(item int) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() int {
    if len(s.items) == 0 {
        panic("Stack is empty!")
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

func (s *Stack) Peek() int {
    if len(s.items) == 0 {
        panic("Stack is empty!")
    }
    return s.items[len(s.items)-1]
}

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func (s *Stack) Size() int {
    return len(s.items)
}

Мы использовали срез для хранения элементов стека. Метод Push добавляет элемент на верх стека, метод Pop извлекает его, а метод Peek позволяет посмотреть верхний элемент без его извлечения. Также мы использовали проверку стека на наличие элементов.

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

❓ Как осуществить своп двух переменных без временной переменной

1️⃣ Сложение и вычитание (без временной переменной)

a := 5
b := 3

a = a + b // a становится 8
b = a - b // b становится 5 
a = a - b // a становится 3

a и b меняются местами за три операции без использования временной переменной.

2️⃣ XOR (исключающее ИЛИ)

a := 5 // 0101 в двоичной системе
b := 3 // 0011 в двоичной системе

a = a ^ b // a становится 6 (0110)
b = a ^ b // b становится 5 (0101)
a = a ^ b // a становится 3 (0011)

Двойное применение XOR с теми же операндами восстанавливает исходное значение, поэтому значения переставляются.

3️⃣ Простая функция со свопом

func main() {
    fmt.Println(swap())
}

func swap() []int {
    a, b := 15, 10
    b, a = a, b
    return []int{a, b}
}

swap меняет a и b местами и возвращает результат.

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

❓ Для чего нужен пакет cgo и что он собой представляет

Cgo создаёт мост между Go и C: код на Go вызывает функции C через пространство имён C, а код на C может вызывать экспортированные функции Go.

Cвойства cgo:
• Встраивание кода C в преамбуле перед import "C".
• Доступ к именам из заголовков и преамбулы через пространство имён C.
• Преобразования типов выполняются явно при переходе из C.* к чистым типам Go и обратно.
• Память: объекты, выделенные в C, освобождаются C.free, длительное хранение указателей на Go-память в C запрещено.

package randc

/*
#include <stdlib.h>
*/
import "C"

func Random() int {
  return int(C.random()) // C.long -> Go int
}

func Seed(i uint) {
  C.srandom(C.uint(i)) // Go uint -> C unsigned int
}

Разбор примера:
• import "C" — псевдопакет: ссылка на пространство имён C.
• В rand четыре обращения к C: вызовы C.random и C.srandom, приведение C.uint(i) и сам импорт.
• Random вызывает random из libc. В C она возвращает long (C.long в cgo), результат приводится к Go int перед выдачей наружу.
• Seed принимает Go int, приводит к C.uint и передаёт в srandom.
• Комментарий непосредственно перед import "C" — преамбула. Она компилируется как C-заголовок для C-частей пакета: здесь можно объявлять/определять функции и переменные, затем использовать их из Go через C.*.

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