🤔 Какой паттерн использовал в продукте/своем коде?

В реальных проектах часто используются:
- Builder — для конфигурации сложных объектов (например, HTTP-клиентов).
- Factory — для создания сервисов по интерфейсу.
- Singleton — для централизованного логгера или глобальных параметров.
- Также могут применяться Strategy, Adapter, Observer, особенно при построении архитектуры с плагинами, хранилищами, UI-обработкой.

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

🤔 Зачем используется дополнительный блок фигурных скобок в функции?

В Go дополнительный блок фигурных скобок {} в функции используется для ограничения области видимости переменных и улучшения читаемости кода. Это позволяет временно вводить переменные или выполнять локальные операции без влияния на остальную часть функции.

🚩Зачем это нужно

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

func processData() {
    {
        value := 42
        fmt.Println("Внутренний блок, value =", value) // value доступна только здесь
    }
    // fmt.Println(value) // Ошибка: value не определена за пределами блока
}

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

func readFile() {
    {
        file, err := os.Open("example.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close() // Закроется при выходе из блока

        // Работа с файлом
        fmt.Println("Чтение файла")
    }
    // Здесь файл уже закрыт
}

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

func main() {
    {
        // Работа с настройками
        config := loadConfig()
        fmt.Println("Конфигурация загружена:", config)
    }

    {
        // Работа с данными
        data := fetchData()
        fmt.Println("Данные получены:", data)
    }
}

🟠Проверка и тестирование отдельных блоков
Можно использовать дополнительные блоки для изоляции сложных кусков кода и последующего их упрощения.

func calculate() int {
    result := 0
    {
        a := 10
        b := 20
        result = a + b
    }
    return result
}

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

🤔 В чём разница шардирования и партиционирования?

- Шардирование — горизонтальное распределение данных по разным узлам или серверам. Например, одни пользователи хранятся в одном шарде, другие — в другом.
- Партиционирование — разбиение данных внутри одной базы или таблицы, например по дате, географии или категории. Все данные при этом могут оставаться на одном сервере.
Ключевое отличие: шардирование — про масштабирование инфраструктуры, партиционирование — про организацию данных внутри.

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

🤔 Можно ли изменить определенный символ в строке?

Нет, строки (string) в Go неизменяемы (immutable). Это значит, что нельзя просто изменить один символ в строке.

🚩Почему нельзя изменить символ?

Строка в Go — это байтовый срез ([]byte), но неизменяемый. Когда вы создаёте строку

s := "hello"

Ошибка при попытке изменения символа напрямую

s := "hello"
s[0] = 'H' // Ошибка: cannot assign to s[0]

🚩Как изменить символ в строке?

Поскольку строка неизменяема, вам нужно создать новую строку с заменённым символом.
Способ 1: Преобразовать в []byte (для ASCII-строк)
Если строка содержит только английские буквы и символы ASCII, её можно преобразовать в []byte, заменить символ и создать новую строку.

package main

import "fmt"

func main() {
    s := "hello"
    b := []byte(s) // Преобразуем в изменяемый []byte
    b[0] = 'H'     // Меняем первый символ
    s = string(b)  // Преобразуем обратно в строку

    fmt.Println(s) // "Hello"
}

Способ 2: Преобразовать в []rune (для Unicode)
Если строка содержит русские буквы, эмодзи или другие многобайтовые символы, используйте []rune.

package main

import "fmt"

func main() {
    s := "привет"
    r := []rune(s) // Преобразуем в []rune (массив символов)
    r[0] = 'П'     // Меняем первый символ
    s = string(r)  // Преобразуем обратно в строку

    fmt.Println(s) // "Привет"
}

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

🤔 Что такое репликация?

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

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

🤔 Как расшифровывается аббревиатура ACID?

ACID — это набор свойств транзакций в базах данных, обеспечивающий надежность и целостность данных.

🚩ACID

🟠A (Atomicity) — Атомарность
Транзакция выполняется либо полностью, либо не выполняется вовсе.
Пример: Если при переводе денег со счета A на счет B ошибка произошла на полпути, изменения откатываются.

🟠C (Consistency) — Согласованность
Данные остаются в правильном состоянии до и после транзакции.
Пример: Если сумма на всех счетах банка должна оставаться неизменной, транзакция не должна нарушить это правило.

🟠I (Isolation) — Изолированность
Одновременные транзакции не мешают друг другу.
Пример: Два клиента покупают один и тот же товар, но база данных правильно обрабатывает, кто купил первым.

🟠D (Durability) — Долговечность
После завершения транзакции изменения сохраняются, даже если система сломается.
Пример: Если заказ оформлен, он не исчезнет при внезапном отключении электричества.

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

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

Go использует трассирующий сборщик мусора с метками (mark-and-sweep).
Он проходит в два этапа:
1. Mark — находят все доступные (живые) объекты.
2. Sweep — освобождают недоступные (мертвые) объекты.
GC работает инкрементально и в параллель с приложением, начиная с Go 1.5.

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

🤔 Можно ли сделать 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)
    }
}

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

🤔 Что находится перед названием метода?

Перед названием метода указывается ресивер — переменная, к которой метод привязан. Он описывается в круглых скобках перед именем метода и указывает, для какого типа метод определён.
Здесь u *User — это ресивер. Он определяет, что метод PrintName относится к типу User, и при вызове будет доступ к его полям.

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

🤔 Сколько весит число в байтах?

Размер числа в байтах зависит от его типа данных. В 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
}

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

🤔 Что такое структура (struct) в Go? Зачем они нужны?

struct — это пользовательский тип данных в Go, который группирует поля с разными типами в единый объект. Структуры используются для моделирования сложных сущностей, таких как объекты реального мира, с их свойствами и поведением. Они позволяют организовать данные и методы, что делает код более читаемым и логичным. В отличие от классов в ООП, структуры Go не поддерживают наследование, но позволяют использовать композицию.

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

🤔 Как происходит поиск по ключу в map?

Карты (maps) реализованы на основе хеш-таблиц, что обеспечивает быстрый доступ к значениям по ключам. Давайте рассмотрим, как происходит поиск по ключу в карте, и какие этапы включены в этот процесс.

🚩Основные этапы

🟠Хеширование ключа
Сначала вычисляется хеш-значение ключа. Функция хеширования преобразует ключ в целое число, которое служит индексом в хеш-таблице.

🟠Поиск в хеш-таблице
Хеш-значение используется для доступа к соответствующей "ячейке" или "корзине" (bucket) в хеш-таблице.

🟠Поиск в корзине
Если корзина содержит несколько элементов (из-за коллизий хеширования), Go выполняет линейный поиск среди этих элементов, сравнивая ключи с использованием оператора ==.

🚩Детали

🟠Хеширование ключа
Когда вы пытаетесь получить значение по ключу, Go сначала вычисляет хеш-значение этого ключа. Хеш-функция берет ключ (например, строку или целое число) и преобразует его в индекс хеш-таблицы.

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

🟠Линейный поиск внутри корзины
Если корзина содержит несколько элементов, Go выполняет линейный поиск среди этих элементов. Для каждого элемента в корзине сравнивается ключ с искомым ключом с использованием оператора ==. Если ключи совпадают, возвращается соответствующее значение. Если ключ не найден, возвращается нулевое значение типа (zero value) и флаг, указывающий на отсутствие ключа.

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice:", value) // Alice: 25
    } else {
        fmt.Println("Alice not found")
    }

    value, exists = myMap["Charlie"]
    if exists {
        fmt.Println("Charlie:", value)
    } else {
        fmt.Println("Charlie not found") // Charlie not found
    }
}

🚩Подводные камни и особенности

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

🟠Производительность
В среднем, доступ к элементу в карте осуществляется за константное время O(1), что делает карты очень эффективными для поиска по ключу. Однако в худшем случае, при большой нагрузке коллизий, производительность может деградировать до линейного времени O(n).

🟠Изменение карты во время поиска
Карты не являются потокобезопасными. Если одна горутина изменяет карту, в то время как другая горутина читает из нее, это может привести к панике. Для обеспечения потокобезопасности используйте мьютексы или структуру sync.Map.

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

🤔 Чем юнит-тесты отличаются от интеграционных?

- Юнит-тесты проверяют отдельные функции или методы в изоляции от остального кода. Быстрые, лёгкие, часто запускаются.
- Интеграционные тесты проверяют взаимодействие между компонентами, например, работу сервиса с базой или API с внешней системой.
Юнит-тесты дают быструю обратную связь, интеграционные — показывают, как работает система целиком.

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

🤔 Как завершить много горутин?

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

🚩Использование каналов для управления горутинами

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

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(stopCh <-chan struct{}, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-stopCh:
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    stopCh := make(chan struct{})

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(stopCh, &wg, i)
    }

    // остановка горутин после 3 секунд
    time.Sleep(3 * time.Second)
    close(stopCh) // отправка сигнала всем горутинам остановиться
    wg.Wait()    // ожидание завершения всех горутин
}

🟠Использование пакета context

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

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func worker(ctx context.Context, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(ctx, &wg, i)
    }

    wg.Wait() // ожидание завершения всех горутин
    cancel()  // убедиться, что все ресурсы освобождены
}

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

🤔 Разница между WHERE и HAVING:

`WHERE` применяется до агрегации для фильтрации строк, а `HAVING` используется после агрегации для фильтрации агрегированных данных. Это значит, что `HAVING` может использоваться для условий, которые зависят от результатов функций агрегирования, таких как SUM или COUNT.

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

🤔 Что такое SSL?

SSL (Secure Sockets Layer) — это протокол, который обеспечивает безопасность передачи данных в интернете, используя шифрование. Он был разработан для защиты данных, передаваемых между клиентом (например, веб-браузером) и сервером (например, веб-сайтом), от перехвата и манипуляций.

🚩Основные функции

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

🚩Как работает

1⃣Установка соединения:
Клиент инициирует соединение с сервером, запрашивая защищенное соединение.
2⃣Передача сертификата:
Сервер отправляет свой цифровой сертификат, который содержит его публичный ключ и информацию о сервере.
3⃣Проверка сертификата:
Клиент проверяет сертификат, используя доверенные центры сертификации (CA), чтобы удостовериться в подлинности сервера.
4⃣Создание сессионных ключей:
Клиент и сервер используют асимметричное шифрование для обмена ключами сеанса, которые затем используются для симметричного шифрования данных в течение сессии.
5⃣Шифрование данных:
Все данные, передаваемые между клиентом и сервером, шифруются с использованием симметричных ключей, обеспечивая безопасность передачи.

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

При посещении веб-сайта с использованием HTTPS (например, https://example.com), SSL обеспечивает шифрование и безопасность данных, передаваемых между вашим браузером и сервером.

🚩Развитие

🟠SSL 1.0:
Никогда не был выпущен публично из-за серьезных уязвимостей.
🟠SSL 2.0:
Выпущен в 1995 году, но вскоре был признан небезопасным из-за множества уязвимостей.
🟠SSL 3.0:
Выпущен в 1996 году, значительно улучшил безопасность, но со временем также был признан устаревшим из-за уязвимостей (например, POODLE-атака).

🚩TLS как наследник SSL

🟠TLS (Transport Layer Security):
SSL был заменен протоколом TLS, который является его преемником и предлагает улучшенную безопасность. Текущие версии TLS (1.2 и 1.3) используются вместо SSL.
🟠Основные отличия:
TLS обеспечивает более сильное шифрование, лучшее управление сессионными ключами и устранение уязвимостей, найденных в SSL.

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

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

Git — это распределённая система контроля версий, которая позволяет:
- Отслеживать изменения в коде.
- Создавать ветки и экспериментировать без риска.
- Сотрудничать над проектами в команде. Git хранит историю в виде снимков состояний (commit), а не разницы (diff), что делает его быстрым и надёжным.

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

🤔 Для чего используют индексы?

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

🚩Для чего нужны индексы?

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

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

🟠Изменение значений (если структура изменяема)
В изменяемых структурах данных, таких как срезы или массивы, индекс позволяет присвоить новое значение конкретному элементу.

🟠Оптимизация поиска
Индексы упрощают и ускоряют доступ к данным, потому что доступ осуществляется за O(1) (константное время) в массивах или срезах.

🟠Индексы в строках
В строках индексы используются для доступа к конкретным байтам.

package main

import "fmt"

func main() {
    str := "Привет"
    
    fmt.Println(str[0])           // 208 (байт, не символ!)
    fmt.Printf("%c\n", str[0])    // П (символ, представленный первым байтом UTF-8)
}

🟠Индексы в массивах и срезах
В массивах и срезах индексы используются для извлечения и изменения значений

package main

import "fmt"

func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    
    fmt.Println(arr[2]) // 30
    
    // Изменение значения по индексу
    arr[2] = 100
    fmt.Println(arr) // [10 20 100 40 50]
}

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

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30, 40, 50}
    
    for i, v := range nums {
        fmt.Printf("Индекс: %d, Значение: %d\n", i, v)
    }
}

🟠Индексы и подстроки
Индексы полезны для извлечения подстрок с использованием срезов:

package main

import "fmt"

func main() {
    str := "Привет, Мир!"
    
    fmt.Println(str[8:12]) // Мир
}

🚩Ошибки работы с индексами

🟠Выход за границы
Если попытаться обратиться к элементу по индексу, который выходит за пределы коллекции, Go выдаст runtime panic:

   package main

   func main() {
       nums := []int{1, 2, 3}
       fmt.Println(nums[5]) // panic: runtime error: index out of range
   }
   

🟠Работа с многобайтовыми символами в строках
Если неверно учитывать байтовое представление символов UTF-8, можно получить некорректный результат.

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

🤔 Как устроена куча?

Куча — это область памяти, где:
- Выделение динамическое (во время выполнения).
- Используется для объектов переменной длины и длительного хранения.
- Управляется аллокатором или сборщиком мусора.
- Может фрагментироваться.
- Поддерживает аллокации разного размера, отслеживает свободные блоки.
В языках с GC куча управляется автоматически. В C/C++ — вручную через malloc/free.

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

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

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

🟠Конкатенация строк
Самый простой способ объединить строки — использовать оператор + или функцию fmt.Sprintf.

package main

import "fmt"

func main() {
    s1 := "Привет"
    s2 := "Мир"
    result := s1 + ", " + s2 + "!"
    fmt.Println(result) // Привет, Мир!
    
    // Через fmt.Sprintf
    formatted := fmt.Sprintf("%s, %s!", s1, s2)
    fmt.Println(formatted) // Привет, Мир!
}

🟠Получение длины строки
Функция len возвращает длину строки в байтах, а не в символах.

package main

import "fmt"

func main() {
    str := "Привет"
    fmt.Println(len(str)) // 12, так как кириллические символы занимают 2 байта
}

🟠Итерация по строке
Строки можно обойти как в виде байтов, так и в виде рун (Unicode символов).

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    str := "Привет"
    
    // Итерация по байтам
    for i := 0; i < len(str); i++ {
        fmt.Printf("Байт: %x\n", str[i])
    }

    // Итерация по символам (рунам)
    for _, runeValue := range str {
        fmt.Printf("Символ: %c\n", runeValue)
    }

    // Количество рун
    fmt.Println("Количество символов:", utf8.RuneCountInString(str))
}

🟠Извлечение подстроки
Так как строки неизменяемы, для извлечения подстроки используется срез (slice).

package main

import "fmt"

func main() {
    str := "Привет, Мир!"
    substring := str[8:] // С 8-го байта до конца
    fmt.Println(substring) // Мир!
}

🟠Разделение и объединение строк
Функции strings.Split и strings.Join из пакета strings позволяют разбивать строку на части или объединять части в строку.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "apple,banana,cherry"
    
    // Разделение строки
    parts := strings.Split(str, ",")
    fmt.Println(parts) // [apple banana cherry]
    
    // Объединение строк
    joined := strings.Join(parts, " | ")
    fmt.Println(joined) // apple | banana | cherry
}

🟠Поиск и замена подстроки
Для поиска подстроки можно использовать strings.Contains, strings.Index или strings.HasPrefix/strings.HasSuffix. Для замены — strings.Replace.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Go — это круто!"

    // Поиск подстроки
    fmt.Println(strings.Contains(str, "круто")) // true
    fmt.Println(strings.Index(str, "это"))     // 4

    // Замена подстроки
    newStr := strings.Replace(str, "круто", "отлично", 1)
    fmt.Println(newStr) // Go — это отлично!
}

🟠Преобразование регистра
Стандартная библиотека предоставляет функции для изменения регистра строки: strings.ToLower и strings.ToUpper.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, Go!"
    fmt.Println(strings.ToUpper(str)) // HELLO, GO!
    fmt.Println(strings.ToLower(str)) // hello, go!
}

🟠Тримминг строки
Удаление пробелов или других символов с начала/конца строки выполняется с помощью strings.Trim, strings.TrimSpace и других функций.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "   Hello, Go!   "
    fmt.Println(strings.TrimSpace(str)) // "Hello, Go!"
}

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