💬В чем разница между поверхностным и глубоким копированием в Go?

📌Поверхностное копирование (shallow copy) означает создание новой переменной или структуры, которая ссылается на те же данные в памяти, что и исходная переменная/структура.

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

original := []int{1, 2, 3}
copied := original
copied[0] = 99
fmt.Println(original) // [99 2 3]

📌Глубокое копирование (deep copy) подразумевает создание новой переменной или структуры, которая имеет собственные, полностью независимые копии данных, содержащихся в исходной переменной или структуре.

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

import "github.com/mohae/deepcopy"

original := []int{1, 2, 3}
copied := deepcopy.Copy(original)
copied[0] = 99
fmt.Println(original) // [1 2 3]

💬Какие операторы есть в языке Go? Назовите основные.

📌Арифметические:
• + : сложение
• - : вычитание
• * : умножение
• / : деление
• % : остаток от деления
• ++ : инкремент
• -- : декремент

📌Сравнительные:
• == : равно
• != : не равно
• < : меньше
• <= : меньше или равно
• > : больше
• >= : больше или равно

📌Логические:
• && : логическое И (AND)
• || : логическое ИЛИ (OR)
• ! : логическое НЕ (NOT)

📌Битовые:
• & : битовое И (AND)
• | : битовое ИЛИ (OR)
• ^ : битовое исключающее ИЛИ (XOR)
• &^ : битовая маска сброса (AND NOT)
• << : левый сдвиг
• >> : правый сдвиг

📌Операторы:
• = : присваивание
• +=, -=, *=, /=, %= : присваивание с операцией
• &=, |=, ^=, <<=, >>=, &^= : битовое присваивание с операцией

📌Прочие:
• & : оператор получения адреса
• * : оператор разыменования указателя
• <- : оператор канала (используется для отправки и получения данных через каналы)
• := : присваивание, используемое для объявления и инициализации переменной

💬Что из себя представляют Go workspaces?

🔸В версии Go 1.18 был введен новый режим workspace, который позволяет работать с несколькими модулями одновременно без необходимости редактирования go.mod файлов для каждого модуля.

🔸В каждом workspace, модули рассматриваются как основные модули при разрешении зависимостей. До введения этой функции, для добавления функции в один модуль и ее использования в другом модуле, требовалось либо публиковать изменения первого модуля, либо редактировать файл go.mod зависимого модуля с директивой replace для локальных, неопубликованных изменений модуля.

🔸Режим workspace в Go 1.18 решает ряд проблем, в частности, устраняет необходимость полагаться на локальные замены модулей. Вместо этого, все зависимости контролируются с использованием файла go.work в корневой директории вашего workspace.

🔸Файл go.work содержит директивы use и replace, которые переопределяют индивидуальные файлы go.mod, устраняя необходимость редактирования каждого файла go.mod вручную.

🔸Для создания workspace используется команда go work init с перечислением директорий модулей в качестве аргументов, разделенных пробелами. Workspace не обязан содержать модули, с которыми вы работаете. Команда init создает файл go.work, который перечисляет модули в workspace. Если вы запустите go work init без аргументов, команда создаст пустой workspace.

📌Основные преимущества:

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

2. Управление зависимостями: с помощью workspaces можно легко управлять зависимостями между модулями. Это упрощает обновление, замену или удаление зависимостей в ваших проектах.

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

4. Совместимость с Go модулями: workspaces расширяют возможности Go модулей, добавляя поддержку для работы с несколькими модулями в рамках одного workspace, что делает управление модулями более гибким и удобным.

5. Улучшенный рабочий процесс: Go workspaces предлагают улучшенный рабочий процесс для разработчиков, делая процесс сборки и тестирования более простым и эффективным.

6. Простота и переносимость: создание workspace не требует дополнительных инструментов. Это также обеспечивает переносимость между различными окружениями разработки и командами.

👉 Подробнее

💬Для чего в программах на Go используются функции?

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

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

💬Как в Go реализована композиция (агрегация)? Чем она отличается от наследования?

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

📌В нашем примере:

• Определен базовый тип Engine с двумя полями (Power и Type) и методом Start.
• Определен тип Car, в который встраивается Engine.
• В функции main создается экземпляр типа Car, и через этот экземпляр вызывается метод Start встроенного типа Engine, а также обращаются к полям встроенного типа Engine.

📌Таким образом, композиция в Go позволяет объединять простые типы в более сложные структуры, сохраняя при этом простоту и ясность кода.

🧑‍💻 Статьи для IT: как объяснять и распространять значимые идеи

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

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

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

👉Материалы регулярно дополняются, обновляются и корректируются. А еще мы отвечаем на все учебные вопросы в комментариях курса.

💬Что будет при чтении/записи из закрытого и неинициализированного канала?

📌Чтение из закрытого канала: когда мы пытаемся читать из закрытого канала, происходит следующее:

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

ch := make(chan int)
close(ch)
value, ok := <-ch
fmt.Println(value, ok) // 0 false

📌Запись в закрытый канал: попытка записать в закрытый канал вызовет панику. Это означает, что запись в закрытый канал является недопустимой операцией.

ch := make(chan int)
close(ch)
ch <- 42 // panic: send on closed channel

📌Чтение из неинициализированного (nil) канала будет заблокировано, как и запись в неициализированный (nil) канал.

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

💬Что такое паника (panic) в Go? Какие операции автоматически возвращают панику и останавливают программу?

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

🔸Доступ к индексу за пределами массива/среза: попытка доступа к элементу массива или среза по индексу за пределами его размера приведет к панике.

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

🔸Type assertion:
неправильное приведение типа с помощью type assertion может вызвать панику.

var i interface{} = "hello"
fmt.Println(i.(int)) // panic: interface conversion: interface {} is string, not int

🔸Закрытие закрытого канала:
попытка закрыть уже закрытый канал вызовет панику.

ch := make(chan int)
close(ch)
close(ch) // panic: close of closed channel

📌Обработка паники

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

func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered from panic:", r)
}
}()
causePanic()
fmt.Println("This line will not be reached")
}

func causePanic() {
panic("This is a panic")
}

Если функция causePanic вызывает панику, функция defer будет вызвана перед завершением программы. Функция recover затем используется для захвата значения паники и предотвращения завершения программы.

👉 Подробнее

💬В чем разница между context.Background() и context.TODO()?

📌Разница между context.Background() и context.TODO() в основном заключается в их семантическом использовании.

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

💬Что из себя представляет стабы (stubs) и моки (mock) в контексте тестирования в Go?

📌Стабы (stubs) и моки (mocks) являются техниками, используемыми для изоляции тестируемого кода от внешних зависимостей во время тестирования в Go.

🔸Стабы (stubs) — это фейковые объекты, которые предоставляют предопределенные ответы на вызовы методов во время тестирования.

package main

import "fmt"

type DatabaseStub struct{}

func (db *DatabaseStub) GetUserName(id int) string {
return "Alice"
}

type Database interface {
GetUserName(id int) string
}

func PrintUserName(db Database, id int) {
name := db.GetUserName(id)
fmt.Println(name)
}

func main() {
dbStub := &DatabaseStub{}
PrintUserName(dbStub, 1)
}

🔸Моки (mocks) — это более продвинутые фейковые объекты, которые, кроме предоставления предопределенных ответов, также проверяют, как и когда методы были вызваны в тестах, что помогает в проверке взаимодействия между объектами.

package main

import (
"github.com/stretchr/testify/mock"
"testing"
)

type DatabaseMock struct {
mock.Mock
}

func (db *DatabaseMock) GetUserName(id int) string {
args := db.Called(id)
return args.String(0)
}

func TestPrintUserName(t *testing.T) {
dbMock := new(DatabaseMock)
dbMock.On("GetUserName", 1).Return("Alice")

name := dbMock.GetUserName(1)

dbMock.AssertExpectations(t)
}

📌В первом примере создается стаб DatabaseStub, который имеет метод GetUserName. Во втором примере создается мок DatabaseMock с использованием библиотеки testify, который проверяет, был ли метод GetUserName вызван с правильным аргументом.

💬Как переобъявить переменные с помощью коротких объявлений?

📌В одной области видимости нельзя переобъявлять переменные, но это можно делать в объявлении нескольких переменных (multi-variable declarations), среди которых хотя бы одна — новая. Переобъявляемые переменные должны располагаться в том же блоке, иначе получится затенённая переменная.

📌Неправильно:

func main() {
one := 0
one := 1 // ошибка компиляции
}

📌Правильно:

func main() {
one := 0
one, two := 1,2

one,two = two,one
}

💬В чем разница между пакетами и модулями Go?

📌В Go, пакет — это коллекция исходных файлов .go в одной директории и с одинаковой директивой package, в то время как модуль — это дерево пакетов. Имя модуля задаётся в go.mod.

📌Файлы для одного пакета должны находиться в одной директории. Полное имя для пакета строится из имени модуля и пути к директории с файлами.

◆ Например, в go.mod указано module example.org/mylib, тогда все пакеты из модуля example.org/mylib должны быть в дочерних директориях относительно go.mod, и путь к директории определяет имя пакета.

◆ Например, в дереве исходников нашей библиотеки есть файлы в директоории ./cmd/root. Тогда эти файлы должны быть либо с директивой package root, либо package root_test. И полное имя пакета для этих файлов будет либо example.org/mylib/cmd/root, либо example.org/mylib/cmd/root_test (тесты для пакета example.org/mylib/cmd/root).