🤔 Как называется механизм сборки мусора?

В Go механизм сборки мусора называется Garbage Collector (GC).

🚩Как работает сборщик мусора в Go?

Go использует автоматический сборщик мусора с конкурентной, трицветной, инкрементальной стратегией.

🟠Конкурентный (Concurrent)
выполняется параллельно с работой программы.
🟠Трёхцветный (Tri-color)
объекты помечаются как белые, серые и чёрные.
🟠Инкрементальный (Incremental)
работает порциями, а не останавливает программу надолго.

🚩Алгоритм трёхцветной маркировки

🟠Белые объекты
мусор, который будет удалён.
🟠Серые объекты
те, которые находятся в обработке.
🟠Чёрные объекты
используемые объекты, которые не подлежат удалению.

🚩Оптимизация GC в Go

Чтобы уменьшить нагрузку на GC:
Используйте пул объектов (sync.Pool).
Минимизируйте аллокации в куче (например, используйте []byte вместо string, если можно).
Ограничивайте долгоживущие объекты, так как они реже сканируются.

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

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

Зависит от уровня, но в общем:
- На уровне базы: индексация, query plan, нормализация, кэширование.
- На уровне кода: профилирование, снижение сложности алгоритмов.
- На уровне сети: сжатие, уменьшение количества запросов.
- На уровне архитектуры: кэш, очереди, шардирование, микросервисы, отказ от лишнего состояния.
- На уровне ОС/серверов: тюнинг параметров, балансировка, масштабирование.

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

🤔 Можно ли использовать один и тот же буфер []byte в нескольких горутинах?

Может быть как безопасным, так и небезопасным, в зависимости от контекста и конкретного использования.

🚩Когда использование небезопасно

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            buffer[i] = byte(i) // Несколько горутин одновременно модифицируют буфер
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🚩Безопасное использование одного буфера

🟠Только чтение
Если несколько горутин только читают из буфера, это безопасно. Пример безопасного использования:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < len(buffer); i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("buffer[%d]: %c\n", i, buffer[i])
        }(i)
    }

    wg.Wait()
}

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

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mu.Lock()
            buffer[i] = byte(i)
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

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

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            localBuffer := make([]byte, len(buffer))
            copy(localBuffer, buffer)
            localBuffer[i] = byte(i)
            fmt.Printf("Goroutine %d: %s\n", i, localBuffer)
        }(i)
    }

    wg.Wait()
}

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

🤔 Чем отличается merge от rebase?

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

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

🤔 Как закрыть канал?

В Go каналы (chan) можно закрывать с помощью close(channel), чтобы показать, что больше не будет отправляться данных.

Как закрыть канал?

ch := make(chan int)
close(ch) // Закрываем канал

Полный пример

package main

import "fmt"

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

    go func() {
        for i := 1; i <= 3; i++ {
            ch <- i // Отправляем данные
        }
        close(ch) // Закрываем канал
    }()

    for val := range ch { // Читаем пока канал не закроется
        fmt.Println(val)
    }

    fmt.Println("Канал закрыт, чтение завершено")
}

Выход

1
2
3
Канал закрыт, чтение завершено

🚩Как проверить, закрыт ли канал?

Используем val, ok := <-ch:
- ok == true → канал открыт, есть данные.
- ok == false → канал закрыт.

package main

import "fmt"

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

    val, ok := <-ch
    fmt.Println("val:", val, "ok:", ok) // val: 0 ok: false
}

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

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

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

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

🤔 Какие есть особенности синтаксиса получения и записи значений в map?

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

🚩Получение значений

🟠Простое получение значения по ключу
Для этого используется синтаксис индексирования

value := myMap[key]

Пример

package main

import "fmt"

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

    value := myMap["Alice"]
    fmt.Println("Alice:", value) // Alice: 25
}

🟠Проверка существования ключа
Для этого используется синтаксис двойного присваивания

value, exists := myMap[key]

Пример

package main

import "fmt"

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

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

🚩Запись значений

🟠Добавление или обновление значения
Для этого используется синтаксис индексирования:

myMap[key] = value

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{}

    // Добавление значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    fmt.Println("Map:", myMap) // Map: map[Alice:25 Bob:30]

    // Обновление значения
    myMap["Alice"] = 26
    fmt.Println("Updated Map:", myMap) // Updated Map: map[Alice:26 Bob:30]
}

🟠Удаление значений из карты
Для этого используется встроенная функция delete:

delete(myMap, key)

Пример

package main

import "fmt"

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

    // Удаление значения по ключу
    delete(myMap, "Alice")
    fmt.Println("Map after deletion:", myMap) // Map after deletion: map[Bob:30]
}

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

🟠Отсутствие ключа
Если ключ отсутствует в карте, при попытке получения значения будет возвращено нулевое значение типа значения карты. Например, для карты map[string]int это будет 0.

        package main

    import "fmt"

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

        value := myMap["Bob"] // Ключ "Bob" отсутствует
        fmt.Println("Value:", value) // Value: 0
    }
    

🟠Запись в неинициализированную карту
Нельзя записывать значения в nil карту. Это приведет к панике времени выполнения.

        package main

    func main() {
        var myMap map[string]int // nil карта
        myMap["Alice"] = 25      // Вызовет панику: runtime error: assignment to entry in nil map
    }
    

🟠Итерация по карте
Порядок итерации по карте не определен и может различаться между разными запусками программы.

        package main

    import "fmt"

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

        for key, value := range myMap {
            fmt.Printf("%s: %d\n", key, value)
        }
    }

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

🤔 У ресивера имеется звёздочка — что это значит?

Если у метода ресивер с *, это означает, что метод работает с указателем на объект, а значит:
- изменения внутри метода повлияют на оригинальный объект;
- метод может модифицировать поля структуры;
- вызов возможен как на указателе, так и на значении (Go сам "разыменует").
Такой метод можно вызывать и на value, и на pointer — Go сделает автоматическую конвертацию.

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

🤔 Есть отличия между SSL и TLS?

Да, между SSL (Secure Sockets Layer) и TLS (Transport Layer Security) есть отличия. TLS является улучшенной и более безопасной версией SSL.

🚩История и версия

🟠SSL:
SSL 1.0: Никогда не был выпущен публично из-за серьезных уязвимостей.
SSL 2.0: Выпущен в 1995 году, но вскоре был признан небезопасным из-за множества уязвимостей.
SSL 3.0: Выпущен в 1996 году, значительно улучшил безопасность, но со временем также был признан устаревшим из-за уязвимостей (например, POODLE-атака).

🟠TLS:
TLS 1.0: Выпущен в 1999 году как обновление SSL 3.0. Включает исправления безопасности и улучшения.
TLS 1.1: Выпущен в 2006 году с дополнительными защитами от некоторых атак.
TLS 1.2: Выпущен в 2008 году, поддерживает современные алгоритмы шифрования и хеширования.
TLS 1.3: Выпущен в 2018 году, значительно улучшена безопасность и производительность, упрощен процесс установки соединения.

🚩Технические отличия

🟠Алгоритмы шифрования:
SSL: Поддерживает более старые и менее безопасные алгоритмы шифрования.
TLS: Поддерживает более современные и безопасные алгоритмы шифрования. TLS 1.3 исключает поддержку устаревших алгоритмов и предлагает только современные безопасные алгоритмы.

🟠Процесс рукопожатия (Handshake):
SSL: Более сложный процесс рукопожатия, включающий несколько шагов, что делает его уязвимым для некоторых атак.
TLS: Улучшенный процесс рукопожатия, включая использование HMAC (Hash-based Message Authentication Code) для обеспечения целостности сообщения. TLS 1.3 значительно упрощает и ускоряет процесс рукопожатия.

🟠Целостность данных:
SSL: Использует комбинацию MD5 и SHA-1 для целостности данных, что не так безопасно по современным стандартам.
TLS: Использует HMAC с SHA-256 и другими современными алгоритмами для обеспечения целостности данных.

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

🚩Безопасность

🟠SSL: Уязвим для ряда атак, таких как POODLE, BEAST и другие, из-за устаревших и менее безопасных методов шифрования и проверки целостности.
🟠TLS: Значительно более безопасен благодаря устранению уязвимостей SSL и внедрению современных методов шифрования и проверки целостности. TLS 1.3 еще более безопасен благодаря исключению устаревших методов и упрощению процесса рукопожатия.

🚩Совместимость

🟠SSL: Практически не используется в современных системах из-за известных уязвимостей и устаревших методов безопасности.
🟠TLS: Широко поддерживается и используется в современных браузерах, серверах и других сетевых устройствах. TLS 1.2 и TLS 1.3 являются наиболее часто используемыми версиями.

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

🤔 Что из себя представляет тип данных string в языке Go?

Тип string в Go — это последовательность байтов, закодированных в UTF-8.
Он реализован как структура:
- указатель на массив байтов;
- длина строки.
Строки неизменяемы. Любая операция, которая кажется «изменением», на самом деле создаёт новую строку.

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

🤔 Можно ли изменить определенный символ в строке?

Нет, строки (string) в Go неизменяемы (immutable). Это значит, что нельзя просто изменить один символ в строке.

🚩Почему нельзя изменить символ?

Строка в Go — это байтовый срез ([]byte), но неизменяемый. Когда вы создаёте строку

s := "hello"

Ошибка при попытке изменения символа напрямую

s := "hello"
s[0] = 'H' // Ошибка: cannot assign to s[0]

🚩Как изменить символ в строке?

Поскольку строка неизменяема, вам нужно создать новую строку с заменённым символом.
Способ 1: Преобразовать в []byte (для ASCII-строк)
Если строка содержит только английские буквы и символы ASCII, её можно преобразовать в []byte, заменить символ и создать новую строку.

package main

import "fmt"

func main() {
    s := "hello"
    b := []byte(s) // Преобразуем в изменяемый []byte
    b[0] = 'H'     // Меняем первый символ
    s = string(b)  // Преобразуем обратно в строку

    fmt.Println(s) // "Hello"
}

Способ 2: Преобразовать в []rune (для Unicode)
Если строка содержит русские буквы, эмодзи или другие многобайтовые символы, используйте []rune.

package main

import "fmt"

func main() {
    s := "привет"
    r := []rune(s) // Преобразуем в []rune (массив символов)
    r[0] = 'П'     // Меняем первый символ
    s = string(r)  // Преобразуем обратно в строку

    fmt.Println(s) // "Привет"
}

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

🤔 В чём отличие UInt от Int?

- Int — знаковое целое число, может быть как положительным, так и отрицательным.
- UInt — беззнаковое целое число, только 0 и положительные значения.
UInt полезен, если ты точно знаешь, что число не может быть отрицательным (например, размер массива). Однако арифметические операции между Int и UInt требуют явного преобразования.

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

🤔 Что такое составной индекс?

Составной индекс (Composite Index) — это индекс, который создаётся сразу на нескольких колонках таблицы базы данных. Он помогает ускорить поиск и сортировку данных, особенно если запросы используют условия по нескольким полям.

🚩Зачем нужен составной индекс?

🟠Оптимизация запросов
Если часто выполняются запросы с фильтрацией по нескольким колонкам (WHERE col1 = X AND col2 = Y), составной индекс ускоряет их выполнение.
🟠Ускорение сортировки
Если запросы используют ORDER BY col1, col2, индекс помогает избежать дополнительной сортировки.
🟠Снижение нагрузки на сервер
Без индекса СУБД вынуждена выполнять полный перебор (Full Table Scan), что занимает больше времени.

🚩Как работает составной индекс?

Он строится по нескольким колонкам и фактически представляет собой отсортированную структуру данных. Например, в PostgreSQL или MySQL создаётся так:

CREATE INDEX idx_name ON users (last_name, first_name);

Теперь база данных будет использовать индекс для запросов:

SELECT * FROM users WHERE last_name = 'Иванов' AND first_name = 'Петр';

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

🤔 В чем ключевое различие слайса от массива?

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

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

🤔 По какому алгоритму растет slice?

В Go срезы (slice) динамически изменяемы, и при добавлении новых элементов их вместимость (capacity) увеличивается по определённому алгоритму.

🚩Как растёт `slice` в Go?

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

🚩Алгоритм роста:

Если cap(slice) < 1024, то новая ёмкость (capacity) удваивается.
Если cap(slice) >= 1024, то увеличение идёт примерно на 25% от текущего размера.

package main

import "fmt"

func main() {
    var s []int
    prevCap := cap(s)

    for i := 0; i < 20; i++ {
        s = append(s, i)
        if cap(s) != prevCap {
            fmt.Printf("Len: %d, New Cap: %d (growth: %.2fx)\n", len(s), cap(s), float64(cap(s))/float64(prevCap))
            prevCap = cap(s)
        }
    }
}

Выходные данные (может отличаться в зависимости от реализации Go)

Len: 1, New Cap: 1 (growth: Inf)
Len: 2, New Cap: 2 (growth: 2.00x)
Len: 3, New Cap: 4 (growth: 2.00x)
Len: 5, New Cap: 8 (growth: 2.00x)
Len: 9, New Cap: 16 (growth: 2.00x)
Len: 17, New Cap: 32 (growth: 2.00x)

🚩Почему так?

🟠Экономия памяти
если бы рост был на 1 элемент, то это вызывало бы частые копирования.
🟠Скорость работы
экспоненциальный рост уменьшает количество выделений памяти.

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

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

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

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

🤔 Как строки работают в Golang внутри?

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

🚩Неизменяемость

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

🚩Структура строки

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

🚩UTF-8 как стандартная кодировка

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

🚩Срезы строк

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

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

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

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

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

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

🤔 Чем stream отличается от unary?

Эти термины часто встречаются в gRPC и API:
- Unary — классический вызов: клиент делает запрос, сервер возвращает единственный ответ.
- Stream — потоковая передача:
- Server streaming — сервер отправляет несколько ответов.
- Client streaming — клиент отправляет поток данных.
- Bidirectional — оба обмениваются потоками данных.
Streaming нужен, когда нужно передавать большие объёмы или непрерывный поток данных.

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

🤔 В чем разница процесса и потока в рамках операционной системы?

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

🚩Процесс

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

🚩Поток (Thread)

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

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

🟠Изоляция
Процессы изолированы друг от друга, в то время как потоки делят состояние и ресурсы внутри одного процесса.

🟠Память
Каждый процесс имеет собственное адресное пространство, в то время как все потоки внутри процесса делят его адресное пространство.

🟠Создание и управление
Создание нового процесса более ресурсоемко, чем создание потока внутри существующего процесса.

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

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

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

🤔 В какой момент инициализированное значение переменной передается в defer, как это связано с именованием функции?

Значения, передаваемые в defer, фиксируются в момент объявления defer, а не в момент выполнения.
Если ты передаёшь результат выражения, он вычисляется сразу, а отложенный вызов запоминает результат.
Но если используется именованная возвращаемая переменная, и она изменяется внутри defer, то её новое значение попадает в результат. Это позволяет, например, изменить результат функции прямо из defer-блока.

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