Библиотека Go для собеса | вопросы с собеседований

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

🐘🔮 Иллюзия согласованности в PostgreSQL: как избежать неприятных сюрпризов Несмотря на то, что PostgreSQL обеспечивает строгую согласованность данных благодаря использованию многоверсионного параллельного контроля (MVCC), порядок выполнения транзакций может быть неожиданным для клиента. Это может привести к ситуации, когда записи появляются в неправильном порядке. Рассказываем, как и почему это происходит, и что делать для минимизации подобных проблем. Читать статью

💬 Как эффективно удалять смежные элементы среза, сохраняя порядок элементов? Предположим: 1. Задействованный срез обозначен как s, и его тип — []E, где E — тип элементов среза. 2. Мы хотим удалить элементы в s[from:to], где from <= to. 📌 Способы удаления элементов: 1️⃣

s = s[:from + copy(s[from:], s[to:])]

2️⃣

s = append(s[:from], s[to:]...)

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

import "slices"
s = slices.Delete(s, from, to)

Если используется Go toolchain 1.21, то после вызова функции slices.Delete мы должны самостоятельно очистить освобожденные элементы. Начиная с Go 1.22, функция slices.Delete автоматически очищает освобожденные элементы.

💬 Как эффективно удалять смежные элементы среза, сохраняя порядок элементов? Предположим: 1. Задействованный срез обозначен как s, и его тип — []E, где E — тип элементов среза. 2. Мы хотим удалить элементы в s[from:to], где from <= to. 📌 Способы удаления элементов: 1️⃣

s = s[:from + copy(s[from:], s[to:])]

2️⃣ к эффективно удалять смежные элементы сре 3️⃣ С использованием пакета slices: менты среза, сохраняя порядок элементов? Предположим: 1 Если используется Go toolchain 1.21, то после вызова функции slices.Delete мы должны самостоятельно очистить освобожденные элементы. Начиная с Go 1.22, функция slices.Delete автоматически очищает освобожденные элементы.

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

💬 Какие типы оператора defer существуют в Go? 📌 До Go 1.13: heap-allocated defer До версии Go 1.13 все объекты defer выделялись в куче. Это могло приводить к снижению производительности из-за затрат на выделение памяти в куче. 📌 Go 1.13: stack-allocated defer С версии Go 1.13 была введена возможность выделения объектов defer в стеке. Это позволило улучшить производительность за счет уменьшения затрат на выделение памяти. 📌 Go 1.13+: open-coded defer Также с версии Go 1.13 была введена оптимизация для встраивания defer в конец функции и перед каждым оператором return. Это значительно улучшило производительность, но применимо только в ограниченных кейсах, например, когда количество defer-операторов невелико (не более 8) и нет динамических конструкций, таких как циклы. 📌 Go 1.22: heap-allocated defer в циклах В Go 1.22, если defer используется внутри цикла, он по-прежнему выделяется в куче, поскольку количество объектов defer может динамически меняться во время выполнения. 👉 Подробнее

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

💬 Назовите основные функции и механизмы, которые могут остановить или приостановить выполнение текущей горутины в Go. 1. time.Sleep(d time.Duration): приостанавливает горутину на указанный период времени. 2. runtime.Gosched(): уступает выполнение другим горутинам, временно приостанавливая текущую. 3. runtime.Goexit(): немедленно завершает текущую горутину, выполняя все отложенные вызовы. 4. Блокировка в канале: горутина приостанавливается, ожидая отправки или получения данных через канал. 5. sync.Mutex: горутина блокируется при вызове Lock(), ожидая освобождения мьютекса. 6. context.Context: приостанавливает горутину, слушающую канал Done(), когда контекст отменяется.

💬 Как создать байтовый срез на Go, не обнуляя его байтовые элементы? До версии Go 1.21 этого добиться было невозможно, даже небезопасными способами. Начиная с Go 1.21, реализация strings.Builder.Grow вызывает внутреннюю функцию bytealg.MakeNoZero вместо встроенной функции make, которую вызывала старая реализация. В большинстве случаев встроенная функция make обнуляет элементы результирующего среза, поэтому она часто сравнительно медленнее. С реализацией версии 1.21+ у нас появилась возможность создавать байтовые срезы без инициализации их элементов нулем (хотя для достижения этой функциональности требуется использование функций unsafe)

import (
 "strings"
 "unsafe"
)

func MakeDirtyByteSlice(n int) []byte {
 var b strings.Builder
 b.Grow(n)
 var p = unsafe.StringData(b.String())
 return unsafe.Slice(p, n)
}

💬 Назовите основные способы создания среза в Go. Предположим, что тип нового создаваемого среза — это S, а s0 — это нулевое значение литерала типа S. 1. Использование составных литералов:

// или 
var aSlice = S{Len - 1: s0} // длина и емкость равны Len (константа) 
  

Емкость результирующего среза не всегда выравнивается по размеру класса памяти. 2. Использование встроенной функции make:

// или 
var aSlice = make(S, initialLength) // емкость == initialLength 
  

Емкость результирующего среза не всегда выравнивается по размеру класса памяти. 3. Использование встроенных функций append + make):

// или 
var aSlice = append(S(nil), make(S, initialLength)...) 
// или 
var aSlice = append(S{}, make(S, initialLength, capacity)...) 
// или 
var aSlice = append(S(nil), make(S, initialLength, capacity)...) 
  

С официальным Go-инструментарием емкость результирующего среза выравнивается по размеру класса памяти.

🧑‍💻 Статьи для IT: как объяснять и распространять значимые идеи Напоминаем, что у нас есть бесплатный курс для всех, кто хочет научиться интересно писать — о программировании и в целом. Что: семь модулей, посвященных написанию, редактированию, иллюстрированию и распространению публикаций. Для кого: для авторов, копирайтеров и просто программистов, которые хотят научиться интересно рассказывать о своих проектах. 👉Материалы регулярно дополняются, обновляются и корректируются. А еще мы отвечаем на все учебные вопросы в комментариях курса.

💬 Перечислите все способы клонирования срезов на Go? 1️⃣ Использование make и copy

cloned := make(SliceType, len(aSlice))
copy(cloned, aSlice)

2️⃣ Более развернутая форма 1 способа

var cloned SliceType
if aSlice != nil {
    cloned = make(SliceType, len(aSlice))
    copy(cloned, aSlice)
}

3️⃣ Использование make и append

append(make(SliceType, 0, len(aSlice)), aSlice...)

4️⃣ Использование append

append(SliceType(nil), aSlice...) // Вариант 1
// или
append(SliceType{}, aSlice...) // Вариант 2

5️⃣ Другой способ использования append

append(aSlice[:0:0], aSlice...)

6️⃣ Использование slices.Clone (Go 1.21+)

import "slices"
slices.Clone(aSlice)

💬 Как получить адреса байтов строки в Go? 1. Использование unsafe до версии Go 1.22. До версии Go 1.22 получение адресов байтов строки было возможно только через пакет unsafe. Это небезопасный способ, но он работает:

package main

import (
    "unsafe"
)

func main() {
    str := "Hello, Go!"
    addr := unsafe.StringData(str)
    println(addr, string(*addr)) 
}

2. Использование reflect с версии Go 1.23 Начиная с версии Go 1.23, метод reflect.Value.UnsafePointer позволяет получить адреса байтов строки:

package main

import (
    "reflect"
)

func main() {
    str := "Hello, Go!"
    addr := (*byte)(reflect.ValueOf(str).UnsafePointer())
    println(addr, string(*addr)) 
}

3. Конвертация строки в срез байтов. С версии Go 1.22 была добавлена оптимизация, которая позволяет конвертировать строки в срезы байтов без копирования памяти, если байты не будут изменяться. Это позволяет безопасно получать адреса байтов строки:

package main

func main() {
    str := "Hello, Go!"
    byteSlice := []byte(str)
    addr := &byteSlice[0]
    println(addr, string(*addr)) 
}

✍️ «Библиотека программиста» находится в поиске автора на написание книжных рецензий Кто нужен? ● Энтузиасты (джуны и выше), которые которые разбираются в IT ● Любители книг, которые хотели бы получать деньги за чтение и написание рецензий ● Работаем с самозанятыми (компенсируем налог), ИП Мы предлагаем частичную занятость и полностью удаленный формат работы — можно совмещать с основной и находиться в любом месте🌴 ✉️ Станьте частью нашей команды — присылайте резюме и примеры работ hello@proglib.io

💵⚡️ДАРИМ 40 000₽ ЗА ВИДЕО Конкурс года в «Библиотеке программиста»: смонтируйте короткий вертикальный ролик формата Shorts/Reels* на тему программирования и разработки — лучший автор получит 40 тысяч рублей 🤑 Подробные условия: ➡️смонтируйте короткий смешной вертикальный ролик (можно и нужно использовать мемы) ➡️отправьте нам в бота @ProglibContest_bot ➡️лучшие ролики (по мнению редакции) мы будем выкладывать в канал и в наш инстаграм* ➡️тот, чей ролик соберет больше всего просмотров в инстаграм*, получит приз — 40 тысяч рублей Какие ролики мы не принимаем: 😟не вашего авторства (проверим!) 😟длинные, невертикальные, несмешные Таймлайн: 2 августа — заканчиваем принимать видео ⬇️ 3 августа — начинаем загружать лучшие видео в инстаграм ⬇️ 9 августа — подводим итоги *Организация Meta признана экстремистской в РФ

💬 Как итерироваться по рунам в строке Go? Для получения рун в строке достаточно использовать конструкцию for-range.

for i, rune := range aString {
    ... // используем руну
}

Руна может состоять из 1-4 байтов в UTF-8. Здесь i является начальным индексом байтов руны. Если нам нужно не только получить сами руны, но и их длину, удобным способом будет использование пакета unicode/utf8:

import "unicode/utf8"

var str = aString
for {
    rune, size := utf8.DecodeRuneInString(str)
    if size == 0 {
        break
    }
    str = str[size:]

    ... // используем руну
}

🔥Разработчики на Go! Вам нужны экстремальные результаты в разработке? Присоединяйтесь к нашему открытому онлайн вебинару «Как сделать быстрорастущий сервис с помощью трейсинга». Вы узнаете, как реализовать трейсинг для отслеживания выполнения запросов и выявления проблем. Мы покажем вам инструменты для анализа трейсов и наглядно рассмотрим работу сервиса под нагрузкой. Вы увидите, как с помощью трейсинга можно найти и устранить узкие места, даже если уже есть логирование. 🗣Спикер — DevOps-инженер в нескольких крупных проектах, опытный разработчик и преподаватель. ⏰ Встречаемся онлайн 25 июля в 20:00 мск. Регистрируйтесь прямо сейчас, чтобы не пропустить бесплатный урок: ➡️ РЕГИСТРАЦИЯ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576 Erid 2VtzqvPUkNn

​Открытое собеседование на Gо-разработчика в этот четверг 25 июля(уже в этот четверг!) в 19:00 по мск приходи онлайн на Открытое собеседование от Эйч Навыков. Как это будет: 1. Сергей Парамошкин, Deputy CTO в Yandex Cloud и ментор Эйч Навыков, позадает реальные вопросы и задачи разработчику-добровольцу 2. Потом Сережа даст подробную обратную связь — объяснит, зачем задавал тот или иной вопрос, как лучше на него ответить или решить задачу 3. В конце можно будет задать любой вопрос Сереже Что узнаешь на Открытом собеседовании: - Чего ждут от кандидатов на мидл-позиции в Gо-разработке - Какие вопросы задают на интервью и зачем - Как подготовиться к собесу, чтобы получить заветный оффер Это бесплатно? Бесплатно Просто зарегистрируйся на открытое собеседование в нашем боте @skills_mentee_bot Реклама: ООО “Эйч Карьера” erid: LjN8KRBeB

💬 Как использовать string canonicalization для экономии памяти? В Go, строки неизменяемы и часто одинаковые строки могут иметь разные блоки памяти. String canonicalization позволяет этим строкам делить один и тот же блок памяти, что может значительно сэкономить память. Рассмотрим два способа реализации на Go. 1️⃣ Первый способ предполагает, что когда две строки равны, одна строка может заменить другую, чтобы они делили одну и ту же память.

package main

import "fmt"

func CanonicalizeStrings(ss []string) {
 type S struct {
  str   string
  index int
 }
 var temp = make([]S, len(ss))
 for i := range temp {
  temp[i] = S{
   str:   ss[i],
   index: i,
  }
 }

 for i := 0; i < len(temp); {
  var k = i + 1
  for j := k; j < len(temp); j++ {
   if temp[j].str == temp[i].str {
    temp[j].str = temp[i].str
    temp[k], temp[j] = temp[j], temp[k]
    k++
   }
  }
  i = k
 }

 for i := range temp {
  ss[temp[i].index] = temp[i].str
 }
}

func main() {
 ss := []string{"hello", "world", "hello", "golang", "world"}
 CanonicalizeStrings(ss)
 fmt.Println(ss)
}

2️⃣ Использование unique.Handle, представленного в Go 1.23 Этот способ более удобен и гибок:.

package main

import (
 "fmt"
 "unique"
)

func CanonicalizeString(s string) string {
 return unique.Make(s).Value()
}

func CanonicalizeStrings(ss []string) {
 for i, s := range ss {
  ss[i] = CanonicalizeString(s)
 }
}

func main() {
 ss := []string{"hello", "world", "hello", "golang", "world"}
 CanonicalizeStrings(ss)
 fmt.Println(ss)
}