Golang | Вопросы собесов

🤔 Как в Go объявить инициализатор структуры, выполняющийся при создании экземпляра?

Anonymous Quiz

22%

func (s *Struct) init()

func (s *Struct) Constructor()

312 voters1.5K views16:10

Golang | Вопросы собесов

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

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

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

package main

import (
    "fmt"
)

func findElement(slice []int, value int) (int, bool) {
    for i, v := range slice {
        if v == value {
            return i, true
        }
    }
    return -1, false
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index, found := findElement(slice, 3)
    if found {
        fmt.Printf("Element found at index %d\n", index)
    } else {
        fmt.Println("Element not found")
    }
}

Временная сложность линейного поиска составляет O(n), где n — количество элементов в слайсе. Это означает, что время поиска увеличивается пропорционально количеству элементов в слайсе.

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

package main

import (
    "fmt"
)

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

    value, exists := myMap["Bob"]
    if exists {
        fmt.Printf("Value: %d\n", value)
    } else {
        fmt.Println("Key not found")
    }
}

Временная сложность поиска в карте составляет O(1) в среднем случае, что означает, что время поиска не зависит от количества элементов в карте.

Сравнение производительности

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

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

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

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

1.3K views09:10

Golang | Вопросы собесов

🤔 Как в Go определить инициализацию переменной при первом обращении к ней?

Anonymous Quiz

317 voters1.1K views16:10

Golang | Вопросы собесов

Как правильно объявлять Маппу ?
Спросят с вероятностью 8%

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

Объявление карты

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

var myMap map[KeyType]ValueType

Пример:

var ages map[string]int

Здесь ages — это карта, где ключи имеют тип string, а значения — int.

Инициализация карты

Использование функции make

Создает и инициализирует карту:

ages := make(map[string]int)

Литерал карты

Для инициализации:

ages := map[string]int{
    "Alice": 25,
    "Bob": 30,
}

Работа с ними

Элементы добавляются или обновляются с использованием синтаксиса индексирования:

ages["Charlie"] = 35

Извлечение элементов

Для этого используется синтаксис индексирования:

age := ages["Alice"]
fmt.Println(age) // 25

Проверка существования ключа

Для этого можно использовать двойное присваивание:

age, exists := ages["David"]
if exists {
    fmt.Println("Age of David:", age)
} else {
    fmt.Println("David not found")
}

Удаление элементов

Для этого используется встроенная функция delete:

delete(ages, "Alice")

Пример:

package main

import (
    "fmt"
)

func main() {
    // Объявление и инициализация карты
    ages := make(map[string]int)
    
    // Добавление элементов
    ages["Alice"] = 25
    ages["Bob"] = 30

    // Извлечение элементов
    fmt.Println("Age of Alice:", ages["Alice"])
    fmt.Println("Age of Bob:", ages["Bob"])

    // Проверка существования ключа
    if age, exists := ages["Charlie"]; exists {
        fmt.Println("Age of Charlie:", age)
    } else {
        fmt.Println("Charlie not found")
    }

    // Удаление элемента
    delete(ages, "Alice")

    // Итерация по карте
    for name, age := range ages {
        fmt.Printf("%s is %d years old\n", name, age)
    }
}

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

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

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

1.2K views09:10

Golang | Вопросы собесов

🤔 Какой метод структуры используется для сериализации объекта в JSON формат?

Anonymous Quiz

340 voters1.1K views16:10

Golang | Вопросы собесов

Как думаешь, будут ли MAP ordered ?
Спросят с вероятностью 8%

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

Почему они не упорядочены?

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

Какие проблемы могут возникнуть?

1️⃣Непредсказуемый порядок: При каждой итерации по карте порядок элементов может меняться.

        m := map[string]int{"a": 1, "b": 2, "c": 3}
    for k, v := range m {
        fmt.Println(k, v)
    }
    // Порядок вывода может быть разным при каждом запуске.

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

Что делать, если нужен упорядоченный вывод?

1️⃣Срезы для сортировки ключей:

        m := map[string]int{"a": 1, "b": 2, "c": 3}
    var keys []string
    for k := range m {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Println(k, m[k])
    }

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

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

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

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

1.2K views09:10

Golang | Вопросы собесов

🤔 Какой интерфейс должен реализовывать тип, чтобы его можно было использовать в качестве ключа в map?

Anonymous Quiz

358 voters1.1K views16:10

Golang | Вопросы собесов

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

Существует один основной цикл — это цикл for. н может использоваться в различных формах, выполняя функции традиционных циклов while, do-while и классического for.
Формы цикла

1️⃣С тремя выражениями:

      package main

   import "fmt"

   func main() {
       for i := 0; i < 5; i++ {
           fmt.Println(i)
       }
   }

В этом примере классический цикл for состоит из трех частей: инициализация (i := 0), условие (i < 5) и инкремент (i++). Этот формат аналогичен циклу for в других языках программирования, таких как C или Java.

2️⃣Как `while`:

      package main

   import "fmt"

   func main() {
       i := 0
       for i < 5 {
           fmt.Println(i)
           i++
       }
   }

В данном случае цикл for используется как while. Условие (i < 5) проверяется перед каждой итерацией, и цикл продолжается, пока условие истинно.

3️⃣Бесконечный:

      package main

   import "fmt"

   func main() {
       i := 0
       for {
           if i >= 5 {
               break
           }
           fmt.Println(i)
           i++
       }
   }

Бесконечный цикл создается с использованием for без условий. Для выхода из такого цикла необходимо использовать операторы break или return.

4️⃣ С использованием range :

      package main

   import "fmt"

   func main() {
       arr := []int{1, 2, 3, 4, 5}
       for index, value := range arr {
           fmt.Printf("Index: %d, Value: %d\n", index, value)
       }
   }

Цикл for с использованием range позволяет итерироваться по элементам массивов, срезов, карт, строк и каналов. В данном примере index представляет индекс текущего элемента, а value — его значение.

Примеры:

1️⃣Итерация по массиву:

      arr := [5]int{10, 20, 30, 40, 50}
   for i := 0; i < len(arr); i++ {
       fmt.Println(arr[i])
   }

2️⃣Итерация по карте:

      m := map[string]int{"a": 1, "b": 2, "c": 3}
   for key, value := range m {
       fmt.Printf("Key: %s, Value: %d\n", key, value)
   }

3️⃣Итерация по строке:

      s := "hello"
   for index, char := range s {
       fmt.Printf("Index: %d, Char: %c\n", index, char)
   }

Есть только один основной цикл — for, который можно использовать как классический for, while, бесконечный цикл или цикл по коллекциям с range. Этот подход обеспечивает гибкость и простоту написания циклов в различных ситуациях.

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

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

1.8K views09:10

Golang | Вопросы собесов

🤔 Какой метод нужно реализовать, чтобы структура удовлетворяла интерфейсу fmt.Stringer?

Anonymous Quiz

318 voters1.7K views16:10

Golang | Вопросы собесов

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

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

Что это такое?

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

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

Существует несколько способов создания:

1️⃣Создание слайса из массива:

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

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

        slice := make([]int, 5) // слайс из 5 элементов, инициализированных нулями
    fmt.Println(slice) // [0 0 0 0 0]

3️⃣Создание слайса литералом:

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

Изменение размера слайса

С помощью функции append:

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

Доступ к элементам слайса и изменение их

Аналогичны работе с массивами:

slice := []int{1, 2, 3}
fmt.Println(slice[1]) // 2
slice[1] = 20
fmt.Println(slice) // [1 20 3]

Итерация по слайсу

Выполняется с помощью цикла for:

slice := []int{1, 2, 3, 4, 5}
for i, v := range slice {
    fmt.Printf("Index: %d, Value: %d\n", i, v)
}

Копирование

Для этого используется функция copy:

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

Особенности

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

        slice := make([]int, 3, 5) // длина 3, емкость 5
    fmt.Println(len(slice)) // 3
    fmt.Println(cap(slice)) // 5

✅Срез (slicing): Можно создавать новые слайсы из существующих.

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

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

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

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

2.4K views09:10

Golang | Вопросы собесов

Please open Telegram to view this post

VIEW IN TELEGRAM

3.3K viewsedited 11:57

Golang | Вопросы собесов

Golang | Вопросы собесов pinned «👾 349 вопросов собесов на Golang Developer 🔒 База реальных собесов 🔒 База тестовых заданий 👾 Список менторов 👣 Golang ├ Вакансии ├ LeetCode ответы └ Тесты 👩‍💻 С/С++ ├ Вопросы собесов ├ Вакансии ├ LeetCode ответы └ Тесты 👩‍💻 PHP ├ Вопросы собесов ├ Вакансии…»

11:57

Golang | Вопросы собесов

🤔 Какое ключевое слово используется для объявления неименованного канала в Go?

Anonymous Quiz

466 voters1.7K views16:10

Golang | Вопросы собесов

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

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

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

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

2️⃣Модификация данных:
✅Указатели позволяют функциям изменять значения переменных, передаваемых им в качестве аргументов. Это позволяет создавать более гибкие и мощные функции.

3️⃣Создание сложных структур данных:
✅Указатели используются для создания ссылочных типов данных, таких как связные списки, деревья и графы.

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

1️⃣Создание и использование:

      package main

   import "fmt"

   func main() {
       var x int = 10
       var p *int // Объявление указателя на int
       p = &x     // Присваивание указателю адреса переменной x

       fmt.Println("Value of x:", x)     // Output: 10
       fmt.Println("Address of x:", p)   // Вывод адреса x
       fmt.Println("Value via p:", *p)   // Разыменование указателя, Output: 10
   }

Здесь переменная p является указателем на int и хранит адрес переменной x. Разыменование указателя (*p) позволяет получить значение, хранящееся по этому адресу.

2️⃣Функции:

      package main

   import "fmt"

   func main() {
       x := 10
       fmt.Println("Before:", x) // Output: 10

       increment(&x)
       fmt.Println("After:", x)  // Output: 11
   }

   func increment(p *int) {
       *p++ // Увеличение значения по адресу, на который указывает p
   }

В данном примере функция increment принимает указатель на int и увеличивает значение по этому адресу. Это позволяет изменять значение переменной x непосредственно.

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

      package main

   import "fmt"

   type Person struct {
       name string
       age  int
   }

   func main() {
       p := Person{name: "Alice", age: 30}
       fmt.Println("Before:", p) // Output: {Alice 30}

       updatePerson(&p)
       fmt.Println("After:", p)  // Output: {Alice 31}
   }

   func updatePerson(p *Person) {
       p.age++ // Изменение поля структуры через указатель
   }

В этом примере функция updatePerson изменяет поле структуры Person через указатель на эту структуру.

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

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

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

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

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

1.7K views09:10

Golang | Вопросы собесов

🤔 Какой тип должен реализовывать метод Error() string?

Anonymous Quiz

427 voters1.3K views16:10

Golang | Вопросы собесов

Что будет в Map, если не делать make или short assign ?
Спросят с вероятностью 8%

Карты (maps) необходимо инициализировать перед использованием. Если карта не была инициализирована с помощью функции make или литерала карты, она будет иметь нулевое значение nil. Попытка добавить элементы в такую карту приведет к панике (panic).

Пример с неинициализированной картой

package main

import "fmt"

func main() {
    var myMap map[string]int
    // Карта не инициализирована, её значение - nil
    fmt.Println(myMap) // Output: map[]

    // Попытка добавить элемент в неинициализированную карту
    // Это вызовет панику
    myMap["key"] = 1
}

Этот код приведет к панике с сообщением об ошибке:

panic: assignment to entry in nil map

Инициализация карты

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

1️⃣Использование функции `make`:

      package main

   import "fmt"

   func main() {
       // Инициализация карты с помощью make
       myMap := make(map[string]int)
       myMap["key"] = 1
       fmt.Println(myMap) // Output: map[key:1]
   }

2️⃣Использование литерала карты:

      package main

   import "fmt"

   func main() {
       // Инициализация карты с помощью литерала карты
       myMap := map[string]int{
           "key1": 1,
           "key2": 2,
       }
       fmt.Println(myMap) // Output: map[key1:1 key2:2]
   }

Пример:

package main

import "fmt"

func main() {
    // Инициализация карты с помощью make
    myMap := make(map[string]int)

    // Добавление элементов в карту
    myMap["one"] = 1
    myMap["two"] = 2

    // Вывод карты
    fmt.Println(myMap) // Output: map[one:1 two:2]

    // Доступ к элементу карты
    value := myMap["one"]
    fmt.Println("Value for key 'one':", value) // Output: Value for key 'one': 1

    // Проверка наличия ключа в карте
    if val, exists := myMap["three"]; exists {
        fmt.Println("Key 'three' exists with value:", val)
    } else {
        fmt.Println("Key 'three' does not exist")
    }

    // Удаление элемента из карты
    delete(myMap, "two")
    fmt.Println(myMap) // Output: map[one:1]
}

Если карта не была инициализирована с помощью make или литерала карты, она будет nil. Попытка добавить элементы в такую карту приведет к панике. Чтобы избежать этого, необходимо инициализировать карту перед использованием.

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

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

1.3K views09:10

Golang | Вопросы собесов

📌

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

💬

Спрашивают в 8% собеседований

Встроены мощные инструменты для написания и запуска тестов. Тестирование — важная часть разработки ПО, так как помогает убедиться, что код работает правильно и что изменения не приводят к регрессиям.

Основные компоненты

1️⃣

Создание тестовых файлов:

➕ Тестовые файлы в Go должны оканчиваться на _test.go. Это позволяет инструменту тестирования Go автоматически распознавать их как тесты.
➕ Тестовые функции должны начинаться с Test и принимать один аргумент типа *testing.T.

2️⃣

Написание простого теста:

➕ Рассмотрим простой пример, в котором тестируется функция, добавляющая два числа:

      // main.go
   package main

   func Add(a, b int) int {
       return a + b
   }
   // main_test.go
   package main

   import "testing"

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

3️⃣

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

➕Чтобы запустить тесты, используйте команду go test в терминале. Она автоматически найдет и выполнит все тесты в текущем пакете.

      $ go test

4️⃣

Тестирование с таблицей (table-driven tests):

➕ Table-driven tests — это подход, при котором вы пишете тесты в виде таблицы входных и ожидаемых значений. Это позволяет легко добавлять новые тестовые случаи и улучшает читаемость.

      // main_test.go
   package main

   import "testing"

   func TestAdd(t *testing.T) {
       tests := []struct {
           a, b, expected int
       }{
           {1, 2, 3},
           {0, 0, 0},
           {-1, -1, -2},
           {2, 2, 4},
       }

       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)
           }
       }
   }

🔥

ТОП ВОПРОСОВ С СОБЕСОВ

🔒

База собесов

| 🔒

База тестовых

Please open Telegram to view this post

VIEW IN TELEGRAM

1.5K views09:10

Golang | Вопросы собесов

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

Anonymous Quiz

406 voters1.3K views16:10

Golang | Вопросы собесов

📌

Какое свойство должно быть у ключа в Map ?

💬

Спросят с вероятностью 8%

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

🤔

Типы данных, которые могут быть ключами

1️⃣

Целые числа (int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64):

      var intMap map[int]string
   intMap = make(map[int]string)
   intMap[1] = "one"

2️⃣

Строки (string):

      var stringMap map[string]int
   stringMap = make(map[string]int)
   stringMap["one"] = 1

3️⃣

Булевы значения (bool):

      var boolMap map[bool]string
   boolMap = make(map[bool]string)
   boolMap[true] = "yes"
   boolMap[false] = "no"

4️⃣

Указатели (например, *int, *struct):

      var ptrMap map[*int]string
   ptrMap = make(map[*int]string)
   var a int
   ptrMap[&a] = "pointer to a"

5️⃣

Каналы (chan T):

      var chanMap map[chan int]string
   chanMap = make(map[chan int]string)
   c := make(chan int)
   chanMap[c] = "channel"

6️⃣

Интерфейсы (при условии, что их конкретные значения сравнимы):

      var ifaceMap map[interface{}]string
   ifaceMap = make(map[interface{}]string)
   ifaceMap[1] = "one"
   ifaceMap["key"] = "value"

7️⃣

Структуры (struct), если все их поля сравнимы:

      type Person struct {
       Name string
       Age  int
   }
   var structMap map[Person]string
   structMap = make(map[Person]string)
   structMap[Person{"Alice", 30}] = "person 1"

🤔

Типы данных, которые не могут быть ключами

1️⃣

Срезы (slice):

      // Это вызовет ошибку компиляции
   // var sliceMap map[[]int]string

2️⃣

Карты (map):

      // Это вызовет ошибку компиляции
   // var mapMap map[map[int]string]string

3️⃣

Функции (func):

      // Это вызовет ошибку компиляции
   // var funcMap map[func() int]string

🤔

Пример:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    // Карта с ключами типа int
    intMap := make(map[int]string)
    intMap[1] = "one"
    intMap[2] = "two"
    fmt.Println(intMap) // Output: map[1:one 2:two]

    // Карта с ключами типа string
    stringMap := make(map[string]int)
    stringMap["one"] = 1
    stringMap["two"] = 2
    fmt.Println(stringMap) // Output: map[one:1 two:2]

    // Карта с ключами типа bool
    boolMap := make(map[bool]string)
    boolMap[true] = "yes"
    boolMap[false] = "no"
    fmt.Println(boolMap) // Output: map[false:no true:yes]

    // Карта с ключами типа *int
    a, b := 1, 2
    ptrMap := make(map[*int]string)
    ptrMap[&a] = "pointer to a"
    ptrMap[&b] = "pointer to b"
    fmt.Println(ptrMap) // Output: map[0x...:pointer to a 0x...:pointer to b]

    // Карта с ключами типа struct
    structMap := make(map[Person]string)
    structMap[Person{"Alice", 30}] = "person 1"
    structMap[Person{"Bob", 25}] = "person 2"
    fmt.Println(structMap) // Output: map[{Alice 30}:person 1 {Bob 25}:person 2]
}

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

🔥

ТОП ВОПРОСОВ С СОБЕСОВ

🔒

База собесов

| 🔒

База тестовых

Please open Telegram to view this post

VIEW IN TELEGRAM

1.7K viewsedited 09:10

Golang | Вопросы собесов

🤔 Какой метод используется для декодирования JSON данных в Go?

Anonymous Quiz

446 voters1.6K views16:10

Golang | Вопросы собесов

📌

Что такое unit тесты ?

💬

Спрашивают в 8% собеседований

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

🤔

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

1️⃣

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

2️⃣

Документация кода:
Хорошо написанные юнит-тесты служат живой документацией для кода, показывая, как именно должны работать функции и методы.

3️⃣

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

4️⃣

Повышение уверенности в коде:
Юнит-тесты обеспечивают уверенность в том, что код работает правильно, что особенно важно при добавлении новых функций или исправлении ошибок.

🤔

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

1️⃣

Создание тестовых файлов:
➖Тестовые файлы в Go должны оканчиваться на _test.go.
➖Тестовые функции должны начинаться с Test и принимать один аргумент типа *testing.T.

2️⃣

Пример написания юнит-теста:
Рассмотрим пример, где у нас есть функция, которая складывает два числа, и мы пишем для неё юнит-тест.

      // main.go
   package main

   func Add(a, b int) int {
       return a + b
   }
      // main_test.go
   package main

   import "testing"

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

3️⃣

Запуск юнит-тестов:
Чтобы запустить юнит-тесты, используйте команду go test в терминале.

      $ go test

4️⃣

Тестирование с таблицей (table-driven tests):
Table-driven tests позволяют легко добавлять новые тестовые случаи и улучшать читаемость тестов.

      package main

   import "testing"

   func TestAdd(t *testing.T) {
       tests := []struct {
           a, b, expected int
       }{
           {1, 2, 3},
           {0, 0, 0},
           {-1, -1, -2},
           {2, 2, 4},
       }

       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)
           }
       }
   }

Лучшие практики

1️⃣

Соблюдайте атомарность:
Каждый юнит-тест должен проверять только одну конкретную функцию или метод и проверять один аспект её поведения.

2️⃣

Используйте понятные названия:
Имена тестовых функций должны быть понятными и отражать их цель. Например, TestAdd для тестирования функции Add.

3️⃣

Проверяйте крайние случаи:
Убедитесь, что ваши тесты проверяют крайние случаи и потенциальные ошибки, такие как нулевые значения, отрицательные числа и переполнения.

4️⃣

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

5️⃣

Используйте mocking, если необходимо:
При тестировании функций, которые зависят от внешних ресурсов (таких как базы данных или API), используйте мокирование (mocking) для изоляции тестов.

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

🔥

ТОП ВОПРОСОВ С СОБЕСОВ

🔒

База собесов

| 🔒

База тестовых

Please open Telegram to view this post

VIEW IN TELEGRAM

1.7K views09:10

About

Blog

Apps

Platform