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

Нельзя напрямую взять ссылку на значение, хранящееся по ключу в карте (map), из-за особенностей реализации карт и управления памятью. Рассмотрим подробнее, почему это так.

Причины, почему нельзя брать ссылку на значение в карте

1️⃣Внутреннее устройство карты (map):
✅Карты реализованы на основе хеш-таблиц. Внутреннее устройство карты предполагает, что значения могут перемещаться в памяти при выполнении операций, таких как добавление или удаление элементов.
✅Хеш-таблица может перераспределять (реорганизовывать) свои внутренние структуры для оптимизации доступа к элементам. Это может происходить, например, когда карта увеличивается в размере.

2️⃣Потенциальная недействительность ссылок:
✅Если бы была возможность брать ссылки на значения, хранящиеся в карте, то при любой операции изменения карты (добавление, удаление элементов) ссылки могли бы становиться недействительными.
✅Это привело бы к потенциально небезопасному поведению программы, так как указатель (ссылка) мог бы указывать на уже несуществующую или перемещенную область памяти.

Демонстрация проблемы

Здесь попытка взять ссылку на значение из карты могла бы привести к проблемам:

package main

import "fmt"

func main() {
    m := map[string]int{"a": 1, "b": 2}

    // Нельзя делать так:
    // p := &m["a"]

    // Вместо этого можно работать с копией значения
    value := m["a"]
    p := &value

    fmt.Println("Value:", *p) // 1

    // Изменение карты
    m["c"] = 3

    // Ссылка на значение в карте могла бы стать недействительной
    // fmt.Println("Value after map change:", *p)
}

Правильные способы работы со значениями карты

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

1️⃣Работа с копией значения:
✅Получить значение из карты и сохранить его в переменную.

      value := m["a"]
   

2️⃣Изменение значения в карте:
✅Если необходимо изменить значение в карте, его нужно сначала извлечь, изменить, а затем снова записать в карту.

      value := m["a"]
   value = value + 10
   m["a"] = value
   

3️⃣Использование указателей в качестве значений:
✅В некоторых случаях можно использовать указатели в качестве значений карты, чтобы можно было изменять значения через указатели.

      package main

   import "fmt"

   func main() {
       m := map[string]*int{"a": new(int), "b": new(int)}
       *m["a"] = 1
       *m["b"] = 2

       // Теперь можно брать указатели на значения
       p := m["a"]
       fmt.Println("Value:", *p) // 1

       // Изменение значения через указатель
       *p = 42
       fmt.Println("Updated Value:", *m["a"]) // 42
   }
   

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как проводить тестирования в Go ?
Спросят с вероятностью 8%

Тестирование проводится с использованием встроенного пакета testing. Этот пакет предоставляет инструменты для написания и выполнения тестов, а также для измерения производительности кода. Рассмотрим основные аспекты тестирования в Go, включая создание тестов, запуск тестов и использование дополнительных возможностей пакета testing.

Создание тестов

Структура тестового файла

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

Написание тестов

Функции тестов должны начинаться с Test и принимать один параметр типа *testing.T. Это позволяет Go распознавать и запускать их как тесты.

package main

import (
    "testing"
)

// Функция, которую будем тестировать
func Add(a, b int) int {
    return a + b
}

// Тестовая функция
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

В этом примере тестовая функция TestAdd проверяет работу функции Add. Если результат не совпадает с ожидаемым значением, тестовая функция вызывает t.Errorf для регистрации ошибки.

Запуск тестов

Для этого используется команда go test. Эта команда автоматически находит и выполняет все тесты в текущем пакете.

go test

При запуске этой команды Go выполнит все тестовые функции, определенные в файлах _test.go, и выведет результаты.

Табличные тесты

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

package main

import (
    "testing"
)

// Функция, которую будем тестировать
func Add(a, b int) int {
    return a + b
}

// Табличный тест
func TestAdd(t *testing.T) {
    var tests = []struct {
        a, b, expected int
    }{
        {2, 3, 5},
        {1, 1, 2},
        {0, 0, 0},
        {-1, -1, -2},
    }

    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
        }
    }
}

Тестирование производительности (Benchmarks)

Для измерения производительности кода используются бенчмарки. Функции бенчмарков начинаются с Benchmark и принимают один параметр типа *testing.B.

package main

import (
    "testing"
)

// Функция, которую будем тестировать
func Add(a, b int) int {
    return a + b
}

// Бенчмарк
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

Для запуска бенчмарков используется команда go test с флагом -bench.

go test -bench=.

Иногда требуется пропустить выполнение некоторых тестов. Это можно сделать с помощью метода t.Skip.

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping test in short mode.")
    }
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want %d", result, 5)
    }
}

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

package main

import (
    "fmt"
)

// Функция, которую будем демонстрировать
func Add(a, b int) int {
    return a + b
}

// Пример использования функции Add
func ExampleAdd() {
    fmt.Println(Add(2, 3))
    // Output: 5
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как можно нарезать слайс: нюансы и подводные камни ?
Спросят с вероятностью 8%

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

Основы нарезки

Синтаксис

newSlice := originalSlice[start:end]

✅start: начальный индекс (включительно).
✅end: конечный индекс (исключительно).

Пример

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    newSlice := original[1:4] // Элементы с индексами 1, 2 и 3
    fmt.Println(newSlice) // [2 3 4]
}

Нюансы и подводные камни

1️⃣Индекс выхода за границы

При нарезке слайса важно, чтобы индексы start и end были в пределах длины исходного слайса. Нарушение этого правила приведет к панике (runtime panic).

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       
       // Это вызовет панику: runtime error: slice bounds out of range
       // newSlice := original[1:6]
       
       // Правильное использование
       newSlice := original[1:5]
       fmt.Println(newSlice) // [2 3 4 5]
   }
   

2️⃣Модификация исходного слайса

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

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 20 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

3️⃣Изменение длины и емкости

Длина нового слайса определяется как end - start. Емкость нового слайса определяется как cap(original) - start.

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       fmt.Println("New Slice Length:", len(newSlice)) // 3
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 4
   }
   

4️⃣Создание копий слайсов

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

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := make([]int, 3)
       copy(newSlice, original[1:4])
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 2 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

5️⃣Использование полной формы нарезки

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

      newSlice := original[start:end:max]
   

Это полезно, когда вы хотите контролировать емкость нового слайса.

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:3:4]
       fmt.Println("New Slice:", newSlice) // [2 3]
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 3
   }
   

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое unit тесты ?
Спросят с вероятностью 8%

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

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

1️⃣Проверка правильности кода: Помогают убедиться, что отдельные части программы работают правильно.
2️⃣Поддержка и рефакторинг: Они облегчают процесс модификации и улучшения кода, позволяя быстро проверить, что изменения не сломали существующую функциональность.
3️⃣Документация: Могут служить живой документацией кода, показывая примеры использования функций и их ожидаемое поведение.
4️⃣Уменьшение количества багов: Раннее обнаружение и исправление ошибок позволяет улучшить качество кода и снизить затраты на исправление багов в будущем.

Создание

Unit-тесты пишутся с использованием встроенного пакета testing. Рассмотрим процесс создания на примере.

Шаги для его создания

1️⃣Создание функции, которую нужно тестировать:

package main

// Функция, которую будем тестировать
func Add(a, b int) int {
    return a + b
}

2⃣Создание файла с тестами:
Создайте файл с суффиксом _test.go, например, main_test.go.

3⃣Написание тестовой функции:
Должна начинаться с Test и принимать параметр типа *testing.T.

package main

import "testing"

// Тестовая функция для Add
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

В этом примере функция TestAdd проверяет работу функции Add. Если результат не соответствует ожидаемому значению, вызывается метод t.Errorf, который регистрирует ошибку.

Запуск тестов

Для этого используйте команду go test.

go test

Табличные тесты

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

package main

import "testing"

// Функция, которую будем тестировать
func Add(a, b int) int {
    return a + b
}

// Табличный тест для Add
func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {2, 3, 5},
        {1, 1, 2},
        {0, 0, 0},
        {-1, -1, -2},
    }

    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
        }
    }
}

Примеры также могут служить unit-тестами, если они включают вывод, проверяемый пакетом testing.

package main

import "fmt"

// Функция, которую будем демонстрировать
func Add(a, b int) int {
    return a + b
}

// Пример использования функции Add
func ExampleAdd() {
    fmt.Println(Add(2, 3))
    // Output: 5
}

Преимущества:

1⃣Раннее обнаружение ошибок: Тесты помогают выявить ошибки на ранних стадиях разработки.
2⃣Упрощение рефакторинга: Обеспечивают уверенность в том, что изменения в коде не нарушают существующую функциональность.
3⃣Документация: Тесты служат примером использования функций и методов, что облегчает понимание кода.
4⃣Повышение качества кода: Постоянное тестирование помогает поддерживать высокий уровень качества и надежности кода.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как можно слить два слайса ?
Спросят с вероятностью 8%

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

Слияние двух слайсов

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

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := []int{4, 5, 6}

    // Используем оператор разворачивания `...`, чтобы добавить все элементы slice2 в slice1
    mergedSlice := append(slice1, slice2...)

    fmt.Println("Slice 1:", slice1)         // [1 2 3]
    fmt.Println("Slice 2:", slice2)         // [4 5 6]
    fmt.Println("Merged Slice:", mergedSlice) // [1 2 3 4 5 6]
}

Пояснение

Здесь:
1️⃣Создаются два слайса slice1 и slice2.
2️⃣Используется функция append и оператор разворачивания ..., чтобы добавить все элементы slice2 в slice1.
3️⃣Результатом является новый слайс mergedSlice, содержащий элементы из обоих исходных слайсов.

Пример 2: Слияние строковых слайсов

package main

import "fmt"

func main() {
    slice1 := []string{"a", "b", "c"}
    slice2 := []string{"d", "e", "f"}

    // Слияние строковых слайсов
    mergedSlice := append(slice1, slice2...)

    fmt.Println("Slice 1:", slice1)         // [a b c]
    fmt.Println("Slice 2:", slice2)         // [d e f]
    fmt.Println("Merged Slice:", mergedSlice) // [a b c d e f]
}

Пример с предварительным созданием результирующего слайса

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

Пример 3: Использование copy и append

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := []int{4, 5, 6}

    // Создаем результирующий слайс с нужной емкостью
    mergedSlice := make([]int, len(slice1) + len(slice2))

    // Копируем элементы из первого слайса
    copy(mergedSlice, slice1)

    // Добавляем элементы из второго слайса
    copy(mergedSlice[len(slice1):], slice2)

    fmt.Println("Slice 1:", slice1)         // [1 2 3]
    fmt.Println("Slice 2:", slice2)         // [4 5 6]
    fmt.Println("Merged Slice:", mergedSlice) // [1 2 3 4 5 6]
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое интеграционные тесты ?
Спросят с вероятностью 8%

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

Почему они нужны:
1️⃣Проверка взаимодействия компонентов: Убедиться, что различные части системы правильно взаимодействуют друг с другом.
2️⃣Выявление проблем на ранних этапах: Легче и дешевле исправлять ошибки, обнаруженные на этапе тестирования, чем в продакшене.
3️⃣Гарантия целостности системы: Обеспечить, что изменения в одном модуле не сломают другие модули.

Как они используются:
Обычно пишутся после написания модульных тестов и перед тестированием всей системы (end-to-end тестированием). Они охватывают больше кода, чем модульные тесты, и часто взаимодействуют с внешними сервисами, такими как базы данных или веб-сервисы.

Рассмотрим простую систему, где есть два модуля: модуль для работы с базой данных и модуль для обработки HTTP-запросов.

// file: main.go
package main

import (
  "database/sql"
  "fmt"
  "log"
  "net/http"

)

var db *sql.DB

func main() {
  var err error
  db, err = sql.Open("sqlite3", "./foo.db")
  if err != nil {
    log.Fatal(err)
  }
  defer db.Close()

  http.HandleFunc("/user", getUserHandler)
  log.Fatal(http.ListenAndServe(":8080", nil))
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
  id := r.URL.Query().Get("id")
  user, err := getUserByID(id)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }
  fmt.Fprintf(w, "User: %s", user)
}

func getUserByID(id string) (string, error) {
  var name string
  err := db.QueryRow("SELECT name FROM users WHERE id = ?", id).Scan(&name)
  if err != nil {
    return "", err
  }
  return name, nil
}

Для написания интеграционного теста мы можем использовать библиотеку

net/http/httptest

для тестирования HTTP-запросов и библиотеки для работы с базой данных:

// file: main_test.go
package main

import (
  "net/http"
  "net/http/httptest"
  "testing"

)

func TestGetUserHandler(t *testing.T) {
  // Подготовка тестовой базы данных
  db, err := sql.Open("sqlite3", ":memory:")
  if err != nil {
    t.Fatal(err)
  }
  defer db.Close()
  db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
  db.Exec("INSERT INTO users (id, name) VALUES (1, 'Alice')")

  // Создание запроса
  req, err := http.NewRequest("GET", "/user?id=1", nil)
  if err != nil {
    t.Fatal(err)
  }

  // Создание ResponseRecorder для записи ответа
  rr := httptest.NewRecorder()
  handler := http.HandlerFunc(getUserHandler)

  // Выполнение запроса
  handler.ServeHTTP(rr, req)

  // Проверка ответа
  expected := "User: Alice"
  if rr.Body.String() != expected {
    t.Errorf("expected %v, got %v", expected, rr.Body.String())
  }
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое функция copy ?
Спросят с вероятностью 8%

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

Синтаксис функции

func copy(dst, src []T) int

✅dst: слайс назначения (куда будут копироваться элементы).
✅src: слайс источника (откуда будут копироваться элементы).

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

Пример 1: Копирование слайса

package main

import "fmt"

func main() {
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 5) // Создаем слайс назначения длиной 5

    n := copy(dst, src) // Копируем элементы из src в dst
    fmt.Println("Copied elements:", n) // 5
    fmt.Println("Destination slice:", dst) // [1 2 3 4 5]
}

Пример 2: Частичное копирование

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

package main

import "fmt"

func main() {
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 3) // Создаем слайс назначения длиной 3

    n := copy(dst, src) // Копируем элементы из src в dst
    fmt.Println("Copied elements:", n) // 3
    fmt.Println("Destination slice:", dst) // [1 2 3]
}

Пример 3: Копирование в пустой слайс

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

package main

import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, 5) // Создаем слайс назначения длиной 5

    n := copy(dst, src) // Копируем элементы из src в dst
    fmt.Println("Copied elements:", n) // 3
    fmt.Println("Destination slice:", dst) // [1 2 3 0 0]
}

Применение функции copy

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

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

Функция copy является полезным инструментом для копирования элементов между слайсами. Она возвращает количество скопированных элементов и автоматически обрабатывает случаи, когда длина слайсов различается.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как в Go пишут unit тесты со стандартным пакетом testing ?
Спросят с вероятностью 8%

Модульные тесты (unit tests) пишутся с использованием стандартного пакета testing. Они направлены на проверку отдельных функций или методов в изоляции, чтобы убедиться, что каждая функция работает корректно.

Как это делается:

1️⃣Создание тестового файла: Тестовые файлы должны иметь суффикс _test.go. Например, если у вас есть файл math.go, тестовый файл для него будет называться math_test.go.
2️⃣Написание тестовых функций: Тестовые функции должны начинаться с Test, а их имя должно быть описательным. Например, TestAdd для функции Add.
3️⃣Использование метода `t.Errorf` или t.Fatalf: Эти методы позволяют сообщать о провале теста. t.Errorf продолжает выполнение тестов после ошибки, а t.Fatalf завершает выполнение текущего теста.

Допустим, у нас есть простая функция для сложения двух чисел в файле math.go:

// file: math.go
package math

func Add(a, b int) int {
  return a + b
}

Создадим тест для этой функции в файле math_test.go:

// file: math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
  result := Add(2, 3)
  expected := 5
  if result != expected {
    t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
  }
}

Детали:

1️⃣Импорт пакетамер, TestAd Это обязательный шаг для использования функций и типов, предоставляемых пакетом testing.
2️⃣Определение тестовой функции: Функция должна принимать один аргумент типа *testing.T. Это структура, предоставляемая пакетом testing, которая используется для логирования и отчета об ошибках.
3️⃣Проверка результата: Внутри тестовой функции вы вызываете тестируемую функцию, проверяете результат и используете методы t.Errorf или t.Fatalf для сообщения о несоответствиях.

Расширенные возможности:

✅Табличные тесты: Полезны для тестирования нескольких сценариев с разными входными данными и ожидаемыми результатами.

func TestAddTableDriven(t *testing.T) {
  tests := []struct {
    a, b   int
    result int
  }{
    {1, 1, 2},
    {2, 3, 5},
    {10, -2, 8},
    {-1, -1, -2},
  }

  for _, tt := range tests {
    t.Run(fmt.Sprintf("%d+%d", tt.a, tt.b), func(t *testing.T) {
      res := Add(tt.a, tt.b)
      if res != tt.result {
        t.Errorf("Add(%d, %d) = %d; expected %d", tt.a, tt.b, res, tt.result)
      }
    })
  }
}

Чтобы запустить тесты, используйте команду:

go test

Эта команда автоматически находит все файлы с суффиксом _test.go, компилирует их и запускает тестовые функции.

Модульные тесты пишутся с использованием стандартного пакета testing. Они помогают убедиться, что отдельные функции работают правильно. Тесты создаются в файлах с суффиксом _test.go и включают тестовые функции, начинающиеся с Test, которые проверяют результаты работы функций и сообщают о несоответствиях.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое моки (mocks) ?
Спросят с вероятностью 8%

Моки (mocks) – это имитации объектов или компонентов, которые используются в тестировании для замены реальных объектов. Они помогают изолировать тестируемый код, эмулируя поведение зависимостей, таких как базы данных, внешние API или другие сервисы. Это особенно полезно в модульных тестах, где важно проверить функциональность конкретного блока кода без влияния внешних факторов.

Зачем они нужны:

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

Как их использовать:

Для создания их часто используются интерфейсы и специальные библиотеки, такие как gomock или testify/mock.

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

1️⃣Определение интерфейса:

// file: user.go
package user

type User struct {
  ID   int
  Name string
}

type UserRepository interface {
  GetUserByID(id int) (*User, error)
}

2️⃣Создание функции, использующей интерфейс:

// file: service.go
package user

type UserService struct {
  Repo UserRepository
}

func (s *UserService) GetUserName(id int) (string, error) {
  user, err := s.Repo.GetUserByID(id)
  if err != nil {
    return "", err
  }
  return user.Name, nil
}

3️⃣Написание теста с использованием мока:

// file: service_test.go
package user

import (
  "testing"

  "github.com/stretchr/testify/assert"
  "github.com/stretchr/testify/mock"
)

// MockUserRepository is a mock implementation of the UserRepository interface.
type MockUserRepository struct {
  mock.Mock
}

func (m *MockUserRepository) GetUserByID(id int) (*User, error) {
  args := m.Called(id)
  return args.Get(0).(*User), args.Error(1)
}

func TestGetUserName(t *testing.T) {
  mockRepo := new(MockUserRepository)
  service := UserService{Repo: mockRepo}

  // Определяем поведение мока
  mockRepo.On("GetUserByID", 1).Return(&User{ID: 1, Name: "Alice"}, nil)

  // Выполнение теста
  name, err := service.GetUserName(1)

  // Проверка результатов
  assert.NoError(t, err)
  assert.Equal(t, "Alice", name)

  // Проверка, что мок был вызван с правильными параметрами
  mockRepo.AssertExpectations(t)
}

Объяснение:

1️⃣Определение интерфейса: Интерфейс UserRepository определяет метод GetUserByID.
2️⃣Использование интерфейса в сервисе: Сервис UserService использует UserRepository для получения информации о пользователе.
3️⃣Создание мока: Мы создаем мок MockUserRepository, реализующий интерфейс UserRepository.
4️⃣Определение поведения мока: Устанавливаем ожидания, что метод GetUserByID будет вызван с определенными параметрами и вернет заданные результаты.
5️⃣Тестирование сервиса: Проверяем, что метод GetUserName возвращает правильное значение, и что мок был вызван с ожидаемыми параметрами.

Моки – это заменители реальных объектов, используемые в тестировании для изоляции кода, ускорения тестов и создания предсказуемых условий. Для этого часто используют интерфейсы и библиотеки, такие как testify/mock.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как можно добавить элементы в слайс ?
Спросят с вероятностью 8%

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

Использование append для добавления элементов в слайс

1️⃣Добавление одного элемента

Чтобы это сделать используйте append следующим образом:

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4) // Добавление одного элемента
    fmt.Println(slice) // [1 2 3 4]
}

2️⃣Добавление нескольких элементов

Чтобы это сделать передайте их через запятую:

package main

import "fmt"

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

3️⃣Добавление элементов из другого слайса

Чтобы это сделать используйте оператор разворачивания (...):

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := []int{4, 5, 6}
    slice1 = append(slice1, slice2...) // Добавление элементов из slice2 в slice1
    fmt.Println(slice1) // [1 2 3 4 5 6]
}

Пример динамического увеличения емкости слайса

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

package main

import "fmt"

func main() {
    slice := make([]int, 0, 2) // Создаем слайс длиной 0 и емкостью 2
    fmt.Println("Initial:", slice, "Len:", len(slice), "Cap:", cap(slice))

    // Добавляем элементы
    slice = append(slice, 1)
    fmt.Println("After append 1:", slice, "Len:", len(slice), "Cap:", cap(slice))

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

    slice = append(slice, 3) // Емкость увеличивается автоматически
    fmt.Println("After append 3:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 4, 5, 6) // Добавляем несколько элементов
    fmt.Println("After append 4, 5, 6:", slice, "Len:", len(slice), "Cap:", cap(slice))
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Опишите алгоритм, как будет происходить вставка в Map ?
Спросят с вероятностью 8%

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

1️⃣Хеширование ключа: Вычисляется хеш-код для ключа с использованием функции хеширования. Это дает нам число, которое будет использоваться для определения позиции ключа в хеш-таблице.

2️⃣Определение индекса: Индекс в массиве корзин (buckets) вычисляется на основе хеш-кода и размера массива. Обычно используется операция побитового И (&) для получения индекса.

3️⃣Поиск корзины: С использованием вычисленного индекса определяется конкретная корзина, в которую будет помещен ключ.

4️⃣Проверка на коллизию: Если корзина уже содержит элементы, проверяется, есть ли в ней элемент с таким же ключом:
✅Если элемент с таким ключом уже существует, его значение обновляется новым значением.
✅Если элемент с таким ключом не найден, новый ключ-значение добавляется в корзину.

5️⃣Вставка элемента: Новый элемент добавляется в соответствующую корзину.

Алгоритм вставки на более низком уровне:

1️⃣Хеширование ключа:

        hash := hashFunction(key)
    

2️⃣Определение индекса:

        index := hash & (len(buckets) - 1)
    

3️⃣Поиск корзины и проверка на коллизию:
✅Проверяем корзину по индексу:

            bucket := buckets[index]
      

✅Итерируемся по элементам в корзине для поиска совпадения ключа:

            for _, element := range bucket {
          if element.key == key {
              element.value = newValue
              return
          }
      }
      

4️⃣Добавление нового элемента:
✅Если совпадения ключа не найдено, добавляем новый элемент в корзину:

            bucket = append(bucket, newElement)
      

Пример вставки элемента в карту:

package main

import "fmt"

func main() {
    // Создаем карту
    myMap := make(map[string]int)

    // Вставка элементов
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    // Обновление значения существующего ключа
    myMap["Alice"] = 26

    // Печать карты
    fmt.Println(myMap)
}

В этом примере:
1️⃣Создается карта myMap с ключами типа string и значениями типа int.
2️⃣Вставляются пары ключ-значение: "Alice": 25 и "Bob": 30.
3️⃣Значение для ключа "Alice" обновляется на 26.
4️⃣Карта выводится на экран.

Важные моменты:

✅Коллизии: Если два ключа имеют один и тот же хеш-код, они попадают в одну корзину. Решение коллизий обычно осуществляется с помощью связных списков или других структур данных внутри каждой корзины.
✅Распределение хеша: Хорошая функция хеширования равномерно распределяет ключи по корзинам, минимизируя количество коллизий.
✅Динамическое изменение размера: При переполнении корзин карта автоматически увеличивает размер массива корзин, чтобы поддерживать эффективное время выполнения операций.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых