🤔 Что происходит при склеивании строк?

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

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

🤔 Зачем нужна Grafana?

Grafana — это инструмент для визуализации и мониторинга данных. Он позволяет строить дашборды (панели) с графиками, метриками и алертами, получая данные из различных источников (Prometheus, InfluxDB, Loki, MySQL и других).

🚩Основные возможности Grafana

🟠Визуализация данных
создание графиков, таблиц, гистограмм и других визуальных представлений.
🟠Мониторинг в реальном времени
отслеживание метрик серверов, баз данных, контейнеров и микросервисов.
🟠Гибкость источников данных
поддерживает Prometheus, Elasticsearch, MySQL, PostgreSQL и десятки других.
🟠Настраиваемые алерты
оповещения (email, Slack, Telegram) при достижении критических значений.
🟠Дашборды для DevOps
удобный интерфейс для анализа производительности систем.

🚩Зачем нужна Grafana?

🟠Для мониторинга серверов и приложений
Можно отслеживать загрузку CPU, RAM, количество запросов в базе, ошибки и задержки API.

🟠Для DevOps и SRE
Позволяет наблюдать за работой Kubernetes, Docker, CI/CD-пайплайнов и микросервисов.

🟠Для бизнес-аналитики
Может использоваться для отображения KPI, продаж, конверсий и других данных.

🟠Для алертов и оповещений
Если сервер падает или нагрузка превышает порог – Grafana уведомит команду.

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

Устанавливаем Prometheus и Grafana
Добавляем Prometheus как источник данных в Grafana
Создаём дашборд с метриками, например
Количество HTTP-запросов
Время ответа сервера
Количество активных соединений

http_requests_total{job="web_service"}

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

🤔 Какие последствия чтения из закрытого канала?

1. Чтение возможно – если в канале остались данные, они будут возвращены.
2. Получение zero-value – если канал пуст, возвращается нулевое значение типа (0 для int, "" для string и nil для указателей).
3. ok == false – можно проверить факт закрытия с помощью второго параметра при чтении (val, ok := <-chan).

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

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

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

🤔 Почему нельзя брать ссылку на значение, хранящееся по ключу в map?

Элементы map не гарантируют стабильное расположение в памяти, так как map может перераспределять внутренние данные. Это делает адрес элемента недействительным.

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

🤔 Что такое нормализация?

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

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

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

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

🚩Структура

🟠Указатель на базовый массив
Указатель на первый элемент массива, на который ссылается слайс.
🟠Длина (length)
Количество элементов, доступных в слайсе.
🟠Емкость (capacity)
Максимальное количество элементов, которое может содержать слайс без перераспределения памяти.

🚩Внутреннее устройство

Можно представить в виде структуры

type slice struct {
    ptr *ElementType // Указатель на базовый массив
    len int          // Длина
    cap int          // Емкость
}

🟠Слайс из массива
Можно создать из массива, указав диапазон элементов:

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(slice) // [2 3 4]
}

🟠Слайс с использованием функции make
Позволяет создать слайс определенной длины и емкости:

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5) // Слайс длиной 3 и емкостью 5
    fmt.Println(slice)         // [0 0 0]
}

🟠Доступ к элементам слайса
Осуществляется так же, как и к элементам массива:

package main

import "fmt"

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

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

🟠Добавление элементов
Для этого используется функция append

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4, 5) // Добавляем элементы 4 и 5 в конец слайса
    fmt.Println(slice)          // [1 2 3 4 5]
}

🟠Извлечение подмножества слайса (slicing)
Можно создавать новые слайсы на основе существующих

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    subSlice := slice[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(subSlice)  // [2 3 4]
}

🟠Копирование слайсов
Для этого используется функция copy

package main

import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    copy(dst, src)
    fmt.Println(dst) // [1 2 3]
}

🚩Динамическое изменение длины и емкости

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

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5)
    fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 1, 2, 3)
    fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 4)
    fmt.Println("After another append:", slice, "Len:", len(slice), "Cap:", cap(slice))
}

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

🤔 Как слайсы работают?

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

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

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

Существуют встроенные функции для преобразования типов, включая преобразование из строки в целое число и наоборот. Для этих целей используются функции из стандартной библиотеки strconv. Рассмотрим, как это делается.

🚩Преобразование строки в целое число

Для этого используется функция strconv.Atoi. Она возвращает два значения: само число и ошибку, если преобразование не удалось.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "123"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error converting string to int:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

🚩Преобразование целого числа в строку

Для этого используется функция strconv.Itoa.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 123
    str := strconv.Itoa(num)
    fmt.Println("Converted string:", str)
}

🚩Обработка ошибок при преобразовании

Важно обрабатывать ошибки при преобразовании типов, особенно при преобразовании строки в целое число, чтобы избежать неожиданных сбоев в программе.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "abc"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

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

🤔 Какой результат получим, если разделить int на 0 и float на 0?

Деление int на 0 вызовет паническую ошибку, а деление float на 0 вернёт +Inf, -Inf или NaN в зависимости от ситуации.

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

🤔 Как использовать линтеры (linters)?

Линтеры — это инструменты для автоматической проверки кода на ошибки, потенциальные баги и несоответствие стилю кодирования.

🟠Популярные линтеры для Go
В Go есть несколько популярных линтеров:
golangci-lint – самый мощный и популярный, объединяет множество линтеров.
go vet – стандартный инструмент для поиска ошибок.
golint – проверяет стиль кода (но устарел).
staticcheck – анализирует код на ошибки и неэффективность.

🟠Установка линтера
Устанавливаем golangci-lint (лучший вариант)

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

После установки проверьте версию:

golangci-lint --version

🟠Запуск линтера
Запустить проверку в проекте можно так:

golangci-lint run

Можно проверить только определённый файл:

golangci-lint run myfile.go

Если хотите автоматически исправлять ошибки, используйте:

golangci-lint run --fix

🟠Использование `go vet` (встроенный анализатор)
Go уже имеет встроенный линтер

go vet ./...

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

🤔 Что такое CI/CD?

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

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

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

В Go эффективное объединение строк – важная задача, поскольку строки неизменяемые. Неправильный подход (например, простая конкатенация s1 + s2 + s3) может привести к множественным аллокациям памяти и копированиям.

🚩Способы объединения строк

Использование strings.Builder (Рекомендуется)
Это самый эффективный способ склеивания строк, так как он минимизирует количество аллокаций.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var sb strings.Builder

    sb.WriteString("Hello")
    sb.WriteString(", ")
    sb.WriteString("World!")

    result := sb.String()
    fmt.Println(result) // Hello, World!
}

Использование + (Неэффективно )

s := "Hello" + ", " + "World!"

Использование fmt.Sprintf (Неэффективно )

s := fmt.Sprintf("%s, %s!", "Hello", "World")

Использование strings.Join (Хорошо для срезов )
Если строки хранятся в []string, strings.Join – это оптимальный вариант

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := []string{"Hello", "World", "Go"}
    result := strings.Join(words, ", ")
    fmt.Println(result) // Hello, World, Go
}

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

🤔 Что такое микросервисная архитектура?

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

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

🤔 Куда смотреть если лагает сервер?

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

🟠Логи (логирование)
Сначала проверяем логи!
Системные логи (journalctl -u myservice, /var/log/syslog, /var/log/messages)
Логи приложения (например, logs/app.log)
Nginx / Apache (/var/log/nginx/error.log, /var/log/httpd/error.log)
Пример просмотра последних 100 строк лога:

tail -n 100 /var/log/syslog

Если используете docker:

docker logs my_container --tail 100 -f

🟠Нагрузка на процессор и память
Проверяем, не перегружен ли сервер:

top
htop  # Более удобный интерфейс

Или просто:

ps aux --sort=-%cpu | head -10  # Топ-10 процессов по CPU
ps aux --sort=-%mem | head -10  # Топ-10 процессов по памяти

Если процесс "myapp" жрет CPU, смотрим его нагрузку:

pidstat -p $(pgrep myapp)

🟠Сетевые проблемы
Проверяем сетевую активность:

netstat -tulnp  # Слушающие порты
ss -tulnp       # Альтернатива netstat

Пингуем сервер:

ping google.com

Проверяем скорость соединения:

wget --output-document=/dev/null https://speedtest.tele2.net/10MB.zip

🟠Нагрузка на диск
Проверяем, не забит ли диск:

df -h   # Свободное место
du -sh /* | sort -h  # Топ занимаемых мест

Мониторинг активности диска:

iotop  # Если доступен

🟠База данных
Если сервер использует PostgreSQL / MySQL, смотрим запросы:

SHOW PROCESSLIST;  # MySQL: текущие запросы
SELECT * FROM pg_stat_activity;  # PostgreSQL: активные запросы

Проверяем медленные запросы (если включен slow_query_log):

tail -n 100 /var/log/mysql/slow.log

---

🟠Go-профилирование (если сервер на Go)
Включаем pprof и анализируем:

import _ "net/http/pprof"
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()

Запускаем профайлер:

go tool pprof https://localhost:6060/debug/pprof/profile?seconds=30

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

🤔 Как устроен процесс удаления из конца и начала массива?

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

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

🤔 Как строки работают в Golang внутри?

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

🚩Неизменяемость

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

🚩Структура строки

Внутренне строка представлена структурой, которая содержит два поля:
Указатель на массив байтов: Это указатель на первый элемент массива байт, который фактически хранит символы строки в кодировке UTF-8.
Длина: Количество байт в строке, а не количество рун или символов. Это важное различие, поскольку в UTF-8 один символ может занимать от 1 до 4 байт.

🚩UTF-8 как стандартная кодировка

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

🚩Срезы строк

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

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

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

s := "Hello, world"      // Создание строки
t := s[7:]               // Срез строки, создает новую строку "world"

fmt.Println(s)           // Выводит: Hello, world
fmt.Println(t)           // Выводит: world

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

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

Такая структура называется значимым типом (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
}

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

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

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

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