🍔 Топ-вакансий для Go-разработчиков за неделю

Team Lead на Go от 500 000 ₽

Golang-разработчик на удалёнку

Middle Go-разработчик от 180 000 ₽

Golang разработчик до 270 000 ₽

Go-разработчик с тремя годами опыта

➡️ Еще больше топовых вакансий — в нашем канале Go jobs

🐸 Библиотека Go-разработчика

#GoWork

🧑‍💻 Как проверить строку на пустоту

Кажется, что проверка строки на пустоту — это простая задача. Но в Go есть несколько способов, и выбор между ними зависит от того, что вы считаете пустотой: действительно пустая строка или строка только с пробелами. Давайте разберёмся, когда использовать каждый подход.

Самый очевидный способ — сравнить длину со значением ноль или сравнить саму строку с пустой:

if len(s) == 0 {
    // строка пуста
}

if s == "" {
    // строка пуста
}

Часто нужно проверить не просто длину, а содержимое. Строка « » технически не пуста, но полезной информации в ней нет. Для таких случаев используем strings.TrimSpace():

if strings.TrimSpace(s) == "" {
    // пуста или только пробелы
}

Это убирает пробелы по краям и проверяет, что-то осталось. Если нужно проверить наличие видимых символов вообще, помогает strings.Fields():

if len(strings.Fields(s)) == 0 {
    // только пробельные символы или вообще пуста
}

Fields() разбивает строку по пробелам и возвращает срез непустых элементов. Если срез пуст — видимых данных нет.

Главное — не усложняйте без надобности. Go ценит простоту кода.

🐸 Библиотека Go-разработчика

#GoToProduction

✏️ Расстояния между единицами: находим нужный паттерн

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

Массив [1,0,0,0,1,0,0,1] при k=2 валиден: между первой и второй единицей три нуля (достаточно), между второй и третьей — два нуля (достаточно). А вот [1,0,1,0,0,1] при k=2 — нет, потому что первые две единицы разделены только одним нулём.

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

Это будет один проход по массиву:

func kLengthApart(nums []int, k int) bool {
    lastPos := -k - 1
    
    for i := 0; i < len(nums); i++ {
        if nums[i] == 1 {
            if i - lastPos - 1 < k {
                return false
            }
            lastPos = i
        }
    }
    return true
}

Результат: O(n) время, O(1) память.

🐸 Библиотека Go-разработчика

#ReadySetGo

🔄 Revive v1.13.0: три новых правила линтера и мелкие исправления

Вышла новая версия Revive. Главное — три новых правила.

Первое указывает на проверки вида if _, ok := m[k]; ok перед доступом. Вместо этого можно сразу читать значение и проверять второй возвращаемый параметр.

Второе ловит вызовы wg.Add() и wg.Done() внутри wg.Go() в WaitGroup контексте — это потенциально опасно.

Третье находит условия, которые можно упростить.

Технически: поднята версия Go до 1.24, переорганизован код правил, обновлены зависимости.

➡️ Release notes

🐸 Библиотека Go-разработчика

#GoLive

💻 Тестирование ввода из stdin

Тестирование функций, которые читают данные с консоли через fmt.Scan и stdin в Go, часто становится настоящей задачей. В таких случаях нельзя просто передать параметры функции — код напрямую взаимодействует со стандартным вводом.


Пример проблемы:

func ReadName() string {
    var name string
    fmt.Print("Enter your name: ")
    fmt.Scan(&name)
    return name
}

Для этой функции сложно написать unit-тест, потому что она читает из os.Stdin, а в тестах обычно хочется подставлять свои данные.

Решение: подменяем os.Stdin

В тестах можно временно переназначить os.Stdin на чтение из заранее подготовленного буфера:

func TestReadName(t *testing.T) {
    input := "Alice\n"
    r, w, _ := os.Pipe()
    w.WriteString(input)
    w.Close()
    oldStdin := os.Stdin
    defer func() { os.Stdin = oldStdin }()
    os.Stdin = r

    got := ReadName()
    want := "Alice"
    if got != want {
        t.Errorf("got %q, want %q", got, want)
    }
}

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

🐸 Библиотека Go-разработчика

#GoToProduction

🐳 Изучаем Docker в терминале

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

Главная особенность — это удобный TUI-интерфейс на базе Bubble Tea, позволяющий выполнять задания и сразу же проверять свои решения командой.

Все упражнения построены таким образом, чтобы вы действительно делали — запускали контейнеры, писали Dockerfile, разбирались в сетевых настройках и Docker Compose. Это не лекции, а практическая игра, которая помогает освоить реальные сценарии.

➡️ Поизучать Docker CLI

🐸 Библиотека Go-разработчика

#GoDeep

🔥 Выучи математику за 60 дней!

Чем важна математика расскажет Мария Тихонова - кандидат компьютерных наук, руководитель исследовательского направления SberAI, доцент факультета компьютерных наук и преподаватель НИУ ВШЭ на курсе «Математика для Data Science» от Proglib Academy.

👀 Мария - человек, который реально работает с LLM и делает так, чтобы модели понимали человеческую речь, а не делали вид.

Что еще внутри курса:

- живые вебинары, на которых можно задать вопросы спикерам
- доступ к материалам в записи, если не успели на лекцию и чат
- 3 задания с практикой на Python и финальный проект с подробной обратной связью от экспертов курса
- актуальные знания: программа разработана в ноябре 2025г.
- программа без воды - 2 месяца только самого нужного для старта
- для старта нужны всего лишь знания школьной математики и основы Python
- скидка 40% до 30 ноября
- если оплатить до конца ноября, получите курс «Базовая математика» в подарок

👇👇👇
Записаться на курс

👨‍💻 Ошибки с sync.WaitGroup

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

sync.WaitGroup состоит из трех операций: Add() говорит «я жду еще одну горутину», Done() говорит «эта горутина закончила», Wait() блокирует до того, как счетчик вернется к нулю.

Но вот где начинаются проблемы:

Вызов Add() после запуска горутины:

go func() {
    wg.Add(1)      // слишком поздно!
    doWork()
    wg.Done()
}()
wg.Wait()

Главная горутина может выйти из Wait() прежде, чем дочерняя вызовет Add(). Вот вам race condition.

Забыли Done():

go func() {
    doWork()
    // забыли wg.Done()
}()
wg.Wait()  // будет висеть вечно

Wait() никогда не вернется, потому что счетчик никогда не уменьшится.

Wait() в неправильном месте:

for _, item := range items {
    go func(i Item) {
        wg.Add(1)
        defer wg.Done()
        doWork(i)
    }(item)
    wg.Wait()  // внутри цикла! это синхронное выполнение
}

Wait() внутри цикла превращает параллельное выполнение в последовательное. Вы ждете каждой горутины перед запуском следующей.

Запомните: WaitGroup — инструмент для синхронизации конца работы, а не управления её началом.

🐸 Библиотека Go-разработчика

#GoDeep

🤖 ChatGPT выключен, а работа идёт как обычно

В мире разработки всё чаще говорят про AI, который помогает писать код быстрее и качественнее. Однако, встречаются примеры, когда выключение Copilot не приводит к заметным потерям в работе.

Возможно, скиллы и понимание задач дают больше, чем автодополнение от AI.

💬 Как думаете не отвлекают ли эти ИИ? Или всё-таки с ними куда лучше?

🔸 AI-агенты для DS-специалистов
🔸 Получить консультацию менеджера
🔸 Сайт Академии 🔸 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoTalk

✏️ nil-срез vs nil-мапа: почему append проходит, а запись в мапу нет

В Go nil-срез — это валидный срез, просто пустой с длиной и ёмкостью ноль. При вызове append на nil-срезе Go автоматически создаёт новый массив нужного размера и возвращает новый срез с элементами. Поэтому добавлять значения можно сразу.

nil-мапа — это неинициализированная структура, которая не хранит данные. Попытка записать в такую мапу приведёт к панике. Мапу обязательно надо инициализировать с помощью make, чтобы она работала.

var a []int
a = append(a, 4, 5, 6) // работает, потому что Go выделяет память
fmt.Println(a)         // [4 5 6]

var m map[int]int
// m[1] = 1 // паника, nil-мапа не инициализирована
m = make(map[int]int)
m[1] = 1 // теперь всё ок

🔹 Алгоритмы и структуры данных
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoDeep

📎 Библиотека анимаций для терминала

Для тех, кто занимается разработкой текстовых интерфейсов на Go, есть интересный инструмент — библиотека sysc-Go.

В библиотеке доступны разные категории эффектов: от классического цифрового дождя в стиле «Матрицы» и пламени Doom до красочных фейерверков и подводных анимаций с рыбой.

Есть и текстовые эффекты, которые оживляют ASCII-арт — например, огненный текст, эффекты типографики с имитацией печатной машинки или вращающиеся кольцевые анимации.

Чистая реализация на Go без зависимостей, удобный CLI-интерфейс с выбором и просмотром всех доступных эффектов, а также встроенный ASCII-редактор с живым предпросмотром.

➡️ Анимировать терминал

🔹 Практический интенсив «Архитектуры и шаблоны проектирования»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoToProduction

📎 Как лишние // indirect-зависимости убивают ваш Go-проект

Go сам отслеживает, какие нужны зависимости, и добавляет к ним транзитивные (// indirect) при go get. Когда библиотека удалена, многие верят, что go mod tidy наведёт полный порядок, но на деле она осторожно подходит к удалению и может оставить кучу неиспользуемого хлама.

Рабочий способ чистки такой: коммитим текущее состояние, вручную убираем все строки // indirect из go.mod, стираем go.sum, затем запускаем go mod tidy. Система пересчитает зависимости и вернёт только реально используемые. После этого сборка станет ощутимо быстрее, а зависимостей станет меньше.

Для контроля лучше раз в квартал повторять процедуру и всё время использовать go mod tidy перед коммитами.

🔹 Алгоритмы и структуры данных
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoDeep

🐸 Библиотека Go-разработчика

#GoGiggle

✏️ Что такое Trie и когда его использовать

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

Когда стоит применять Trie

• Когда у вас большой словарь или список слов, требующих быстрого поиска

• Для функций startsWith(prefix), когда нужно быстро проверить, есть ли слова с заданным префиксом

• Когда нужны частичные совпадения с wildcard-символами — например, поиск по шаблонам с точками или звездочками

• Для реализации игр со словами, таких как Boggle, Scrabble или Wordle

• В автодополнении и DNS-lookup

• Для любых задач, где важна быстрая проверка строк по префиксу

Базовая структура:

package main

type TrieNode struct {
    children map[rune]*TrieNode
    isEnd    bool // Флаг конца слова
    value    interface{} // Опционально: значение, связанное со словом
}

type Trie struct {
    root *TrieNode
}

func NewTrie() *Trie {
    return &Trie{
        root: &TrieNode{
            children: make(map[rune]*TrieNode),
        },
    }
}

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

Вставка слова:

func (t *Trie) Insert(word string) {
    node := t.root
    
    for _, char := range word {
        if _, exists := node.children[char]; !exists {
            node.children[char] = &TrieNode{
                children: make(map[rune]*TrieNode),
            }
        }
        node = node.children[char]
    }
    
    node.isEnd = true
}

Поиск слова:

func (t *Trie) Search(word string) bool {
    node := t.root
    
    for _, char := range word {
        if child, exists := node.children[char]; exists {
            node = child
        } else {
            return false
        }
    }
    
    return node.isEnd
}

Автодополнение по префиксу:

func (t *Trie) StartsWith(prefix string) []string {
    node := t.root
    
    // Находим узел префикса
    for _, char := range prefix {
        if child, exists := node.children[char]; exists {
            node = child
        } else {
            return []string{} // Префикс не найден
        }
    }
    
    // Собираем все слова с этим префиксом
    var results []string
    t.dfs(node, prefix, &results)
    return results
}

func (t *Trie) dfs(node *TrieNode, current string, results *[]string) {
    if node.isEnd {
        *results = append(*results, current)
    }
    
    for char, child := range node.children {
        t.dfs(child, current+string(char), results)
    }
}

Использование префиксного дерева значительно ускоряет операции поиска и автодополнения по сравнению с простыми Map или Set. Хотя Trie требует больше памяти, выигрыш в скорости обычно оправдывает этот расход.

🔹 ML для старта в Data Science
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoDeep

📰 Дайджест недели

Прошла 47 неделя 2025 года. Вспомним какая она была.

— Экосистема Go в 2025

Go отмечает 16 лет, оставаясь популярным выбором для бэкендов и инфраструктуры. В 2025 растет использование фреймворков Gin и Fiber, тестовых библиотек testify и gomock, а AI-помощники активно интегрируются в рабочие процессы разработчиков

— Centrifuge v0.38.0

— Педагоги в Казахстане получат доступ к ChatGPT Edu

— Revive v1.13.0

— Google выпустили VS Code 2

Google запустили Antigravity — новую платформу для разработки программного обеспечения, ориентированную на работу с автономными AI-агентами.

🔸 Алгоритмы и структуры данных
🔸 Получить консультацию менеджера
🔸 Сайт Академии 🔸 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoLive

🧑‍💻 Ранняя пенсия с миллионами

$10-15 млн к 28 годам — звучит круто. Но стоит ли так рано бросать всё и уходить в свободное плавание?

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

💬 А вы готовы уйти с работы, имея такой запас? Или работа для вас — это больше, чем просто деньги?

🔹 Практический интенсив «Архитектуры и шаблоны проектирования»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🐸 Библиотека Go-разработчика

#GoTalk