🤔 Что такое runtime (планировщик scheduler)?

Планировщик (scheduler) — это часть Go runtime, которая отвечает за распределение горутин по потокам, их запуск, приостановку и возобновление.
Он работает кооперативно, то есть горутина должна "добровольно" уступить выполнение (например, при channel, sleep, IO).

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

🤔 Есть отличия между 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 являются наиболее часто используемыми версиями.

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

🤔 Как реализован ООП в Go и C#?

1. Go:
- Нет классов, используется композиция через структуры и методы.
- Полиморфизм достигается с помощью интерфейсов.
- Наследования нет, встраивание заменяет его.
2. C#:
- Полноценное ООП: классы, наследование, абстракция, интерфейсы.
- Поддержка модификаторов доступа (public, private, protected).
- Разработано для объектно-ориентированной модели с полной поддержкой инкапсуляции и полиморфизма.

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

🤔 Какие недостатки есть у Go?

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

➖Отсутствие дженериков (до Go 1.18)
До введения дженериков, одним из основных недостатков языка было отсутствие поддержки дженериков, что приводило к тому, что разработчики должны были использовать интерфейсы и тип interface{} для создания функций и структур, работающих с различными типами данных. Это могло привести к ухудшению производительности и увеличению сложности кода.

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

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

➖Неиммутабельные строки
Неизменяемы, что может привести к неэффективному использованию памяти и времени процессора при частой модификации строк, например, в циклах или больших объёмах текстовых данных.

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

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

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

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

🤔 Что такое утиная типизация?

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

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

🤔 Что такое хэш-таблица?

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

🚩Основные компоненты

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

🟠Хэш-таблица
Массив фиксированного размера, где каждый элемент называется "корзиной" (bucket). Корзина может содержать одно или несколько значений.

🟠Коллизии
Ситуация, когда два разных ключа хешируются в один и тот же индекс. Коллизии решаются с помощью различных методов, таких как цепочки (chaining) или открытая адресация (open addressing).

🚩Принцип работы

🟠Вставка
Хеш-функция вычисляет индекс для данного ключа. Значение помещается в соответствующую корзину по этому индексу. Если возникает коллизия, используется метод разрешения коллизий.

🟠Поиск
Хеш-функция вычисляет индекс для ключа. Корзина по этому индексу проверяется на наличие значения. Если значение найдено, оно возвращается; если нет, возвращается индикатор отсутствия значения.

🟠Удаление
Хеш-функция вычисляет индекс для ключа. Значение удаляется из соответствующей корзины. При необходимости корректируются ссылки или структура данных для разрешения коллизий.

🚩Плюсы и минусы

➕Быстрый доступ
Среднее время доступа к элементу составляет O(1).
➕Простота использования
Обеспечивает простой интерфейс для вставки, поиска и удаления данных.
➖Коллизии
Требуют дополнительных механизмов для разрешения, что может усложнить реализацию.
➖Зависимость от хеш-функции
Эффективность хэш-таблицы зависит от качества хеш-функции.
➖Перераспределение
При увеличении количества элементов может потребоваться перераспределение и увеличение размера таблицы, что временно снижает производительность.

package main

import "fmt"

func main() {
    // Создание карты
    myMap := make(map[string]int)

    // Вставка значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    // Поиск значений
    value, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice:", value) // Alice: 25
    } else {
        fmt.Println("Alice not found")
    }

    // Удаление значений
    delete(myMap, "Alice")
    _, exists = myMap["Alice"]
    if !exists {
        fmt.Println("Alice has been deleted") // Alice has been deleted
    }
}

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

🤔 Что такое nil-канал и что будет, если писать и читать из него?

Это неинициализированный канал (var ch chan int).
- Чтение из nil-канала – блокирует горутину навсегда.
- Запись в nil-канал – блокирует горутину навсегда.
Nil-каналы используются для динамического управления каналами в select, когда временно не нужно обрабатывать канал.

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

🤔 Как устроена объектоориентированная модель?

Объектно-ориентированная модель отличается от традиционных ООП-языков, таких как C# или Java. Нет классов и наследования в привычном понимании. Вместо этого используются структуры (structs) и интерфейсы для реализации основных принципов ООП: инкапсуляции, композиции и полиморфизма.

🚩Концепции

🟠Структуры (Structs)
Служат аналогом классов. Они позволяют объединять данные в логически связанные группы.

type Person struct {
    Name string
    Age  int
}

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

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

🟠Инкапсуляция
Достигается через модификаторы доступа на уровне пакета. Поля и методы, начинающиеся с заглавной буквы, экспортируемые (public), остальные — нет (private).

type Person struct {
    name string // неэкспортируемое поле
    Age  int    // экспортируемое поле
}

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

type Employee struct {
    Person
    Position string
}

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

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Person struct {
    Name string
}

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

func main() {
    p := Person{Name: "John"}
    SayHello(p)
}

🟠Полиморфизм
Достигается через интерфейсы. Любой тип, который реализует интерфейс, может быть использован вместо него.

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Robot struct {
    ID string
}

func (r Robot) Greet() {
    fmt.Printf("Greetings, I am robot %s\n", r.ID)
}

func main() {
    p := Person{Name: "John"}
    r := Robot{ID: "XJ-9"}

    SayHello(p)
    SayHello(r)
}

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

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

Go поддерживает только цикл for, который можно использовать как:
Классический цикл с условиями (for i := 0; i < 10; i++).
Цикл с проверкой условия (for i < 10).
Бесконечный цикл (for {}), который останавливается вручную через break.

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

🤔 Возможен ли JOIN со вложенными запросами?

Да, в SQL возможен JOIN с вложенными запросами. Это позволяет объединять результаты подзапросов с другими таблицами, что полезно, когда нужно предварительно отфильтровать или агрегировать данные перед объединением.

🚩Как это работает?

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

🚩Пример: JOIN с подзапросом

Допустим, у нас есть две таблицы:
- orders (id, user_id, total)
- users (id, name)
Мы хотим получить всех пользователей и их заказы, но только те заказы, где сумма больше 100

SELECT u.name, sub.total
FROM users u
JOIN (
    SELECT user_id, total
    FROM orders
    WHERE total > 100
) AS sub ON u.id = sub.user_id;

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

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

Чтобы создать методы, доступные извне (в других пакетах), нужно:
- Объявить тип (структуру, интерфейс и т.п.).
- Определить метод с экспортируемым именем (с заглавной буквы).
- Поместить его в нужный пакет.
- Импортировать пакет и использовать метод по имени типа.
Метод становится доступным из другого пакета только если его имя начинается с заглавной буквы. Это основное правило экспорта в Go.

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

🤔 Как устроен слайс в Go ?

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

🚩Структура

🟠Указатель на базовый массив
Указатель на первый элемент массива, на который ссылается слайс.
🟠Длина (length)
Количество элементов, доступных в слайсе.
🟠Емкость (capacity)
Максимальное количество элементов, которое может содержать слайс без перераспределения памяти.

🚩Внутреннее устройство

Можно представить в виде структуры

type slice struct {
    ptr *ElementType // Указатель на базовый массив
    len int          // Длина
    cap int          // Емкость
}

🟠Слайс из массива
Можно создать из массива, указав диапазон элементов:

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(slice) // [2 3 4]
}

🟠Слайс с использованием функции make
Позволяет создать слайс определенной длины и емкости:

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5) // Слайс длиной 3 и емкостью 5
    fmt.Println(slice)         // [0 0 0]
}

🟠Доступ к элементам слайса
Осуществляется так же, как и к элементам массива:

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println(slice[0]) // 1
    slice[1] = 10
    fmt.Println(slice)    // [1 10 3 4 5]
}

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

🟠Добавление элементов
Для этого используется функция append

package main

import "fmt"

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

🟠Извлечение подмножества слайса (slicing)
Можно создавать новые слайсы на основе существующих

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    subSlice := slice[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(subSlice)  // [2 3 4]
}

🟠Копирование слайсов
Для этого используется функция copy

package main

import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    copy(dst, src)
    fmt.Println(dst) // [1 2 3]
}

🚩Динамическое изменение длины и емкости

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

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5)
    fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 1, 2, 3)
    fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 4)
    fmt.Println("After another append:", slice, "Len:", len(slice), "Cap:", cap(slice))
}

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

🤔 Зачем нужны транзакции?

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

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

🤔 Зачем нужны таймауты при http запросах?

Таймауты (timeout) в HTTP-запросах предотвращают зависание приложения при медленных или недоступных серверах. Они позволяют ограничить время ожидания ответа, чтобы избежать бесконечного ожидания и высвободить ресурсы.

🚩Основные типы таймаутов в Go (`net/http`)

В Golang таймауты можно устанавливать на разных уровнях:
Timeout для всего запроса (включает подключение, отправку и получение данных)

   client := &http.Client{
       Timeout: 5 * time.Second, // Запрос не может длиться дольше 5 секунд
   }

Таймаут на установку соединения

   transport := &http.Transport{
       DialContext: (&net.Dialer{
           Timeout: 2 * time.Second, // 2 секунды на подключение
       }).DialContext,
   }
   client := &http.Client{Transport: transport}

Таймаут на чтение и запись

   transport := &http.Transport{
       ResponseHeaderTimeout: 3 * time.Second, // 3 секунды на заголовки
   }

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

🤔 Что такое метод?

Метод в Go — это функция, привязанная к конкретному типу (обычно к структуре). Он отличается от обычной функции тем, что имеет ресивер.

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

🤔 Для чего используют индексы?

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

🚩Для чего нужны индексы?

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

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

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

🟠Оптимизация поиска
Индексы упрощают и ускоряют доступ к данным, потому что доступ осуществляется за O(1) (константное время) в массивах или срезах.

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

package main

import "fmt"

func main() {
    str := "Привет"
    
    fmt.Println(str[0])           // 208 (байт, не символ!)
    fmt.Printf("%c\n", str[0])    // П (символ, представленный первым байтом UTF-8)
}

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

package main

import "fmt"

func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    
    fmt.Println(arr[2]) // 30
    
    // Изменение значения по индексу
    arr[2] = 100
    fmt.Println(arr) // [10 20 100 40 50]
}

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

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30, 40, 50}
    
    for i, v := range nums {
        fmt.Printf("Индекс: %d, Значение: %d\n", i, v)
    }
}

🟠Индексы и подстроки
Индексы полезны для извлечения подстрок с использованием срезов:

package main

import "fmt"

func main() {
    str := "Привет, Мир!"
    
    fmt.Println(str[8:12]) // Мир
}

🚩Ошибки работы с индексами

🟠Выход за границы
Если попытаться обратиться к элементу по индексу, который выходит за пределы коллекции, Go выдаст runtime panic:

   package main

   func main() {
       nums := []int{1, 2, 3}
       fmt.Println(nums[5]) // panic: runtime error: index out of range
   }
   

🟠Работа с многобайтовыми символами в строках
Если неверно учитывать байтовое представление символов UTF-8, можно получить некорректный результат.

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

🤔 Что такое lock-free структуры данных, и есть ли в Go такие?

Lock-free структуры данных обеспечивают потокобезопасность без мьютексов, используя атомарные операции. Они более эффективны для высокопроизводительных систем. В Go можно создавать такие структуры с помощью пакета sync/atomic, но готовых реализаций немного.

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

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

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

🚩Основы нарезки

Синтаксис

newSlice := originalSlice[start:end]

start: начальный индекс (включительно).
end: конечный индекс (исключительно).

Пример

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    newSlice := original[1:4] // Элементы с индексами 1, 2 и 3
    fmt.Println(newSlice) // [2 3 4]
}

🚩Нюансы и подводные камни

🟠Индекс выхода за границы
При нарезке слайса важно, чтобы индексы start и end были в пределах длины исходного слайса. Нарушение этого правила приведет к панике (runtime panic).

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       
       // Это вызовет панику: runtime error: slice bounds out of range
       // newSlice := original[1:6]
       
       // Правильное использование
       newSlice := original[1:5]
       fmt.Println(newSlice) // [2 3 4 5]
   }
   

🟠Модификация исходного слайса
Слайсы в Go работают как ссылки на массивы. Это означает, что если вы модифицируете элементы нового слайса, то изменения отразятся и в исходном слайсе.

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 20 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

🟠Изменение длины и емкости
Длина нового слайса определяется как end - start. Емкость нового слайса определяется как cap(original) - start.

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       fmt.Println("New Slice Length:", len(newSlice)) // 3
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 4
   }
   

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

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := make([]int, 3)
       copy(newSlice, original[1:4])
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 2 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

🟠Использование полной формы нарезки
Полная форма нарезки позволяет явно указать емкость нового слайса:

newSlice := original[start:end:max

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

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:3:4]
       fmt.Println("New Slice:", newSlice) // [2 3]
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 3
   }
   

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