🤔 Какие есть правила при выделении переменной в горутине?

- Если переменная не покидает рамки функции, она хранится на стеке горутины.
- Если переменная используется в замыкании или передаётся в другую горутину (например, через канал), она может "утечь в heap" — и будет сборщиком мусора отслеживаться.
- Escape-анализ компилятора автоматически определяет, куда выделять память.

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

🤔 Что такое триггер?

Триггер — это специальная процедура в СУБД, которая автоматически выполняется при определённом событии (например, INSERT, UPDATE, DELETE) в таблице.

🚩Как работают триггеры?

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

🚩Пример триггера в PostgreSQL

Допустим, у нас есть таблица orders, и мы хотим автоматически сохранять историю изменений заказов в таблицу orders_log.

CREATE TABLE orders_log (
    id SERIAL PRIMARY KEY,
    order_id INT,
    old_status TEXT,
    new_status TEXT,
    changed_at TIMESTAMP DEFAULT now()
);

CREATE OR REPLACE FUNCTION log_order_update()
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO orders_log (order_id, old_status, new_status)
    VALUES (OLD.id, OLD.status, NEW.status);
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER order_status_change
AFTER UPDATE ON orders
FOR EACH ROW
WHEN (OLD.status IS DISTINCT FROM NEW.status)
EXECUTE FUNCTION log_order_update();

🚩Разновидности триггеров

🟠До выполнения операции (`BEFORE`)
Используется для проверки или модификации данных перед изменением.

🟠После выполнения операции (`AFTER`)
Чаще всего используется для логирования или дополнительных действий.

🟠INSTEAD OF (для представлений)
Позволяет заменить выполнение операции (INSERT, UPDATE, DELETE).

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

🤔 Почему встраивание — не наследование?

1. Явное управление:
- Встраивание дает доступ к методам встроенной структуры, но не создает иерархии.
2. Избегание жесткой привязки:
- Код становится более модульным, без строгой зависимости от базового типа.
3. Композиция вместо наследования:
- Go следует принципу композиции, что упрощает тестирование и повторное использование.

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

🤔 Как работать со слайсами?

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

🚩Что это такое?

Это динамическая последовательность элементов одного типа, которая предоставляет доступ к части или всем элементам массива без копирования данных. Он содержит три компонента:
Указатель на массив.
Длина (количество элементов в слайсе).
Ёмкость (максимальное количество элементов, которые могут быть включены в слайс без перераспределения памяти).

🚩Почему они нужны?

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

🚩Создать слайс можно несколькими способами:

Из массива

    arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // слайс содержит элементы {2, 3, 4}
    

Используя make

slice := make([]int, 5)  // создаёт слайс длиной и ёмкостью 5, заполненный нулями    

Литерал слайса

slice := []int{1, 2, 3, 4, 5}    

🚩Основные операции

Доступ к элементам

fmt.Println(slice[0])  // выводит первый элемент слайса    

Изменение элементов

slice[1] = 10  // изменяет второй элемент слайса    

Добавление элементов

slice = append(slice, 6, 7)  // добавляет элементы 6 и 7 к слайсу    

Срезка (slicing)

newSlice := slice[1:3]  // создаёт новый слайс с элементами с 1-го по 3-й    

Рассмотрим пример функции, которая добавляет элемент в слайс и возвращает новый слайс

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3}
    nums = append(nums, 4)  // добавление элемента
    fmt.Println(nums)  // выводит [1, 2, 3, 4]
}

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

🤔 Насколько увеличивается слайс при append?

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

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

🤔 Как работает append в слайсе ?

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

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

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

Синтаксис

slice = append(slice, elem1, elem2, ...)

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

package main

import "fmt"

func main() {
    // Создаем слайс из 3 целых чисел
    slice := []int{1, 2, 3}
    
    // Добавляем один элемент
    slice = append(slice, 4)
    
    // Добавляем несколько элементов
    slice = append(slice, 5, 6, 7)
    
    // Выводим слайс
    fmt.Println(slice) // Выводит: [1 2 3 4 5 6 7]
}

🚩Объяснение работы

1⃣Начальный слайс
Создаем слайс с тремя элементами [1, 2, 3].

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

2⃣Добавление одного элемента
Добавляем элемент 4 к слайсу. Теперь слайс содержит [1, 2, 3, 4].

slice = append(slice, 4)   

3⃣Добавление нескольких элементов
Добавляем элементы 5, 6, и 7. Теперь слайс содержит [1, 2, 3, 4, 5, 6, 7].

slice = append(slice, 5, 6, 7)   

4⃣Вывод слайса
Выводим слайс, который содержит [1, 2, 3, 4, 5, 6, 7].

fmt.Println(slice)   

Работа с емкостью и длиной

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    fmt.Printf("Before append: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
    
    slice = append(slice, 4)
    fmt.Printf("After append: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
    
    slice = append(slice, 5, 6, 7)
    fmt.Printf("After multiple appends: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
}

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

🤔 Как работает Select?

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

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

🤔 Как происходит поиск по ключу в map?

Карты (maps) реализованы на основе хеш-таблиц, что обеспечивает быстрый доступ к значениям по ключам. Давайте рассмотрим, как происходит поиск по ключу в карте, и какие этапы включены в этот процесс.

🚩Основные этапы

🟠Хеширование ключа
Сначала вычисляется хеш-значение ключа. Функция хеширования преобразует ключ в целое число, которое служит индексом в хеш-таблице.

🟠Поиск в хеш-таблице
Хеш-значение используется для доступа к соответствующей "ячейке" или "корзине" (bucket) в хеш-таблице.

🟠Поиск в корзине
Если корзина содержит несколько элементов (из-за коллизий хеширования), Go выполняет линейный поиск среди этих элементов, сравнивая ключи с использованием оператора ==.

🚩Детали

🟠Хеширование ключа
Когда вы пытаетесь получить значение по ключу, Go сначала вычисляет хеш-значение этого ключа. Хеш-функция берет ключ (например, строку или целое число) и преобразует его в индекс хеш-таблицы.

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

🟠Линейный поиск внутри корзины
Если корзина содержит несколько элементов, Go выполняет линейный поиск среди этих элементов. Для каждого элемента в корзине сравнивается ключ с искомым ключом с использованием оператора ==. Если ключи совпадают, возвращается соответствующее значение. Если ключ не найден, возвращается нулевое значение типа (zero value) и флаг, указывающий на отсутствие ключа.

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice:", value) // Alice: 25
    } else {
        fmt.Println("Alice not found")
    }

    value, exists = myMap["Charlie"]
    if exists {
        fmt.Println("Charlie:", value)
    } else {
        fmt.Println("Charlie not found") // Charlie not found
    }
}

🚩Подводные камни и особенности

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

🟠Производительность
В среднем, доступ к элементу в карте осуществляется за константное время O(1), что делает карты очень эффективными для поиска по ключу. Однако в худшем случае, при большой нагрузке коллизий, производительность может деградировать до линейного времени O(n).

🟠Изменение карты во время поиска
Карты не являются потокобезопасными. Если одна горутина изменяет карту, в то время как другая горутина читает из нее, это может привести к панике. Для обеспечения потокобезопасности используйте мьютексы или структуру sync.Map.

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

🤔 Из каких частей состоит HTTP-запрос?

HTTP-запрос включает:
- Стартовую строку: метод (GET, POST), путь (/api), версия (HTTP/1.1)
- Заголовки (headers): информация о клиенте, типах данных, авторизации и т.д.
- Пустая строка: разделитель между заголовками и телом
- Тело (body): данные запроса (не всегда есть — например, у GET нет)

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

🤔 Как сделать свои методы для пакета?

В Go методы создаются для структур (или типов) внутри пакета. Это позволяет добавлять логику и поведение объектам.

🚩Создание собственного пакета

Допустим, мы создаем пакет mathutils, который будет содержать метод для структуры Calculator.

package mathutils

// Calculator - структура с данными
type Calculator struct {
    A, B int
}

// Sum - метод для сложения чисел A и B
func (c Calculator) Sum() int {
    return c.A + c.B
}

🚩Использование пакета в другом файле

Теперь мы можем использовать этот метод в основном файле программы.

package main

import (
    "fmt"
    "mypackage/mathutils" // Импортируем наш пакет
)

func main() {
    calc := mathutils.Calculator{A: 5, B: 3}
    fmt.Println("Sum:", calc.Sum()) // Выведет: Sum: 8
}

🚩Указатели vs. Значения в методах

Методы можно объявлять как для значений (func (c Calculator)) так и для указателей (func (c *Calculator)).
Когда использовать указатели?
Если метод изменяет данные структуры.
Чтобы избежать копирования больших структур.

func (c *Calculator) Multiply(factor int) {
    c.A *= factor
    c.B *= factor
}

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

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

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

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

🤔 Как расшифровывается аббревиатура ACID?

ACID — это набор свойств транзакций в базах данных, обеспечивающий надежность и целостность данных.

🚩ACID

🟠A (Atomicity) — Атомарность
Транзакция выполняется либо полностью, либо не выполняется вовсе.
Пример: Если при переводе денег со счета A на счет B ошибка произошла на полпути, изменения откатываются.

🟠C (Consistency) — Согласованность
Данные остаются в правильном состоянии до и после транзакции.
Пример: Если сумма на всех счетах банка должна оставаться неизменной, транзакция не должна нарушить это правило.

🟠I (Isolation) — Изолированность
Одновременные транзакции не мешают друг другу.
Пример: Два клиента покупают один и тот же товар, но база данных правильно обрабатывает, кто купил первым.

🟠D (Durability) — Долговечность
После завершения транзакции изменения сохраняются, даже если система сломается.
Пример: Если заказ оформлен, он не исчезнет при внезапном отключении электричества.

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

🤔 Что известно про паттерн Singleton (Одиночка)?

Singleton гарантирует, что у класса есть только один экземпляр, и предоставляет глобальную точку доступа к нему.
Характеристики:
- Ленивая инициализация (создаётся при первом вызове).
- Применяется для объектов, которые должны быть уникальны: логгеры, конфигурация, доступ к БД.
- В Go реализуется через глобальные переменные и sync.Once для потокобезопасной инициализации.

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

🤔 Как использовать линтеры (linters)?

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

🟠Популярные линтеры для Go
В Go есть несколько популярных линтеров:
golangci-lint – самый мощный и популярный, объединяет множество линтеров.
go vet – стандартный инструмент для поиска ошибок.
golint – проверяет стиль кода (но устарел).
staticcheck – анализирует код на ошибки и неэффективность.

🟠Установка линтера
Устанавливаем golangci-lint (лучший вариант)

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

После установки проверьте версию:

golangci-lint --version

🟠Запуск линтера
Запустить проверку в проекте можно так:

golangci-lint run

Можно проверить только определённый файл:

golangci-lint run myfile.go

Если хотите автоматически исправлять ошибки, используйте:

golangci-lint run --fix

🟠Использование `go vet` (встроенный анализатор)
Go уже имеет встроенный линтер

go vet ./...

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

🤔 Что такое type switch?

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

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

🤔 Какие циклы есть в 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)
   }  

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

🤔 Что такое recover?

Recover — это механизм восстановления после ошибки. В языках вроде Go recover используется для перехвата паники и безопасного продолжения работы программы.
Обобщённо, "recover" означает стратегию, при которой система или компонент не падает окончательно, а пытается вернуть управление, залогировать ошибку или выполнить корректную очистку.

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

🤔 Насколько безопасно передавать слайсы в разные горутины?

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

🚩Основные аспекты безопасности

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

package main

import (
    "fmt"
    "sync"
)

func printSlice(slice []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for _, v := range slice {
        fmt.Println(v)
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup
    wg.Add(2)

    go printSlice(slice, &wg)
    go printSlice(slice, &wg)

    wg.Wait()
}

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

package main

import (
    "fmt"
    "sync"
)

func incrementSlice(slice []int, wg *sync.WaitGroup, mu *sync.Mutex) {
    defer wg.Done()
    for i := range slice {
        mu.Lock()
        slice[i]++
        mu.Unlock()
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup
    var mu sync.Mutex

    wg.Add(2)

    go incrementSlice(slice, &wg, &mu)
    go incrementSlice(slice, &wg, &mu)

    wg.Wait()
    fmt.Println(slice)
}

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

package main

import (
    "fmt"
    "sync"
)

func incrementSlice(slice []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := range slice {
        slice[i]++
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup

    wg.Add(2)

    // Передаем копии слайса в горутины
    go incrementSlice(append([]int(nil), slice...), &wg)
    go incrementSlice(append([]int(nil), slice...), &wg)

    wg.Wait()
    fmt.Println(slice) // Исходный слайс не изменяется
}

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