❓ Для чего предназначен пакет flag в Go

Пакет flag предназначен для разбора аргументов командной строки в приложениях на Go. Он позволяет определять флаги с конкретными типами (string, int, bool), задавать значения по умолчанию и описание, а затем считывать их в коде.

Это упрощает создание CLI-приложений и обработку параметров запуска без необходимости вручную разбирать os.Args.

🐸 Библиотека Go для собеса

❓Как создать строковый флаг

Для создания строкового флага используется функция flag.String. Она принимает имя флага, значение по умолчанию и описание, и возвращает указатель на переменную. После объявления всех флагов нужно вызвать flag.Parse(), чтобы разобрать аргументы командной строки.

Пример:

var name = flag.String("name", "Guest", "User name")
flag.Parse()
fmt.Println("Hello,", *name)

🐸 Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

❓ Чем отличается flag.StringVar от flag.String

1. flag.StringVar

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

Сигнатура: func StringVar(p *string, name string, value string, usage string)

Позволяет явно контролировать, в какую переменную попадёт значение флага.

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

2. flag.String

Создаёт новую переменную (указатель на строку) и возвращает её, а значение устанавливается из командной строки.

Сигнатура: func String(name string, value string, usage string) *string

Возвращает указатель на автоматически созданную переменную.

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

🐸 Библиотека Go для собеса

❓ Как определить булевый флаг

Булевый флаг создаётся через flag.Bool. Если в командной строке указать только имя флага (-v), значение будет true. Можно также явно задать -v=false.

verbose := flag.Bool("v", false, "Enable verbose mode")
flag.Parse()
if *verbose {
    fmt.Println("Verbose logging enabled")
}

🐸 Библиотека Go для собеса

❓ Что такое M:N scheduling

M:N scheduling в Go — это модель планирования, при которой множество горутин (M) выполняется поверх ограниченного количества потоков операционной системы (N). Это отличается от моделей 1:1 (каждая горутина — отдельный системный поток) и N:1 (все горутины на одном системном потоке).

В Go реализована модель M:N с использованием трех основных сущностей:

• G (Goroutine) — легковесная пользовательская горутина с собственным стеком и контекстом исполнения.

• M (Machine) — системный поток, управляемый ОС, на котором реально выполняется код.

• P (Processor) — логический процессор, который связывает горутины с потоками, предоставляя им контекст и ресурсы для выполнения.

Количество P по умолчанию равно числу логических CPU или задается через runtime.GOMAXPROCS. Для выполнения горутин P должен быть привязан к M. Планировщик Go распределяет горутины между доступными P и M.

🐸 Библиотека Go для собеса

❓ Что произойдёт при нескольких вызовах flag.Parse()

flag.Parse() разбирает аргументы только один раз.

Последующие вызовы не изменят результат, так как парсер уже прошёл по os.Args.

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

🐸 Библиотека Go для собеса

❓ Какие типовые ошибки могут возникать при использовании конкурентности в Go

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

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

Голодание. Иногда одни части программы забирают все ресурсы, а другие не могут работать — им всегда не хватает доступа.

Ошибка с каналами. Если программа ждет данные из канала, а данные туда никто не отправляет, выполнение остановится и программа заморозится.

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

🐸 Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

❓ Как получить неразобранные аргументы после парсинга флагов

После вызова flag.Parse() все оставшиеся аргументы (которые не являются флагами) можно получить через flag.Args().

flag.Parse()
fmt.Println("Remaining args:", flag.Args())

🐸 Библиотека Go для собеса

❓ Можно ли определить пользовательские типы флагов

Да, для этого нужно реализовать интерфейс flag.Value с двумя методами:

type Value interface {
    String() string
    Set(string) error
}

После этого пользовательский тип можно зарегистрировать через flag.Var.

type MyFlag struct{}
func (m *MyFlag) String() string { return "" }
func (m *MyFlag) Set(value string) error { fmt.Println("Set value:", value); return nil }

var my MyFlag
flag.Var(&my, "myflag", "custom flag")
flag.Parse()

🐸 Библиотека Go для собеса

❓ Как с помощью append сложить массивы

Чтобы объединить два слайса с помощью append, нужно использовать оператор распаковки — три точки.

Но тут есть важный нюанс — если у первого слайса достаточно capacity, то append может переиспользовать его базовый массив, и это может привести к неожиданному поведению.

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

🐸 Библиотека Go для собеса

❓ Как работает автоматическая помощь -h или --help

При вызове программы с флагом -h пакет flag автоматически выводит список всех объявленных флагов с их описанием и значением по умолчанию. Это не требует дополнительного кода для справки.

🐸 Библиотека Go для собеса

❓ Как проверить тип переменной в рантайме

Самый универсальный способ — использовать встроенный пакет reflect. Он позволяет получить информацию о типе любой переменной.

Метод TypeOf() возвращает объект Type, который содержит полную информацию о типе: имя, размер, методы и другие характеристики:

func main() {
    var x interface{} = 42
    var y interface{} = "привет"
    var z interface{} = []int{1, 2, 3}
    
    fmt.Println(reflect.TypeOf(x))  // int
    fmt.Println(reflect.TypeOf(y))  // string
    fmt.Println(reflect.TypeOf(z))  // []int
}

Когда вы работаете с интерфейсами и хотите проверить конкретный тип, используйте type assertion:

func processValue(val interface{}) {
    if str, ok := val.(string); ok {
        fmt.Printf("Это строка: %s\n", str)
    } else if num, ok := val.(int); ok {
        fmt.Printf("Это число: %d\n", num)
    } else {
        fmt.Println("Неизвестный тип")
    }
}

Когда нужно обработать несколько типов, type switch читается намного проще:

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Целое число: %d\n", v)
    case string:
        fmt.Printf("Строка длиной %d символов\n", len(v))
    case []int:
        fmt.Printf("Срез из %d элементов\n", len(v))
    case bool:
        fmt.Printf("Булево значение: %v\n", v)
    default:
        fmt.Printf("Неизвестный тип: %T\n", v)
    }
}

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

var data interface{} = map[string]int{"ключ": 100}
fmt.Printf("Тип переменной: %T\n", data)  // map[string]int

Когда использовать каждый способ

reflect.TypeOf() — когда нужна детальная информация о типе или вы работаете с неизвестными структурами данных. Учитывайте, что рефлексия замедляет выполнение.

Type assertion — для проверки одного-двух конкретных типов. Самый производительный вариант.

Type switch — когда нужно обработать несколько известных типов. Код получается чище и понятнее цепочки if-else.

%T в fmt — только для отладки и логирования.

🐸 Библиотека Go для собеса

❓ Чем отличаются методы Time.Sub() и Time.Add() в пакете time

Time.Sub() — метод вычисляет разницу между двумя моментами времени.

start := time.Now()
time.Sleep(2 * time.Second)
end := time.Now()

duration := end.Sub(start) // ≈ 2 секунды
fmt.Println(duration) // 2.001234567s

Time.Add() — метод добавляет или вычитает при отрицательном значении длительность к/от момента времени и возвращает новое время.

now := time.Now()
tomorrow := now.Add(24 * time.Hour)
yesterday := now.Add(-24 * time.Hour)

fmt.Println("Завтра:", tomorrow)
fmt.Println("Вчера:", yesterday)

🐸 Библиотека Go для собеса