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

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

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

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

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

🤔 Как строки работают в 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

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

🤔 Что известно про паттерн Factory (Фабрика)?

Factory — это паттерн, скрывающий логику создания объектов за единым интерфейсом. Он позволяет:
- инкапсулировать создание объектов разного типа;
- выбирать реализацию в зависимости от условий;
- отделить клиентский код от конкретных типов.
Пример: создание разных видов подключений (TCP, HTTP, WebSocket) через одну фабрику, возвращающую интерфейс Connection.

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

🤔 Как закрыть канал?

В Go каналы (chan) можно закрывать с помощью close(channel), чтобы показать, что больше не будет отправляться данных.

Как закрыть канал?

ch := make(chan int)
close(ch) // Закрываем канал

Полный пример

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        for i := 1; i <= 3; i++ {
            ch <- i // Отправляем данные
        }
        close(ch) // Закрываем канал
    }()

    for val := range ch { // Читаем пока канал не закроется
        fmt.Println(val)
    }

    fmt.Println("Канал закрыт, чтение завершено")
}

Выход

1
2
3
Канал закрыт, чтение завершено

🚩Как проверить, закрыт ли канал?

Используем val, ok := <-ch:
- ok == true → канал открыт, есть данные.
- ok == false → канал закрыт.

package main

import "fmt"

func main() {
    ch := make(chan int)
    close(ch)

    val, ok := <-ch
    fmt.Println("val:", val, "ok:", ok) // val: 0 ok: false
}

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

🤔 Какой вес у пустой структуры?

Пустая структура в Go (struct{}) занимает 0 байт.
Она не содержит ни одного поля, и компилятор оптимизирует её до нуля. Это удобно, например, для использования в map[T]struct{} — в качестве множества без нагрузки на память.

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

🤔 Какие есть возможности у создания дочернего контекста данных?

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

🟠Управление временем выполнения операций
Контексты позволяют задавать дедлайны и таймауты для операций.
context.WithTimeout создает контекст с таймаутом, после которого операция будет автоматически отменена.

ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)
defer cancel()

context.WithDeadline создает контекст с дедлайном, который определяет точное время, после которого операция будет отменена.

deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(parentCtx, deadline)
defer cancel()

🟠Явная отмена операций
Контексты позволяют явно отменять операции, что полезно для управления горутинами и предотвращения утечек памяти.
context.WithCancel создает контекст, который может быть отменен вручную с помощью функции cancel.

ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

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

type key string
ctx := context.WithValue(parentCtx, key("userID"), 12345)

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

ctx1, cancel1 := context.WithCancel(parentCtx)
ctx2, cancel2 := context.WithTimeout(ctx1, 1*time.Second)
defer cancel1()
defer cancel2()

🟠Синхронизация горутин
Контексты обеспечивают механизм для синхронизации и координации работы нескольких горутин.
Пример синхронизации горутин

var wg sync.WaitGroup
ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

wg.Add(2)
go func() {
    defer wg.Done()
    worker(ctx, "Worker 1")
}()
go func() {
    defer wg.Done()
    worker(ctx, "Worker 2")
}()
wg.Wait()

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(1 * time.Second)
        }
    }
}

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

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "Request processed")
    case <-ctx.Done():
        err := ctx.Err()
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)

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

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

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

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

🤔 Что такое NAT?

Это технология, используемая для изменения сетевых адресов в заголовках пакетов данных, которые проходят через маршрутизатор или межсетевой экран. Она позволяет нескольким устройствам в локальной сети использовать один и тот же публичный IP-адрес для выхода в интернет.

🚩Основные типы

🟠Статический NAT (Static NAT):
Фиксированный сопоставление: Один внутренний IP-адрес сопоставляется с одним внешним IP-адресом. Используется, когда необходимо, чтобы устройство в локальной сети всегда было доступно под одним и тем же публичным IP-адресом. Например Веб-сервер, который должен быть доступен из интернета под фиксированным IP-адресом.

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

🟠Преобразование адресов и портов (PAT, Port Address Translation), также известный как Маскарадинг (Masquerading):
Несколько внутренних IP-адресов могут использовать один внешний IP-адрес, но различаются по номерам портов. Каждый внутренний IP-адрес и порт сопоставляется с уникальным внешним портом. Например, Домашние или офисные сети, где множество устройств выходят в интернет через один публичный IP-адрес.

🚩Зачем нужен

🟠Сохранение IP-адресов:
IPv4-адресов недостаточно для всех устройств, и NAT позволяет использовать один публичный IP-адрес для множества устройств.

🟠Безопасность:
Внутренние IP-адреса не видны извне, что усложняет потенциальным злоумышленникам попытки атак на внутренние устройства.

🟠Управление подключениями:
NAT позволяет администрировать и контролировать сетевой трафик, предоставляя возможности для управления доступом и приоритизацией трафика.

🚩Принцип работы

🟠Инициирование соединения:
Когда устройство в локальной сети (например, компьютер с IP-адресом 192.168.1.10) инициирует соединение с устройством в интернете, NAT изменяет исходящий IP-адрес и порт на внешний IP-адрес маршрутизатора и уникальный номер порта.

🟠Ответный трафик:
Когда ответный пакет возвращается, NAT использует таблицу сопоставлений, чтобы определить, к какому внутреннему устройству направить пакет, и изменяет внешний IP-адрес и порт обратно на внутренний IP-адрес и порт.

🚩Пример работы PAT

1⃣Внутренний компьютер с IP-адресом 192.168.1.10 и портом 12345 инициирует соединение.
2⃣NAT изменяет это на внешний IP-адрес 203.0.113.1 и порт 54321.
3⃣Ответный пакет от сервера приходит на IP-адрес 203.0.113.1 и порт 54321.
4⃣NAT преобразует это обратно в 192.168.1.10:12345 и отправляет пакет внутреннему компьютеру.

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

🤔 Расскажи про гарбидж коллектор

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

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

🤔 Как определить количество символов для строки?

В Go строки представлены как набор байтов ([]byte), но количество символов может отличаться, так как некоторые символы занимают несколько байтов (например, Unicode).

🚩Способы подсчёта символов в строке

len(s) – количество байтов (НЕ символов!)

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

utf8.RuneCountInString(s) – количество символов (РЕКОМЕНДУЕТСЯ )

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Привет"
    fmt.Println(utf8.RuneCountInString(s)) // 6, правильно считает символы
}

Подсчёт через range (альтернативный метод)

count := 0
for range "Привет" {
    count++
}
fmt.Println(count) // 6

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

🤔 Насколько безопасен слайс в контексте Concurrency?

Слайсы небезопасны для одновременного изменения. Их безопасно использовать только для чтения или с синхронизацией.

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

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

Один из полезных паттернов, который я использовал в реальном проекте на Go — это Worker Pool (пул воркеров).
Этот паттерн помогает ограничить количество горутин при обработке задач, чтобы не перегружать систему.

🚩Задача

В моём проекте был сервис, который обрабатывал тысячи файлов параллельно. Если запускать новую горутину на каждый файл, то память быстро заканчивалась, и сервер "умирал".
Решение: вместо создания тысяч горутин я использовал Worker Pool с фиксированным числом воркеров (например, 5), которые брали задачи из очереди.

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

Есть канал задач (jobs).
Есть пул воркеров (workers), которые читают задачи из канала.
Каждый воркер обрабатывает одну задачу и берёт следующую.

package main

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

// Количество воркеров
const workerCount = 5

// Воркер, который берет задачи из канала и обрабатывает их
func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
  defer wg.Done()
  for job := range jobs {
    fmt.Printf("Worker %d processing job %d\n", id, job)
    time.Sleep(time.Second) // Имитация обработки
  }
}

func main() {
  jobs := make(chan int, 10)
  var wg sync.WaitGroup

  // Запускаем воркеров
  for i := 1; i <= workerCount; i++ {
    wg.Add(1)
    go worker(i, jobs, &wg)
  }

  // Отправляем задачи в канал
  for j := 1; j <= 10; j++ {
    jobs <- j
  }
  close(jobs) // Закрываем канал, чтобы воркеры знали, что задачи кончились

  wg.Wait() // Ждём завершения всех воркеров
  fmt.Println("Все задачи обработаны")
}

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

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

Сериализация — это процесс преобразования объекта или структуры в формат, пригодный для хранения или передачи (например, в JSON, XML, бинарный формат).

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

🤔 Что такое интеграционные тесты?

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

🚩Зачем они нужны?

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

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

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

🚩Как их писать?

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

      // main.go
   package main

   import (
       "database/sql"
       _ "github.com/mattn/go-sqlite3"
       "log"
   )

   type User struct {
       ID   int
       Name string
   }

   func CreateUser(db *sql.DB, name string) (int, error) {
       res, err := db.Exec("INSERT INTO users(name) VALUES(?)", name)
       if err != nil {
           return 0, err
       }
       id, err := res.LastInsertId()
       if err != nil {
           return 0, err
       }
       return int(id), nil
   }

   func GetUser(db *sql.DB, id int) (User, error) {
       var user User
       err := db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name)
       if err != nil {
           return user, err
       }
       return user, nil
   }

   func main() {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           log.Fatal(err)
       }
       defer db.Close()

       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           log.Fatal(err)
       }
   }
        // main_test.go
   package main

   import (
       "database/sql"
       "testing"
       _ "github.com/mattn/go-sqlite3"
   )

   func setupTestDB(t *testing.T) *sql.DB {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           t.Fatal(err)
       }
       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           t.Fatal(err)
       }
       return db
   }

   func TestCreateAndGetUser(t *testing.T) {
       db := setupTestDB(t)
       defer db.Close()

       // Создание пользователя
       userID, err := CreateUser(db, "John Doe")
       if err != nil {
           t.Fatalf("Failed to create user: %v", err)
       }

       // Получение пользователя
       user, err := GetUser(db, userID)
       if err != nil {
           t.Fatalf("Failed to get user: %v", err)
       }

       // Проверка результатов
       if user.Name != "John Doe" {
           t.Errorf("Expected name to be 'John Doe', got %s", user.Name)
       }
   }

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

🤔 Что такое функция copy?

Функция copy копирует элементы из одного слайса в другой.
1. Синтаксис: copy(dst, src).
2. Копируется минимальное количество элементов, равное длине меньшего слайса.

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

🤔 В чем отличия http 1.1 и http 2?

Это версии протокола HTTP, каждая из которых имеет свои особенности и улучшения по сравнению с предыдущими версиями. Важные различия между этими версиями включают следующие аспекты:

🚩Мультиплексирование

🟠HTTP/1.1
Поддерживает одновременное открытие нескольких TCP соединений (обычно 6-8), что позволяет загружать несколько ресурсов параллельно. Однако каждое соединение может обрабатывать только один запрос за раз, что приводит к задержкам из-за блокировки очереди (head-of-line blocking).

🟠HTTP/2
Вводит мультиплексирование, позволяющее отправлять множество запросов и ответов асинхронно через одно единственное TCP соединение. Это значительно уменьшает задержки и улучшает производительность при загрузке страниц с большим количеством ресурсов.

🚩Бинарный протокол

🟠HTTP/1.1
Является текстовым протоколом, что означает, что запросы и ответы форматируются в виде читаемого текста.

🟠HTTP/2
Бинарный протокол, который делает передачу данных более эффективной и менее подверженной ошибкам в синтаксическом анализе. Бинарный формат упрощает реализацию парсеров и уменьшает размер передаваемых данных.

🚩Сжатие заголовков

🟠HTTP/1.1
Заголовки передаются без сжатия, что может привести к значительному объему передаваемых данных, особенно если одни и те же заголовки отправляются повторно с каждым запросом.

🟠HTTP/2
Использует механизм сжатия заголовков HPACK, который уменьшает избыточность заголовков, сжимая их перед отправкой. Это особенно эффективно для повторяющихся запросов к одним и тем же серверам.

🚩Приоритизация запросов

🟠HTTP/1.1
Не поддерживает приоритизацию запросов, из-за чего браузеры должны использовать эвристики для управления приоритетами ресурсов.

🟠HTTP/2
Поддерживает явную приоритизацию запросов, позволяя клиенту указывать приоритет обработки ресурсов, что делает загрузку страниц более эффективной.

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

🤔 Какие есть агрегатные функции?

Агрегатные функции работают с группами данных и возвращают один результат:
- COUNT() — количество.
- SUM() — сумма.
- AVG() — среднее.
- MIN(), MAX() — минимум и максимум.
- В некоторых СУБД есть STRING_AGG(), GROUP_CONCAT() — объединение строк.
Они часто используются с GROUP BY в SQL и при анализе данных.

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

🤔 Как сделать свои методы для пакета?

В Go методы создаются для структур (или типов) внутри пакета. Это позволяет добавлять логику и поведение объектам.

🚩Создание собственного пакета

Допустим, мы создаем пакет mathutils, который будет содержать метод для структуры Calculator.

package mathutils

// Calculator - структура с данными
type Calculator struct {
    A, B int
}

// Sum - метод для сложения чисел A и B
func (c Calculator) Sum() int {
    return c.A + c.B
}

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

Теперь мы можем использовать этот метод в основном файле программы.

package main

import (
    "fmt"
    "mypackage/mathutils" // Импортируем наш пакет
)

func main() {
    calc := mathutils.Calculator{A: 5, B: 3}
    fmt.Println("Sum:", calc.Sum()) // Выведет: Sum: 8
}

🚩Указатели vs. Значения в методах

Методы можно объявлять как для значений (func (c Calculator)) так и для указателей (func (c *Calculator)).
Когда использовать указатели?
Если метод изменяет данные структуры.
Чтобы избежать копирования больших структур.

func (c *Calculator) Multiply(factor int) {
    c.A *= factor
    c.B *= factor
}

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

🤔 Зачем синхронизировать доступ к данным?

Синхронизация необходима для предотвращения конфликтов при одновременном доступе из нескольких потоков (или горутин). Без синхронизации возможны:
- Повреждение данных
- Гонки (data race)
- Непредсказуемое поведение и ошибки
Примитивы синхронизации (mutex, atomic и т.д.) обеспечивают корректность и согласованность данных.

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

🤔 Go — императивный или декларативный?

Go — это императивный язык программирования.

🚩Почему Go императивный?

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

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 5; i++ {
        sum += i  // Явно изменяем переменную sum
    }
    fmt.Println("Сумма:", sum)
}

🚩Декларативные элементы в Go

Хотя Go — это в первую очередь императивный язык, в нем есть элементы декларативного подхода. Например:
🟠Функциональные элементы
map, filter через срезы и функции высшего порядка.
🟠Структурированность кода
интерфейсы позволяют писать код, в котором детали реализации скрыты (инкапсуляция).
🟠Go concurrency (goroutines, channels)
вместо явного управления потоками, мы декларируем взаимодействие через каналы.

package main

import "fmt"

func mapSlice(slice []int, f func(int) int) []int {
    result := make([]int, len(slice))
    for i, v := range slice {
        result[i] = f(v)  // Декларативное применение функции к элементам
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    squared := mapSlice(nums, func(n int) int { return n * n })
    fmt.Println(squared) // [1 4 9 16 25]
}

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