🤔 Как называется структура, которая копирует, когда что-либо передаешь?

Такая структура называется значимым типом (value type).
Когда ты передаёшь её в функцию или присваиваешь другой переменной, создаётся копия значения, а не ссылка. В Go к value types относятся: int, float, bool, struct, array.

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

🤔 Сколько весит число в байтах?

Размер числа в байтах зависит от его типа данных. В Go есть несколько числовых типов, и каждый занимает определённое количество байтов в памяти.

🚩Проверка размера в Go (`unsafe.Sizeof`)

Можно проверить размер типа с помощью unsafe.Sizeof()

package main

import (
  "fmt"
  "unsafe"
)

func main() {
  var a int64
  var b float64
  var c byte // то же самое, что uint8
  fmt.Println("int64:", unsafe.Sizeof(a))   // 8
  fmt.Println("float64:", unsafe.Sizeof(b)) // 8
  fmt.Println("byte:", unsafe.Sizeof(c))    // 1
}

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

🤔 Что такое сага?

Это архитектурный паттерн управления долгоживущими распределёнными транзакциями.
Вместо одной глобальной транзакции, используется последовательность локальных операций, каждая из которых имеет компенсирующее действие, если что-то пошло не так.
Применяется в микросервисной архитектуре, где нельзя использовать обычные транзакции между сервисами. Есть два варианта исполнения: оркестрация (центральный координатор) и хореография (сервисы реагируют на события друг друга).

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

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

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

🚩Основы

Могут быть типизированы, что означает, что канал может передавать значения только одного определённого типа. Они могут быть объявлены и инициализированы с помощью ключевого слова chan:

ch := make(chan int) // Канал для передачи значений типа int

🚩Отправка и получение данных

Для отправки значения в канал используется оператор <-:

ch <- 10 // Отправка значения 10 в канал

Для получения значения из канала тот же оператор используется, но в другом контексте:

value := <-ch // Прочитать значение из канала и присвоить его переменной value

🚩Блокировки

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

🚩Буферизация

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

ch := make(chan int, 5) // Буферизированный канал с размером буфера 5

В буферизированном канале отправка не блокируется до тех пор, пока буфер не заполнится, и получение не блокируется до тех пор, пока буфер не опустеет.

🚩Закрытие каналов

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

close(ch)

Проверка на то, что канал закрыт и данные исчерпаны, возможна в операции чтения:

value, ok := <-ch
if !ok {
    // Канал закрыт и все данные получены
}

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

🤔 В чем отличия HTTP 1.1 и HTTP 2?

HTTP/2 поддерживает мультиплексирование запросов, бинарный формат и сжатие заголовков, что делает его быстрее, чем текстовый и последовательный HTTP/1.1.

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

🤔 В чем разница между императивным и декларативным?

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

🚩Императивное программирование

Это стиль программирования, где выражается последовательность команд для выполнения задач. В этом подходе программист указывает машине, как изменять своё состояние пошагово, контролируя поток выполнения через управляющие конструкции, такие как циклы, условные операторы и т.д.
🟠Подробное описание процесса
Программист должен указывать все шаги, которые необходимо выполнить для достижения результата.
🟠Примеры языков
Java, C, Python в их традиционном использовании.
🟠Управление состоянием
Императивные программы часто включают явное управление состоянием и его изменениями.

# Императивный подход к сортировке массива методом пузырька
def bubble_sort(array):
    n = len(array)
    for i in range(n):
        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return array

🚩Декларативное программирование

Это стиль программирования, где описывается желаемый результат, но не детализируется процесс его достижения. В декларативном стиле программа определяет, что должно быть сделано, а не как.
🟠Абстракция от процесса
Описываются желаемые свойства результата, а система сама определяет, как его достичь.
🟠Примеры языков
SQL, HTML, CSS, функциональные языки программирования, такие как Haskell.
🟠Сокрытие сложности
Декларативный подход часто предполагает высокий уровень абстракции, что уменьшает количество деталей, которые нужно учитывать.

-- Декларативный запрос в SQL для получения списка сотрудников, отсортированного по зарплате
SELECT name, salary FROM employees ORDER BY salary DESC;

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

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

🟠Управление состоянием
Императивный подход требует активного управления состоянием программы, в то время как в декларативном подходе состояние управляется системой или вовсе абстрагировано.

🟠Поддержка языка
Разные языки поддерживают разные стили программирования. Некоторые языки, как JavaScript, могут поддерживать оба стиля в зависимости от использования.

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

🤔 Что будет, если подставить переменную в массив?

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

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

🤔 Какие функции у map?

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

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

🟠Объявление карты
Для этого используется ключевое слово map, после которого указываются типы ключей и значений.

var myMap map[string]int

🟠Инициализация карты
Это можно сделать с помощью функции make или литерала карты.

// Инициализация с помощью make
myMap = make(map[string]int)

// Инициализация с помощью литерала карты
myMap = map[string]int{
    "Alice": 25,
    "Bob":   30,
}

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

myMap["Charlie"] = 35
myMap["Alice"] = 26 // обновление значения по ключу "Alice"

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

age := myMap["Alice"]
fmt.Println(age) // 26

🟠Проверка существования ключа
Чтобы проверить это можно использовать двойное присваивание.

age, exists := myMap["David"]
if exists {
    fmt.Println("Age of David:", age)
} else {
    fmt.Println("David not found")
}

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

delete(myMap, "Bob")

🟠Итерация по карте
Для этого используется цикл for range.

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

Пример

package main

import (
    "fmt"
)

func main() {
    // Инициализация карты с помощью литерала
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // Добавление нового элемента
    myMap["Charlie"] = 35

    // Обновление существующего элемента
    myMap["Alice"] = 26

    // Извлечение значения по ключу
    age := myMap["Alice"]
    fmt.Println("Age of Alice:", age) // 26

    // Проверка существования ключа
    age, exists := myMap["David"]
    if exists {
        fmt.Println("Age of David:", age)
    } else {
        fmt.Println("David not found")
    }

    // Удаление элемента
    delete(myMap, "Bob")

    // Итерация по карте
    for key, value := range myMap {
        fmt.Printf("Key: %s, Value: %d\n", key, value)
    }
}

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

🤔 Как устроены горутины, сколько памяти они занимают в стеке?

Горутины — это легковесные потоки, управляемые рантаймом Go, а не ОС.
Каждая горутина:
- Получает начальный стек размером ~2 КБ.
- Имеет собственные регистры состояния и структуру для планирования.
- Может перераспределять стек по мере роста (growable stack), что экономит ресурсы.
Благодаря этому в Go можно создать десятки или сотни тысяч горутин, в отличие от потоков ОС.

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

🤔 Что такое структура (stuct) в Go Зачем они нужны?

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

🚩Определение структуры

Определяются с использованием ключевого слова struct. В структуре могут быть поля различных типов.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Создание экземпляра структуры
    var p Person
    p.Name = "Alice"
    p.Age = 30

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

🚩Инициализация структур

Существует несколько способов инициализации структур.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация с использованием литерала структуры
    p := Person{Name: "Bob", Age: 25}
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

Инициализация по умолчанию

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация по умолчанию (поля будут нулевыми значениями)
    var p Person
    fmt.Println("Name:", p.Name) // Пустая строка
    fmt.Println("Age:", p.Age)   // 0
}

🚩Вложенные структуры

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

package main

import "fmt"

// Определение структур Address и Person
type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    // Инициализация структуры с вложенной структурой
    p := Person{
        Name: "Charlie",
        Age:  40,
        Address: Address{
            City:  "New York",
            State: "NY",
        },
    }

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
    fmt.Println("City:", p.Address.City)
    fmt.Println("State:", p.Address.State)
}

🚩Методы структур

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

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

// Метод для структуры Person
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{Name: "David", Age: 35}
    p.Greet()
}

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

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

🤔 Почему поиск в B-tree работает быстрее, чем линейный перебор?

B-tree (сбалансированное дерево) организует данные так, чтобы:
- Быстро сужать поиск на каждом уровне.
- Работать эффективно с дисковой памятью (большие блоки и минимум обращений). Линейный перебор проходит все элементы, а B-tree уменьшает количество операций до логарифмического времени — особенно важно при работе с большими объёмами данных.

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

🤔 Почему пустой интерфейс можно привести к любому типу?

В Go пустой интерфейс interface{} является особым типом, который может содержать значение любого типа. Это связано с тем, что в Go любой тип реализует пустой интерфейс, поскольку в нем нет методов, которые нужно реализовать.

🚩Пустой интерфейс

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

type interface{} interface {}

🚩Внутреннее представление интерфейсов в Go

🟠Type
Типа конкретного значения
🟠Value
Самого значения

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

🚩Приведение пустого интерфейса к конкретному типу

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

Присваивание значений пустому интерфейсу

package main

import "fmt"

func main() {
    var i interface{}
    i = 42
    fmt.Println(i) // 42

    i = "hello"
    fmt.Println(i) // hello
}

Утверждение типа (Type Assertion)

package main

import "fmt"

func main() {
    var i interface{} = "hello"

    // Утверждение типа с проверкой
    s, ok := i.(string)
    if ok {
        fmt.Println("String:", s)
    } else {
        fmt.Println("Not a string")
    }

    // Утверждение типа без проверки
    // Это вызовет панику, если тип не соответствует
    s = i.(string)
    fmt.Println("String:", s)
}

Использование switch для проверки типа

package main

import "fmt"

func printType(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Integer:", v)
    case bool:
        fmt.Println("Boolean:", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    printType("hello")
    printType(42)
    printType(true)
    printType(3.14)
}

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

🤔 Чем отличается конкурентность от параллелизма?

- Конкурентность (concurrency) — это способность обрабатывать несколько задач одновременно, переключаясь между ними (в т.ч. в одном потоке).
- Параллелизм (parallelism) — это одновременное выполнение задач на нескольких процессорах или ядрах.
Конкурентность — про структуру кода. Параллелизм — про реальное одновременное исполнение.

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

🤔 Go — императивный или декларативный?

Go — это императивный язык программирования.

🚩Почему Go императивный?

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

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 5; i++ {
        sum += i  // Явно изменяем переменную sum
    }
    fmt.Println("Сумма:", sum)
}

🚩Декларативные элементы в Go

Хотя Go — это в первую очередь императивный язык, в нем есть элементы декларативного подхода. Например:
🟠Функциональные элементы
map, filter через срезы и функции высшего порядка.
🟠Структурированность кода
интерфейсы позволяют писать код, в котором детали реализации скрыты (инкапсуляция).
🟠Go concurrency (goroutines, channels)
вместо явного управления потоками, мы декларируем взаимодействие через каналы.

package main

import "fmt"

func mapSlice(slice []int, f func(int) int) []int {
    result := make([]int, len(slice))
    for i, v := range slice {
        result[i] = f(v)  // Декларативное применение функции к элементам
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    squared := mapSlice(nums, func(n int) int { return n * n })
    fmt.Println(squared) // [1 4 9 16 25]
}

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

🤔 Если индекс создан для двух колонок, а запрос использует только одну — будет ли он работать?

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

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

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

Нарезка (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
   }

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

🤔 Зачем используется дополнительный блок фигурных скобок в функции?

Дополнительный блок ({ ... }) внутри функции используется для:
- ограничения области видимости переменных;
- создания временной логической области, например, для вложенного вычисления;
- контроля жизни переменной, чтобы освободить её как можно раньше (особенно в длинных функциях или при работе с ресурсами)

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

🤔 Что такое SLI?

Это конкретная метрика, используемая для измерения качества обслуживания сервиса. SLI показывает, насколько хорошо сервис соответствует определенным критериям, установленным в SLO (Service Level Objective).

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

🟠Доступность (Availability)
Процент времени, в течение которого сервис доступен для пользователей. Пример: "99.9% времени в течение месяца."
🟠Производительность (Performance)
Метрики, такие как время отклика или пропускная способность. Пример: "Среднее время отклика 200 миллисекунд."
🟠Время восстановления (MTTR - Mean Time to Recovery)
Среднее время, необходимое для восстановления сервиса после сбоя. Пример: "Среднее время восстановления 1 час."
🟠Время на устранение инцидентов (MTTA - Mean Time to Acknowledge)
Среднее время на принятие мер после обнаружения проблемы. Пример: "Среднее время реакции на инцидент 30 минут."
🟠Процент ошибок (Error Rate)
Процент запросов, завершающихся ошибкой. Пример: "Процент ошибочных запросов не более 0.1%."

🚩Примеры

🟠Доступность
"Сервис был доступен 99.95% времени за последний месяц."
🟠Производительность
"Среднее время отклика сервиса за последний месяц составило 150 миллисекунд."
🟠Время восстановления (MTTR)
"Среднее время восстановления сервиса после сбоев за последний месяц составило 45 минут."
🟠Процент ошибок (Error Rate)
"Процент ошибочных запросов за последний месяц составил 0.05%."

🚩Различие между SLA, SLO и SLI

🟠SLA (Service Level Agreement)
Соглашение между поставщиком услуги и клиентом, включающее SLO и описывающее уровень обслуживания, который должен быть достигнут. SLA может включать последствия за невыполнение SLO.

🟠SLO (Service Level Objective)
Конкретные цели или метрики, которые определяют уровень обслуживания, которого должен достигнуть сервис. SLO являются частью SLA.

🟠SLI (Service Level Indicator)
Конкретные метрики, используемые для измерения фактической производительности сервиса относительно установленных SLO. SLI — это количественные показатели, которые служат основой для SLO.

🚩Важность

🟠Измерение качества услуг
SLI позволяют количественно измерять различные аспекты работы сервиса, такие как доступность и производительность.
🟠Контроль и мониторинг
SLI используются для постоянного мониторинга сервиса и обеспечения соответствия установленным SLO.
🟠Управление производительностью
SLI помогают выявлять проблемы в работе сервиса и принимать меры для их устранения.
🟠Улучшение сервиса
Анализ SLI позволяет улучшать качество обслуживания путем выявления и устранения узких мест и проблем.

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

🟠Доступность
SLI: "99.9% времени сервис доступен."
SLO: "Сервис должен быть доступен не менее 99.9% времени в течение месяца."
SLA: "Если доступность падает ниже 99.9%, клиент получает компенсацию."
🟠Производительность
SLI: "Среднее время отклика 200 миллисекунд."
SLO: "Среднее время отклика не должно превышать 250 миллисекунд для 95% запросов."
SLA: "Если время отклика превышает 250 миллисекунд, клиент получает компенсацию."

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

🤔 Сколько можно возвращать значений из функции?

В Go функция может возвращать несколько значений одновременно, благодаря множественному возврату.
Ограничений по количеству возвратов формально нет (можно вернуть хоть 10 переменных), но по стилю рекомендуется не перегружать сигнатуру — до 2–3 значений максимум, особенно если не используются именованные возвращаемые значения.

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

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

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

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