Golang | Вопросы собесов
4.33K subscribers
26 photos
694 links
Download Telegram
В чем отличие длины и ёмкости у слайса ?
Спросят с вероятностью 8%

Слайсы обладают двумя важными характеристиками: длиной (length) и емкостью (capacity). Понимание этих характеристик помогает эффективно использовать слайсы и управлять их памятью. Рассмотрим, что такое длина и емкость слайса, в чем их различия, и как они влияют на работу слайсов.

Длина (Lenght)

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

import "fmt"

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


Емкость (Capacity)

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

import "fmt"

func main() {
slice := make([]int, 3, 5)
fmt.Println("Length:", len(slice)) // Length: 3
fmt.Println("Capacity:", cap(slice)) // Capacity: 5
}


Различия:

1️⃣Длина:
Количество элементов, доступных в данный момент.
Определяется с помощью функции len.
При обращении к элементам с индексом от 0 до len(slice)-1 гарантируется безопасность.

2️⃣Емкость:
Максимальное количество элементов, которые могут быть добавлены в слайс без выделения новой памяти.
Определяется с помощью функции cap.
Может быть больше или равна длине.

Взаимосвязь длины и емкости

При создании слайса можно задать его длину и емкость. Если емкость не указана, она будет равна длине.
package main

import "fmt"

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

// Добавление элементов в слайс
slice = append(slice, 4, 5)
fmt.Println("Length after append:", len(slice)) // Length after append: 5
fmt.Println("Capacity after append:", cap(slice)) // Capacity after append: 5

// Добавление еще одного элемента приведет к увеличению емкости
slice = append(slice, 6)
fmt.Println("Length after another append:", len(slice)) // Length after another append: 6
fmt.Println("Capacity after another append:", cap(slice)) // Capacity after another append: 10 (емкость удвоилась)
}


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

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

🔐 База собесов | 🔐 База тестовых
📌 Как устроены контексты в Go?

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

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

Ключевые особенности:

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

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

3️⃣ Сроки выполнения: Контекст может иметь установленный таймаут или дедлайн, после достижения которого он автоматически отменяется.

4️⃣ Значения: Контексты могут нести значения — пары ключ-значение, которые можно устанавливать и получать. Эти значения обычно используются для передачи данных, специфичных для запроса, таких как идентификаторы сессий или токены авторизации.

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

Есть несколько способов создания контекста, включая базовые функции из пакета context:

context.Background(): Возвращает пустой контекст, который никогда не отменяется. Обычно используется в основной функции и при инициализации.

context.TODO(): Используется для указания, что должен быть предоставлен подходящий контекст. Обычно применяется в разработке и при рефакторинге.

context.WithCancel(parent Context) (ctx Context, cancel CancelFunc): Создает новый контекст с возможностью отмены.

context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc): Создает контекст, который автоматически отменяется в указанный deadline.

context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc): Аналогичен WithDeadline, но устанавливает время жизни контекста на основе заданного таймаута.

🤔 Пример:
func operation1(ctx context.Context) {
select {
case <-time.After(5 * time.Second):
fmt.Println("operation1 completed")
case <-ctx.Done():
fmt.Println("operation1 cancelled")
}
}

func main() {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

go operation1(ctx)

// Дожидаемся завершения или отмены операции
<-ctx.Done()
if err := ctx.Err(); err != nil {
fmt.Println("main:", err)
}
}


В этом примере функция operation1 прерывается, если контекст отменяется до истечения времени ожидания в 5 секунд.

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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔 Как в Go реализуется шаблон «производитель-потребитель»?
Anonymous Quiz
10%
через map
7%
через mutex
82%
через канал
1%
через slice
📌 Зачем нужны транзакции?

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

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

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

Они базируются на четырёх основных принципах, известных как свойства ACID:

1️⃣ Атомарность (Atomicity): Гарантирует, что все операции в рамках одной транзакции либо полностью выполнены, либо не выполнены вовсе. Если какая-либо часть транзакции не может быть завершена, вся транзакция откатывается (возвращается к исходному состоянию).

2️⃣ Согласованность (Consistency): Обеспечивает, что транзакция переводит базу данных из одного согласованного состояния в другое. При этом сохраняются все правила и ограничения базы данных.

3️⃣ Изолированность (Isolation): Позволяет транзакциям выполняться независимо друг от друга, изолируя их промежуточные состояния и управляя видимостью изменений данных других транзакций.

4️⃣ Долговечность (Durability): Гарантирует, что результаты успешно завершённой транзакции будут устойчивы к системным сбоям, сохраняясь в постоянной памяти.

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

1️⃣ Целостность данных: Транзакции обеспечивают целостность данных, автоматически управляя ошибками и несогласованностями, которые могут возникнуть в процессе выполнения операций. Например, при переводе средств между банковскими счетами транзакция гарантирует, что если с одного счёта деньги были сняты, то они будут зачислены на другой счёт.

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

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

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

🤔 Пример

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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔 Какой оператор используется для безопасного извлечения значений из map в Go?
Anonymous Quiz
24%
get
18%
value
49%
ok
9%
exist
📌 Какие индексы есть?

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

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

1️⃣ B-Tree и B+Tree Индексы

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

2️⃣ Хеш-индексы

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

3️⃣ Инвертированные индексы

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

4️⃣ Пространственные (Spatial) индексы

Используются для данных, которые имеют геометрическое представление, такие как точки, линии и полигоны. Они оптимизированы для поиска данных в пространственных запросах, например, при поиске всех точек в определённом радиусе. Распространённые примеры включают R-tree индексы.

5️⃣ Полноценные текстовые индексы

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

6️⃣ Bitmap индексы

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

🤔 Применение:

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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔 Как в Go создается новый пустой slice заданной длины и емкости?
Anonymous Quiz
87%
make(slice, len, cap)
7%
new(slice, len, cap)
5%
slice(len, cap)
1%
create(slice, len, cap)
Как правильно объявлять Маппу ?
Спросят с вероятностью 8%

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

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

Это коллекция, где каждый элемент имеет уникальный ключ, по которому можно получить связанное с ним значение. Они имеют тип map[KeyType]ValueType, где KeyType — это тип ключей, а ValueType — тип значений.

Объявление и инициализация мапп

1⃣Используя make:
        var myMap = make(map[string]int)


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

2⃣Используя литерал маппы:
        myMap := map[string]int{
"apple": 5,
"orange": 10,
}


Этот способ позволяет одновременно объявить и инициализировать маппу с заданными значениями.

Операции с маппами

1⃣Добавление и обновление элементов:
        myMap["banana"] = 3  // добавляет элемент с ключом "banana" и значением 3
myMap["apple"] = 7 // обновляет значение для ключа "apple" на 7


2⃣Чтение значений по ключу:
        appleCount := myMap["apple"]
fmt.Println(appleCount) // выводит 7


3⃣Проверка наличия ключа:
        value, exists := myMap["banana"]
if exists {
fmt.Println("banana count:", value)
} else {
fmt.Println("banana not found")
}


4⃣Удаление элемента:
        delete(myMap, "orange")  // удаляет элемент с ключом "orange"


Рассмотрим пример функции, которая подсчитывает количество слов в строке и возвращает маппу с результатами:
package main
import (
"fmt"
"strings"
)

func wordCount(s string) map[string]int {
words := strings.Fields(s)
countMap := make(map[string]int)
for _, word := range words {
countMap[word]++
}
return countMap
}

func main() {
text := "hello world hello"
result := wordCount(text)
fmt.Println(result) // выводит: map[hello:2 world:1]
}


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

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

🔐 База собесов | 🔐 База тестовых
🤔 Как в Go проверить, является ли канал закрытым?
Anonymous Quiz
3%
if ch.closed
8%
if ch == nil
74%
if _, ok := <-ch; !ok
15%
if ch.closed()
Какие ключи могут быть в МАПе ?
Спросят с вероятностью 8%

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

Типы, которые можно использовать в качестве ключей

Они должны быть сравнимыми, поскольку Go использует оператор == для проверки равенства ключей. Это необходимо для корректной работы хеш-таблицы. В качестве ключей можно использовать следующие типы:

1️⃣Базовые типы:
bool
int
, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64, uintptr
float32, float64
complex64, complex128
string

2️⃣Указатели:
Указатели на любые типы (*T).

3️⃣Интерфейсы:
Интерфейсы, при условии, что конкретные значения, которые они содержат, также поддерживают сравнение (==).

4️⃣Структуры:
Структуры, если все их поля поддерживают сравнение (==).

Примеры допустимых ключей:

Использование строковых
package main

import (
"fmt"
)

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


Использование целочисленных
package main

import (
"fmt"
)

func main() {
myMap := map[int]string{
1: "one",
2: "two",
}
fmt.Println(myMap)
}


Использование указателей
package main

import (
"fmt"
)

func main() {
a, b := 1, 2
myMap := map[*int]string{
&a: "one",
&b: "two",
}
fmt.Println(myMap)
}


Использование структур
package main

import (
"fmt"
)

type Point struct {
X, Y int
}

func main() {
myMap := map[Point]string{
{X: 1, Y: 2}: "Point A",
{X: 3, Y: 4}: "Point B",
}
fmt.Println(myMap)
}


Типы, которые нельзя использовать в качестве ключей, потому что они не поддерживают оператор ==. К ним относятся:

Слайсы ([]T).
Карты (map[K]V).
Функции (func).

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

Пример недопустимого ключа (слайс)
package main

func main() {
myMap := map[[]int]string{
[]int{1, 2, 3}: "slice",
}
// Это вызовет ошибку компиляции: "invalid map key type []int"
}


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

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

🔐 База собесов | 🔐 База тестовых
🤔 Как в Go создается таймер с определенным интервалом?
Anonymous Quiz
32%
time.NewTimer(duration)
44%
time.NewTicker(duration)
20%
time.Sleep(duration)
4%
time.AfterFunc(duration)
Как быстро можно что-то найти, если искать по индексу в слайсе и в Маппе ?
Спросят с вероятностью 8%

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

Поиск по индексу в слайсе

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

Пример доступа к элементу по индексу:
package main
import "fmt"

func main() {
slice := []int{10, 20, 30, 40, 50}
fmt.Println(slice[2]) // выводит 30
}


Поиск по ключу в маппе

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

Пример доступа к значению по ключу:
package main
import "fmt"

func main() {
myMap := map[string]int{
"apple": 5,
"banana": 3,
"orange": 10,
}
fmt.Println(myMap["banana"]) // выводит 3
}


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


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

Когда что использовать

Слайс: Если вам нужно хранить упорядоченные данные и иметь быстрый доступ по индексу.
Маппа: Если вам нужно хранить ассоциативные данные (пары ключ-значение) и быстро находить значения по уникальным ключам.

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

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

🔐 База собесов | 🔐 База тестовых
🤔 Как в Go определяются анонимные функции?
Anonymous Quiz
3%
anonymous func() {}
92%
func() {}
3%
lambda() {}
2%
def() {}
Как объявлять слайс ?
Спросят с вероятностью 8%

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

Объявление

Можно объявить без указания размера, так как он динамически изменяется:
var mySlice []int


Здесь mySlice — это слайс целых чисел.

Инициализация

После объявления его необходимо инициализировать. Есть несколько способов сделать это:

Использование литералов слайсов

Позволяет сразу задать начальные значения:
mySlice := []int{1, 2, 3, 4, 5}


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

Позволяет создать слайс определенного размера и емкости:
mySlice := make([]int, 5) // слайс длиной 5, заполненный нулями


Можно также указать емкость слайса (максимальное количество элементов, которое слайс может содержать без выделения дополнительной памяти):
mySlice := make([]int, 5, 10) // слайс длиной 5 и емкостью 10


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

Можно создатьуказав, подмножество элементов массива:
arr := [5]int{1, 2, 3, 4, 5}
mySlice := arr[1:4] // слайс содержит элементы с индексами 1, 2, 3


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

Добавление элементов


Для этого используется функция append:
mySlice := []int{1, 2, 3}
mySlice = append(mySlice, 4, 5) // добавляем элементы 4 и 5 в конец слайса


Доступ к элементам

Осуществляется с помощью индексов:
fmt.Println(mySlice[0]) // первый элемент
mySlice[1] = 20 // изменение значения второго элемента


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

Для этого используется цикл for с диапазоном range:
for i, v := range mySlice {
fmt.Printf("Index: %d, Value: %d\n", i, v)
}


Извлечение подмножества(slicing)

Можно создавать новые слайсы на основе существующих:
subSlice := mySlice[1:3] // слайс содержит элементы с индексами 1 и 2


Пример:
package main

import (
"fmt"
)

func main() {
// Инициализация слайса с помощью литерала
mySlice := []int{1, 2, 3}

// Добавление элементов
mySlice = append(mySlice, 4, 5)

// Доступ к элементам и их изменение
fmt.Println("First element:", mySlice[0])
mySlice[1] = 20
fmt.Println("Modified slice:", mySlice)

// Итерация по слайсу
for i, v := range mySlice {
fmt.Printf("Index: %d, Value: %d\n", i, v)
}

// Создание подмножества слайса
subSlice := mySlice[1:4]
fmt.Println("Sub-slice:", subSlice)
}


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

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

🔐 База собесов | 🔐 База тестовых
🤔 Как в Go происходит перехват паники (panic)?
Anonymous Quiz
10%
catch
5%
handle
83%
recover
3%
rescue
Какие функции у map ?
Спросят с вероятностью 8%

Маппы (карты) предоставляют несколько встроенных возможностей для работы с ними. Рассмотрим основные функции и операции, которые можно выполнять.

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

1⃣Объявление и инициализация маппы
Использование make:
            var myMap = make(map[string]int)

Создает пустую маппу с ключами типа string и значениями типа int.

Использование литерала маппы:
            myMap := map[string]int{
"apple": 5,
"banana": 3,
}

Создает и инициализирует маппу с ключами "apple" и "banana".

2⃣Добавление и обновление элементов
        myMap["orange"] = 10  // добавляет элемент с ключом "orange" и значением 10
myMap["apple"] = 7 // обновляет значение для ключа "apple" на 7


3⃣Чтение значений по ключу
        appleCount := myMap["apple"]
fmt.Println(appleCount) // выводит 7


4⃣Проверка наличия ключа
        value, exists := myMap["banana"]
if exists {
fmt.Println("banana count:", value)
} else {
fmt.Println("banana not found")
}


5⃣Удаление элемента
        delete(myMap, "orange")  // удаляет элемент с ключом "orange"


Рассмотрим пример, где используются основные операции с маппой:
package main

import "fmt"

func main() {
// Объявление и инициализация маппы
myMap := map[string]int{
"apple": 5,
"banana": 3,
}

// Добавление и обновление элементов
myMap["orange"] = 10
myMap["apple"] = 7

// Чтение значений по ключу
fmt.Println("apple:", myMap["apple"]) // выводит 7
fmt.Println("orange:", myMap["orange"]) // выводит 10

// Проверка наличия ключа
value, exists := myMap["banana"]
if exists {
fmt.Println("banana count:", value) // выводит 3
} else {
fmt.Println("banana not found")
}

// Удаление элемента
delete(myMap, "banana")
fmt.Println("banana after deletion:", myMap["banana"]) // выводит 0, т.к. элемента нет
}


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

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

🔐 База собесов | 🔐 База тестовых
🤔 Как в Go выполняется преобразование типа interface{} в конкретный тип?
Anonymous Quiz
15%
convert
25%
cast
17%
type convert
43%
type assertion
Какая средняя сложность поиска по слайсу и по map ?
Спросят с вероятностью 8%

Средняя сложность поиска в слайсе и карте (map) различается значительно и зависит от того, как организованы данные в каждой структуре.

Поиск в слайсе

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

Линейный поиск

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

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

Пример линейного поиска:
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(1) (константное время) в среднем случае.

Пример поиска в карте:
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(n), так как необходимо последовательно проверять каждый элемент. Это подходит для небольших коллекций данных или когда важно сохранить порядок элементов.
Карта: Поиск элемента по ключу выполняется за константное время O(1) в среднем, что делает карты идеальными для случаев, когда требуется быстрый доступ к данным по ключу, независимо от размера коллекции.

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

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

🔐 База собесов | 🔐 База тестовых
Что такое тип rune Зачем их использовать ?
Спросят с вероятностью 8%

Тип rune представляет собой alias для типа int32, предназначенного для хранения Unicode кодовых точек.

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

1️⃣Работа с символами Unicode:
Строки (string) являются последовательностями байтов, а не символов. Это означает, что один символ может занимать больше одного байта, особенно если это символ из расширенного набора Unicode.
Тип используется для работы с символами, представляемыми одной кодовой точкой Unicode. Это упрощает манипуляции с символами, так как каждая rune — это отдельный символ, независимо от его длины в байтах.

2️⃣Повышение читабельности кода:
Использование типа rune делает код более понятным и само-документируемым. Когда в коде виден тип rune, это сразу указывает на то, что переменная предназначена для хранения одного символа, а не целого числа.

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

1️⃣Создание и инициализация:
      var r rune = '世'
fmt.Println(r) // Output: 19990

Здесь символ '世' представлен в виде Unicode кодовой точки и сохраняется как rune.

2️⃣Итерация по строке:
      s := "Привет, 世界"
for _, r := range s {
fmt.Printf("%c ", r)
}
// Output: П р и в е т , 世 界

В данном примере используется цикл for range, чтобы итерироваться по строке и извлекать каждый символ в виде rune.

3️⃣Преобразование между `string` ито такое
      s := "Go"
runes := []rune(s)
fmt.Println(runes) // Output: [71 111]

s2 := string(runes)
fmt.Println(s2) // Output: Go

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

rune — это тип в Go для представления одного символа Unicode, помогающий проще работать с символами и делать код более понятным. Это важно для правильной обработки текста, содержащего символы вне ASCII

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

🔐 База собесов | 🔐 База тестовых
🤔 Какой интерфейс в Go используется для записи данных в буфер?
Anonymous Quiz
46%
io.Writer
8%
io.Reader
42%
bufio.Buffer
3%
fmt.Writer