🤨 Как дженерики влияют на Go разработку

В языке программирования Go с версии 1.18 введены обобщения (generics), которые позволяют создавать гибкий и переиспользуемый код. 

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

Без применения comparable можно столкнуться с ошибками компиляции при попытке сравнения несравнимых типов, например, срезов или карт.

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

📎 Подробности и примеры

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

🤖 Интеграция AI в Go-приложения

Deepseek-Go — это обёртка для языка Go, предназначенная для интеграции с платформой Deepseek. Она предоставляет интерфейс для взаимодействия с AI-функциями Deepseek, включая чат-комплиты с поддержкой потоковой передачи, отслеживание использования токенов и другие возможности.

✏️ Пример использования:

func main() {
    // Создание клиента Deepseek
    client := deepseek.NewClient(os.Getenv("DEEPSEEK_KEY"))

    // Создание запроса на чат-комплит
    request := &deepseek.ChatCompletionRequest{
        Model: deepseek.DeepSeekChat,
        Messages: []deepseek.ChatCompletionMessage{
            {Role: constants.ChatMessageRoleSystem, 
             Content: "Здесь задаём как отвечать"},
            {Role: constants.ChatMessageRoleUser, 
             Content: "Здесь спрашиваем"},
        },
    }

    // Отправка запроса и обработка ответа
    ctx := context.Background()
    response, err := client.CreateChatCompletion(ctx, request)
    if err != nil {
        log.Fatalf("Ошибка: %v", err)
    }

    // Вывод ответа
    fmt.Println("Ответ:", response.Choices[0].Message.Content)
}

➡️ GitHub репозиторий проекта

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

↗️ Улучшите работу с GitHub

Эффективная работа с GitHub становится проще с использованием расширений для браузера Chrome. Вот три инструмента, которые помогут вам оптимизировать процесс разработки:

1️⃣ Octotree

Octotree добавляет древовидную структуру файлов в интерфейс GitHub, облегчая навигацию по проектам с большим количеством директорий и файлов.

2️⃣ OctoLinker

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

3️⃣Refined GitHub

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

📎 Подробнее о других расширениях — в статье

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

⭐️ Практическое руководство по MongoDB

MongoDB —  NoSQL-база данных, которая упрощает хранение и обработку больших объёмов данных. Её документно-ориентированная структура делает работу с JSON-подобными данными удобной и гибкой. 

В руководстве разобраны концепции MongoDB: CRUD-операции, создание индексов для ускорения запросов, а также рекомендации по управлению коллекциями и документами. 
Примеры помогут быстро освоить базовые техники и применить в проектах.

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

👨‍💻 Создание сервиса сокращения URL на Go

Сервис сокращения URL — отличный способ улучшить навыки веб-разработки и работы с Go. В этом проекте используется база данных Redis и контейнеризация с помощью Docker.

Этапы разработки:

1️⃣ Инициализация проекта: создайте новый каталог для проекта и инициализируйте модуль Go с помощью команды go mod init.

2️⃣ Установка зависимостей: установите необходимые пакеты, такие как redis и mux для маршрутизации HTTP-запросов.

3️⃣ Определение моделей данных: создайте структуры для входящих и исходящих данных, например, ShortenRequest для исходного URL и ShortenResponse для сокращенного URL.

4️⃣ Настройка хранилища Redis: реализуйте функции для сохранения и извлечения URL-адресов из Redis.

5️⃣ Реализация обработчиков API: создайте обработчики для сокращения URL и перенаправления, обрабатывающие HTTP-запросы и взаимодействующие с хранилищем данных.

6️⃣ Настройка маршрутизатора: настройте маршруты для обработки запросов на сокращение URL и перенаправление, используя mux.

7️⃣ Docker'изация приложения: создайте Dockerfile и docker-compose.yml


🖇 Подробное описание каждого этапа в источнике.
Или можно посмотреть исходный код на GitHub

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

⚙️ Продвинутое логирование в Go

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

➖ Zap предлагает несколько способов создания логгеров:

• zap.NewProduction(): выводит логи в формате JSON с минимальным уровнем Info.

• zap.NewDevelopment(): выводит логи в удобочитаемом формате с минимальным уровнем Debug.

• zap.NewExample(): имеет настройки, схожие с zap.NewDevelopment().

➖ Уровни логирования в Zap:

• Debug: подробные сообщения для отладки.

• Info: информационные сообщения о нормальной работе приложения.

• Warn: предупреждения о проблемах, не требующие немедленного вмешательства.

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

• DPanic: ошибки, которые вызывают панику в режиме разработки; в продакшене записываются как ошибки.

• Panic: запись сообщения и вызов паники, приводящей к остановке программы.

• Fatal: запись сообщения и завершение программы с кодом выхода 1.

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

package main

import (
    "go.uber.org/zap"
)

func main() {
    // Создание логгера с настройками для разработки
    logger, _ := zap.NewDevelopment()
    defer logger.Sync() // Очистка буферов перед завершением

    // Запись различных уровней логов
    logger.Debug("Это сообщение уровня DEBUG")
    logger.Info("Это сообщение уровня INFO")
    logger.Warn("Это сообщение уровня WARN")
    logger.Error("Это сообщение уровня ERROR")
}

➡️ Подробнее про Zap

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

🌐 Современный подход к работе с IP

Пакет net/netip – современное решение для работы с IP-адресами в Go. Он заменяет устаревший тип net.IP и предлагает компактные, неизменяемые и безопасные структуры для работы с IPv4 и IPv6

Основные типы и функции:

• netip.Addr
Этот тип представляет IP-адрес и поддерживает как IPv4, так и IPv6. Методы типа позволяют проверить, к какому семейству адресов относится IP или определить его особенности, такие как принадлежность к loopback или multicast группам.

• netip.Prefix
Используется для описания комбинации IP-адреса и сетевой маски.

• ParseAddr и ParsePrefix
Пакет включает функции для преобразования строкового представления адресов и префиксов в объекты нужных типов.

📎 Документация по пакету

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

🧑‍💻 Shell-скрипты на Go

Библиотека script позволяет загружать и обрабатывать содержимое файлов, запускать внешние программы и анализировать их вывод, а также фильтровать текст – искать строки по шаблонам, заменять текст и сортировать данные.

С её помощью можно работать с HTTP-запросами, обрабатывать веб-страницы и структурированные данные.

✏️ Примеры:

Запуск команды и анализ вывода

count, err := script.Exec("ps aux").Match("nginx").CountLines()
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    fmt.Printf("Запущено %d процессов nginx\n", count)

Чтение файла и фильтрация строк

count, err := script.File("server.log").Match("ERROR").CountLines()
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    fmt.Printf("Найдено %d строк с ошибками\n", count)

Работа с HTTP-запросами

script.Get("https://golang.org").
        Match("Go").
        Stdout()

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

🛠 Минимум аллокаций в Go

Zero-Allocation в Go — это мощный «инструмент», который помогает снизить нагрузку на GC и улучшить производительность

1️⃣ Используйте strings.Builder вместо «+» для строк

• Конкатенация + создает новую строку в куче.

• strings.Builder позволяет избежать лишних аллокаций.

2️⃣ Предварительно задавайте емкость срезов (make([]T, 0, cap))

• append() расширяет массив и выделяет новую память.

• Если емкость известна заранее, лучше использовать make.

3️⃣ Используйте copy() вместо append() для дубликатов срезов

• copy копирует данные без создания новых объектов.

4️⃣ Не передавайте указатели, если объект помещается в стек

• Переменные, переданные по указателю, могут уйти в кучу из-за escape-анализа.

5️⃣ Используйте sync.Pool для повторного использования объектов

Перед оптимизацией профилируйте код, чтобы понять, где реально нужны улучшения

➡️ Примеры для каждого приема в статье

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

🛠 Проблема зависания Go-приложений в Steam

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

Эта ошибка затрагивает даже простые консольные приложения и связана с конфликтом между Steam Overlay и рантаймом Go.

Всё указывает на то, что gameoverlayrenderer64.dll, отвечающая за наложение Steam Overlay, конфликтует с механизмом асинхронной предвыборки в Go.

➖ Как исправить

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

go build -ldflags="-X=runtime.godebugDefault=asyncpreemptoff=1"

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

Эта проблема уже обсуждается в сообществе Go-разработчиков, и можно ожидать её решения в будущих релизах.

➡️ Обсуждение проблемы в Steam и GitHub

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

🧑‍💻 Гибкое тестирование в Go

Ginkgo это BDD-фреймворк (Behavior-Driven Development), который упрощает написание структурированных и читаемых тестов.

В отличие от стандартного testing пакета, Ginkgo дает гибкую систему организации тестов, поддержку параллельного выполнения, мощные моки и матчеры, а также удобный вывод результатов.

Особенно полезен Ginkgo для юнит-тестов, интеграционного тестирования и TDD-подхода. Он активно используется в Kubernetes, где тестирование играет ключевую роль.

Пример использования фреймворка:

func TestMain(t *testing.T) {
  RunSpecs(t, "Main Suite")
}

var _ = Describe("Простая арифметика", func() {
  Context("Операция сложения", func() {
    It("должна правильно складывать числа", func() {
      sum := 2 + 3
      if sum != 5 {
        Fail("Сумма 2 + 3 должна быть равна 5")
      }
    })
  })
})

➡️ Документация проекта

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

🔢 Проблемы с float в Go

В Go, как и в других языках, float32 и float64 могут выдавать неожиданные результаты из-за особенностей их представления в памяти.

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

fmt.Println(0.1 + 0.2) // 0.30000000000000004

Нельзя просто так взять и сравнить два числа с плавающей запятой. Проверка a == b может неожиданно вернуть false, если числа рассчитаны в разное время или через разные выражения.

➡️ Как избежать проблем

• Использовать пакет Decimal

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

• Сравнивать с учётом эпсилона

Когда сравниваете float-значения, лучше учитывать небольшую допустимую разницу:

const epsilon = 1e-9
if math.Abs(a-b) < epsilon {
    fmt.Println("Числа равны")
}

• Переключаться на целые числа

Если возможно, стоит использовать int или хранить денежные значения в копейках (например, 100 рублей = 10000 копеек).

📎 Больше примеров в статье

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

⚡️ Оптимизация запросов в Go с real-time batching

Real-time batching — это стратегия обработки входящих данных, при которой вместо выполнения каждой операции по одной они накапливаются в батч и обрабатываются вместе через небольшие интервалы времени.

➖Как это работает пошагово

1️⃣ Сбор событий в буфер — вместо того чтобы сразу обрабатывать каждое событие, мы добавляем его в очередь или в канал.

2️⃣ Таймер или лимит батча — если прошло, например, 50 мс, или набралось 100 событий, запускается обработка.

3️⃣ Групповая обработка — все собранные события обрабатываются одним запросом к базе данных, API или другому ресурсу.

➖ Где применяется

• Базы данных – массовые INSERT и UPDATE, минимизирующие нагрузку

• Очереди сообщений – накопление сообщений перед отправкой

• Логирование – запись логов блоками вместо построчной записи

• Аналитика – сбор событий перед отправкой в мониторинговую систему

➡️ Подробности с примерами кода в статье

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

🔥 База данных, выдерживающая триллионы запросов

Google Spanner — это уникальная распределённая SQL-база данных, сочетающая масштабируемость NoSQL и согласованность реляционных БД.

Как обрабатываются триллионы строк

➖ Шардирование и динамическое распределение. Данные разделены на «сплиты», которые автоматически перераспределяются между серверами в зависимости от нагрузки.

➖Алгоритм Paxos. Позволяет реплицировать данные между датацентрами без потери согласованности.

➖ TrueTime API. Google использует атомные и GPS-часы, чтобы обеспечить точную синхронизацию времени между серверами.

Где применяется

• Google Ads — миллиарды запросов в день

• Google Play — обработка глобальных транзакций

• YouTube — хранение и управление огромными объёмами данных

📎 Подробнее про Spanner

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

🛠 Декларативная валидация данных в Go

Zog – это библиотека, вдохновлённая Zod. Она позволяет гибко и декларативно проверять входные данные, минимизируя ручную обработку ошибок.

➖ Где пригодится

• Валидация JSON-запросов в API

• Проверка параметров HTTP-запросов

• Чтение и проверка переменных окружения

• Минимизация кода валидации и ошибок

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

var UserSchema = zog.Object(map[string]zog.Schema{
  "username": zog.String().Min(3).Max(20),
  "email":    zog.String().Email(),
  "age":      zog.Number().Min(18),
})

func main() {
  data := map[string]interface{}{
    "username": "go_dev",
    "email":    "[email protected]",
    "age":      25,
  }

  parsed, err := UserSchema.Parse(data)
  if err != nil {
    fmt.Println("Ошибка валидации:", err)
    return
  }

  fmt.Println("Успешно:", parsed)
}

Создаём схему UserSchema, где username должен быть строкой длиной от 3 до 20 символов, email – валидным email-адресом, а age – числом не меньше 18. Передаём тестовый JSON и проверяем его с помощью UserSchema.Parse().

А как вы валидируете данные? Напишите в комментарии👇

🖇 Официальный репозиторий проекта

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