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

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

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

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

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

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

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

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

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

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

🤔 Какие есть алгоритмы балансировки?

Алгоритмы балансировки нагрузки:
- Round Robin — по кругу, равномерно.
- Least Connections — запрос уходит на сервер с наименьшим числом активных соединений.
- IP Hash — запросы одного клиента попадают на один сервер.
- Weighted Round Robin — с учётом мощности/приоритета серверов.
- Random — случайное распределение.
- Consistent Hashing — используется в распределённых системах для устойчивого распределения ключей.

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

🤔 Что такое массив (array)?

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

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

🟠Фиксированный размер
Размер массива задается при его объявлении и не может изменяться во время выполнения программы.
🟠Тип элементов
Все элементы массива имеют один и тот же тип.
🟠Непрерывное размещение в памяти
Элементы массива хранятся последовательно в памяти, что обеспечивает быстрый доступ к любому элементу по индексу.

🚩Объявление и инициализация массивов

Массивы объявляются с указанием типа элементов и фиксированного размера:

var arr [5]int

🟠Инициализация массива
Могут быть инициализированы при объявлении:

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

Можно также инициализировать массив частично, оставив остальные элементы равными нулям:

arr := [5]int{1, 2}

🟠Доступ к элементам массива
Осуществляется с использованием индексов, начиная с 0:

fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10

🟠Длина массива
Фиксирована и задается при его объявлении. Ее можно получить с помощью функции len:

fmt.Println(len(arr)) // 5

🟠Копирование массива
При присваивании одного массива другому копируются все элементы:

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

🟠Передача массива в функции
Копируется весь массив:

func modifyArray(a [5]int) {
    a[0] = 10
}

arr := [5]int{1, 2, 3, 4, 5}
modifyArray(arr)
fmt.Println(arr) // [1 2 3 4 5]

🟠Сравнение массивов
С помощью оператора ==, если они имеют одинаковую длину и тип элементов:

arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
arr3 := [3]int{4, 5, 6}

fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false

Пример

package main

import (
    "fmt"
)

func main() {
    // Объявление и инициализация массива
    arr := [5]int{1, 2, 3, 4, 5}

    // Доступ к элементам
    fmt.Println("First element:", arr[0]) // First element: 1

    // Изменение элементов
    arr[1] = 10
    fmt.Println("Modified array:", arr) // Modified array: [1 10 3 4 5]

    // Длина массива
    fmt.Println("Length of array:", len(arr)) // Length of array: 5

    // Копирование массива
    arr2 := arr
    arr2[0] = 20
    fmt.Println("Original array:", arr) // Original array: [1 10 3 4 5]
    fmt.Println("Copied array:", arr2)  // Copied array: [20 10 3 4 5]

    // Передача массива в функцию
    modifyArray(arr)
    fmt.Println("Array after modifyArray call:", arr) // Array after modifyArray call: [1 10 3 4 5]
}

func modifyArray(a [5]int) {
    a[0] = 10
}

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

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

int(string) невозможно, так как это несопоставимые типы, но можно конвертировать строку в число через strconv.Atoi. string(int) возможно, но результатом будет символ, соответствующий числовому значению в таблице Unicode.

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

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

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

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

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

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

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

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

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

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

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

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

defer реализует концепт отложенного выполнения — аналог "гарантированного освобождения ресурса" или финализации.
Это полезно для:
- Закрытия файлов или соединений.
- Освобождения ресурсов.
- Логирования.
- Обработки ошибок в recover.
Фактически defer помогает имитировать поведение finally из других языков.

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

🤔 Зачем нужны таймауты при 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 секунды на заголовки
   }

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

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

Функция append добавляет элементы к слайсу, расширяя его. Если места в выделенной памяти недостаточно, создаётся новый массив, а данные переносятся в него. Итоговый слайс возвращается с обновлёнными элементами и размером.

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

🤔 Что такое пустой интерфейс?

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

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

🟠Универсальность
Пустой интерфейс может содержать значение любого типа, потому что все типы в Go автоматически реализуют пустой интерфейс.
🟠Использование
Пустой интерфейс широко используется для создания обобщенных (generic) структур данных, функций и методов, которые могут работать с данными любых типов.

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

🟠Присваивание значений разного типа
Пустой интерфейс может использоваться для хранения значений различных типов в одной переменной.

package main

import "fmt"

func main() {
    var i interface{}

    i = 42
    fmt.Println(i) // Output: 42

    i = "hello"
    fmt.Println(i) // Output: hello

    i = true
    fmt.Println(i) // Output: true
}

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

package main

import "fmt"

func printValue(v interface{}) {
    fmt.Println(v)
}

func main() {
    printValue(42)
    printValue("hello")
    printValue(true)
}

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

package main

import "fmt"

func main() {
    var values []interface{}
    values = append(values, 42, "hello", true)

    for _, v := range values {
        fmt.Println(v)
    }
}

🟠Обработка разнородных данных
Пустой интерфейс используется для обработки данных различных типов, например, при парсинге JSON.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonData := `{"name": "Alice", "age": 30}`
    var result map[string]interface{}
    json.Unmarshal([]byte(jsonData), &result)

    fmt.Println(result)
}

🟠Проверка типа и приведение типа
При работе с пустым интерфейсом часто возникает необходимость проверить тип хранимого значения и привести его к конкретному типу. Это можно сделать с помощью утверждения типа (type assertion) или конструкции switch.

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

package main

import "fmt"

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

    s, ok := i.(string)
    if ok {
        fmt.Println("String:", s) // Output: String: hello
    } else {
        fmt.Println("Not a string")
    }

    n, ok := i.(int)
    if ok {
        fmt.Println("Integer:", n)
    } else {
        fmt.Println("Not an integer")
    }
}

🟠Использование `switch` для проверки типа
Конструкция 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") // Output: String: hello
    printType(42)      // Output: Integer: 42
    printType(true)    // Output: Boolean: true
    printType(3.14)    // Output: Unknown type: float64
}

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

🤔 Что известно про паттерн Builder (Строитель)?

Builder — это порождающий паттерн, позволяющий создавать сложные объекты пошагово, контролируя процесс построения.
Он особенно полезен, когда объект:
- имеет много опциональных параметров,
- требует разной конфигурации при создании,
- должен быть иммутабельным после построения.
Пример: создание HTTP-запроса или SQL-запроса с цепочкой .setX().setY().build().

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

🤔 Какое свойство должно быть у ключа в Map?

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

🚩Свойства ключей

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

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

🚩Допустимые типы ключей

Булевый тип (bool)

  m := map[bool]string{
    true:  "Yes",
    false: "No",
}  

Целочисленные типы (int, int8, int16, int32, int64, а также их беззнаковые эквиваленты uint, uint8, uint16, uint32, uint64)

  m := map[int]string{
    1: "One",
    2: "Two",
}  

Числа с плавающей точкой (float32, float64)

  m := map[float64]string{
    1.1: "One point one",
    2.2: "Two point two",
}  

Строки (string)

  m := map[string]int{
    "Alice": 25,
    "Bob":   30,
}

Составные типы (структуры, массивы), при условии, что все их поля также поддерживают сравнение с помощью оператора ==

  type Key struct {
    FirstName string
    LastName  string
}

m := map[Key]int{
    {"Alice", "Smith"}: 1,
    {"Bob", "Johnson"}: 2,
}
  

🚩Недопустимые типы ключей

🟠Срезы (slice)
Срезы не поддерживают операцию сравнения с использованием оператора == (только сравнение с nil).
🟠Карты (map)
Карты не поддерживают операцию сравнения.
🟠Функции (func)
Функции не поддерживают операцию сравнения.

package main

import "fmt"

type Person struct {
    FirstName string
    LastName  string
}

func main() {
    // Создаем карту с ключами типа Person
    m := make(map[Person]int)

    // Вставляем значения в карту
    m[Person{"Alice", "Smith"}] = 25
    m[Person{"Bob", "Johnson"}] = 30

    // Выводим значения из карты
    fmt.Println(m[Person{"Alice", "Smith"}])  // Выводит: 25
    fmt.Println(m[Person{"Bob", "Johnson"}])  // Выводит: 30
}

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

🤔 Что будет, если закрыть уже закрытый канал?

Закрытие закрытого канала вызывает panic.
Рекомендуется не закрывать канал дважды и проверять, закрыт ли он (recover или sync.Once для защиты от дублирующего закрытия).

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

🤔 Почему в TDD тесты пишутся прежде кода?

Этот подход обеспечивает ряд преимуществ, которые способствуют улучшению качества кода, его поддерживаемости и соответствию требованиям.

🚩Причины

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

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

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

🟠Обратная связь и уверенность
Тесты, написанные перед кодом, обеспечивают немедленную обратную связь. Если код не проходит тест, это означает, что он не соответствует требованиям. Это позволяет разработчикам быстро обнаруживать и исправлять ошибки, повышая уверенность в корректности кода.

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

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

🚩Пример процесса TDD

1⃣Написание теста

package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, but got %d", result)
    }
}

2⃣Запуск теста
На этом этапе тест не пройдет, так как функция Add еще не реализована.

3⃣Реализация кода

package main

func Add(a, b int) int {
    return a + b
}

4⃣Запуск теста снова
Теперь тест пройдет, так как функция Add реализована корректно.

5⃣Рефакторинг
При необходимости выполняется рефакторинг кода для улучшения его структуры, при этом тесты продолжают проходить, что гарантирует сохранение функциональности.

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

🤔 Безопасен ли map?

Стандартный map небезопасен для многопоточного доступа. Используйте синхронизацию или специальные структуры данных.

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

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

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

🚩Ключевые особенности

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

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

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

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

🚩Создание и использование контекста

🟠context.Background()
Возвращает пустой контекст, который никогда не отменяется. Обычно используется в основной функции и при инициализации.

🟠context.TODO()
Используется для указания, что должен быть предоставлен подходящий контекст. Обычно применяется в разработке и при рефакторинге.

🟠context.WithCancel(parent Context) (ctx Context, cancel CancelFunc)
Создает новый контекст с возможностью отмены.

🟠context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
Создает контекст, который автоматически отменяется в указанный deadline.

🟠context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
Аналогичен WithDeadline, но устанавливает время жизни контекста на основе заданного таймаута.

func operation1(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("operation1 completed")
    case <-ctx.Done():
        fmt.Println("operation1 cancelled")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    go operation1(ctx)

    // Дожидаемся завершения или отмены операции
    <-ctx.Done()
    if err := ctx.Err(); err != nil {
        fmt.Println("main:", err)
    }
}

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

🤔 Что такое len и capacity в слайсе Go?

1. len: текущая длина слайса, то есть количество элементов, доступных для использования.
2. capacity: общая ёмкость слайса, включая длину и свободное пространство, доступное для добавления новых элементов

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

🤔 Что такое Go?

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

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

🟠Компиляция и скорость
Go — компилируемый язык, обеспечивающий высокую производительность.
🟠Простота
Язык избегает избыточности, улучшая читаемость кода.
🟠Сборка мусора
Автоматическое управление памятью.
🟠Конкурентность
Встроенные средства для работы с параллельными вычислениями, такие как горутины и каналы.
🟠Стандартная библиотека
Широкий набор инструментов и библиотек.

🚩Пример простого приложения

Простого веб-сервера:

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Starting server on :8080")
    http.ListenAndServe(":8080", nil)
}

🚩Основные концепции

🟠Горутины
Легковесные потоки для параллельных вычислений.

go func() {
    fmt.Println("Hello from a goroutine!")
}()   

🟠Каналы
Средства обмена данными между горутинами.

ch := make(chan int)
go func() {
    ch <- 42
}()
value := <-ch
fmt.Println(value)   

🟠Интерфейсы
Абстракция поведения без привязки к реализации.

type Stringer interface {
    String() string
}   

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

package mypackage

import "fmt"

func MyFunction() {
    fmt.Println("Hello from mypackage")
}   

🚩Применение Go

Go используется для серверного ПО, облачных сервисов, микросервисов, инструментов командной строки и систем с высокой производительностью. Известные проекты на Go включают Kubernetes, Docker, Prometheus, а также Google, Dropbox и Netflix.

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

➕Высокая производительность
Быстро компилируемый язык.
➕Простота и читаемость
Минимум синтаксического шума.
➕Конкурентность
Простые механизмы параллельных вычислений.
➕Богатая библиотека
Широкий набор встроенных инструментов.
➖Ограниченные обобщения
Ранее отсутствовали, добавлены в Go 1.18.
➖Нет исключений
Используется управление ошибками через возвращаемые значения.

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

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

Контекст (context) в Go — это механизм для передачи метаданных и управления временем выполнения горутин, который часто используется для управления тайм-аутами, дедлайнами и отменой операций. Контекст передаётся через аргументы функций и может содержать ключи для хранения значений, а также методы для отмены операций (`WithCancel()`, `WithTimeout()`, `WithDeadline()`). Контексты помогают управлять зависимыми горутинами, гарантируя их завершение при отмене родительской операции. Это важно для эффективного использования ресурсов в многозадачных программах.

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

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

В Go, проверка типа интерфейса может быть выполнена несколькими способами: с помощью утверждения типа (type assertion) и с помощью конструкции switch для выбора типа.

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

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

value, ok := interfaceValue.(ConcreteType)

🟠value
Значение типа ConcreteType, если утверждение типа успешно.
🟠ok
Булевое значение, указывающее, удалось ли преобразование.

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")
    }

    // Утверждение типа, которое вызовет панику, если тип не соответствует
    // Uncomment the line below to see the panic
    // s := i.(string)
    // fmt.Println(s)
}

🚩Использование `switch` для выбора типа

Конструкция switch позволяет проверить значение интерфейса на соответствие нескольким возможным типам.

switch v := interfaceValue.(type) {
case ConcreteType1:
    // v имеет тип ConcreteType1
case ConcreteType2:
    // v имеет тип ConcreteType2
default:
    // v имеет другой тип
}

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

Пример использования для проверки и работы с интерфейсами

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

// Реализация интерфейса fmt.Stringer для типа Person
func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func printValue(i interface{}) {
    if str, ok := i.(fmt.Stringer); ok {
        fmt.Println("Stringer:", str.String())
    } else {
        fmt.Println("Not a Stringer")
    }
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    printValue(p)               // Проверка типа fmt.Stringer
    printValue("Hello, world!") // Строка не реализует fmt.Stringer
}

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

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

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

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