🤔 Что такое HAVING?

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

🚩Чем отличается `HAVING` от `WHERE`?

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

Теперь посчитаем сумму продаж по категориям и оставим только те, где сумма > 250

SELECT category, SUM(amount) AS total_sales
FROM sales
GROUP BY category
HAVING SUM(amount) > 250;

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

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

Это структуры данных, которые ускоряют поиск строк в таблицах MySQL. Они работают аналогично оглавлению в книге, позволяя БД быстро находить нужные записи без полного сканирования таблицы.

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

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

В Go метод можно привязывать как к значению структуры, так и к указателю на структуру.
Если у ресивера (receiver) перед именем типа стоит *, это значит, что метод принимает указатель на структуру, а не саму структуру.

🚩Разница между `T` и `*T` в методах

🟠Метод с ресивером-значением (`T`)
Метод работает с копией структуры, а не с оригиналом.

package main

import "fmt"

type Person struct {
    Name string
}

// Метод работает с копией, оригинал не изменится
func (p Person) SetName(name string) {
    p.Name = name
}

func main() {
    p := Person{Name: "Alice"}
    p.SetName("Bob")
    fmt.Println(p.Name) // Выведет: Alice (не изменилось)
}

🟠Метод с ресивером-указателем (`*T`)
Метод работает с оригиналом и может изменять его поля.

type Person struct {
    Name string
}

// Метод изменяет оригинал структуры
func (p *Person) SetName(name string) {
    p.Name = name
}

func main() {
    p := Person{Name: "Alice"}
    p.SetName("Bob")
    fmt.Println(p.Name) // Выведет: Bob (изменилось!)
}

🚩 Когда использовать `*T`?

Если метод изменяет структуру → нужен указатель (*T).
Если метод только читает данные → можно использовать значение (T).
Использование *T также избегает копирования больших структур.

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

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

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

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

🤔 Что такое mutex, какие они бывают и как их использовать?

Mutex (от Mutual Exclusion — взаимное исключение) — это примитив синхронизации, который используется для защиты критических секций ресурса или данных, доступ к которым должен быть ограничен таким образом, чтобы только один поток или горутина могли работать с ним в каждый конкретный момент времени. Mutex гарантирует, что только один поток может входить в защищённую секцию кода, выполняющую операции над общими данными.

🚩Какие бывают Mutex

🟠Блокирующие Mutex (Blocking Mutexes)
Это наиболее распространённый тип мьютексов. При попытке захватить мьютекс, если он уже занят другим потоком, поток блокируется и ожидает, пока мьютекс не будет освобождён.

🟠Неблокирующие Mutex (Non-blocking or Spinlocks)
Вместо блокирования потока, потоки активно проверяют состояние мьютекса в цикле. Это может быть эффективно, если мьютекс захватывается на очень короткое время, так как избегается затрата времени на блокировку и разблокировку потока.

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

Стандартная библиотека предоставляет мьютекс в пакете sync. Вот пример того, как можно использовать мьютекс для синхронизации доступа к общему ресурсу:

package main

import (
    "fmt"
    "sync"
)

var (
    balance int
    mutex   sync.Mutex
)

func deposit(value int, wg *sync.WaitGroup) {
    mutex.Lock() // Захват мьютекса перед изменением переменной balance
    fmt.Printf("Depositing %d to account with balance: %d\n", value, balance)
    balance += value
    mutex.Unlock() // Освобождение мьютекса после изменения
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go deposit(100, &wg)
    go deposit(200, &wg)
    wg.Wait()
    fmt.Printf("New Balance %d\n", balance)
}

🚩Рекомендации по использованию

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

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

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

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

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

🤔 Как передаются параметры в функцию — по указателю или по значению?

По умолчанию в Go все параметры передаются по значению, т.е. копируются.
Но если передать указатель на переменную, можно изменить её содержимое. Это единственный способ передать значение по ссылке.
Тип *T указывает, что это указатель, а не значение.

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

🚨 60 минут до финала

Через час мы закроем краудфандинг easyoffer 2.0
Это последний шанс вписаться в самые выгодные условия.

👉 https://planeta.ru/campaigns/easyoffer

🤔 Можно ли сделать int(string) и string(int) соответственно?

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

🚩Преобразование строки в целое число

Для этого используется функция strconv.Atoi. Она возвращает два значения: само число и ошибку, если преобразование не удалось.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "123"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error converting string to int:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

🚩Преобразование целого числа в строку

Для этого используется функция strconv.Itoa.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 123
    str := strconv.Itoa(num)
    fmt.Println("Converted string:", str)
}

🚩Обработка ошибок при преобразовании

Важно обрабатывать ошибки при преобразовании типов, особенно при преобразовании строки в целое число, чтобы избежать неожиданных сбоев в программе.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "abc"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

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

🤔 Как можно откопировать слайс?

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

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

🤔 Как строки работают в 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

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

🤔 Что известно про паттерн Factory (Фабрика)?

Factory — это паттерн, скрывающий логику создания объектов за единым интерфейсом. Он позволяет:
- инкапсулировать создание объектов разного типа;
- выбирать реализацию в зависимости от условий;
- отделить клиентский код от конкретных типов.
Пример: создание разных видов подключений (TCP, HTTP, WebSocket) через одну фабрику, возвращающую интерфейс Connection.

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

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

В 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
}

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

🤔 Какой вес у пустой структуры?

Пустая структура в Go (struct{}) занимает 0 байт.
Она не содержит ни одного поля, и компилятор оптимизирует её до нуля. Это удобно, например, для использования в map[T]struct{} — в качестве множества без нагрузки на память.

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

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

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

🟠Управление временем выполнения операций
Контексты позволяют задавать дедлайны и таймауты для операций.
context.WithTimeout создает контекст с таймаутом, после которого операция будет автоматически отменена.

ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)
defer cancel()

context.WithDeadline создает контекст с дедлайном, который определяет точное время, после которого операция будет отменена.

deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(parentCtx, deadline)
defer cancel()

🟠Явная отмена операций
Контексты позволяют явно отменять операции, что полезно для управления горутинами и предотвращения утечек памяти.
context.WithCancel создает контекст, который может быть отменен вручную с помощью функции cancel.

ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

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

type key string
ctx := context.WithValue(parentCtx, key("userID"), 12345)

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

ctx1, cancel1 := context.WithCancel(parentCtx)
ctx2, cancel2 := context.WithTimeout(ctx1, 1*time.Second)
defer cancel1()
defer cancel2()

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

var wg sync.WaitGroup
ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

wg.Add(2)
go func() {
    defer wg.Done()
    worker(ctx, "Worker 1")
}()
go func() {
    defer wg.Done()
    worker(ctx, "Worker 2")
}()
wg.Wait()

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(1 * time.Second)
        }
    }
}

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

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "Request processed")
    case <-ctx.Done():
        err := ctx.Err()
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)

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