🤔 Какие циклы есть в Go?

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

🚩Формы цикла

С тремя выражениями

      package main

   import "fmt"

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

Как while

      package main

   import "fmt"

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

Бесконечный

      package main

   import "fmt"

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

С использованием 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)
       }
   }
   
   

🚩Примеры

Итерация по массиву

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

Итерация по карте

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

Итерация по строке

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое recover?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Насколько безопасно передавать слайсы в разные горутины?

Передача слайсов (slices) в разные горутины может быть безопасной или небезопасной в зависимости от того, как вы используете эти слайсы. Основная проблема заключается в доступе к общим данным из разных горутин, что может привести к состояниям гонки (race conditions), если не соблюдать определенные правила.

🚩Основные аспекты безопасности

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

package main

import (
    "fmt"
    "sync"
)

func printSlice(slice []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for _, v := range slice {
        fmt.Println(v)
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup
    wg.Add(2)

    go printSlice(slice, &wg)
    go printSlice(slice, &wg)

    wg.Wait()
}

🟠Синхронизация доступа
Если слайс передается в горутину для записи или для одновременного чтения и записи, необходимо обеспечить синхронизацию доступа к данным. Для этого можно использовать мьютексы (sync.Mutex) или другие механизмы синхронизации.

package main

import (
    "fmt"
    "sync"
)

func incrementSlice(slice []int, wg *sync.WaitGroup, mu *sync.Mutex) {
    defer wg.Done()
    for i := range slice {
        mu.Lock()
        slice[i]++
        mu.Unlock()
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup
    var mu sync.Mutex

    wg.Add(2)

    go incrementSlice(slice, &wg, &mu)
    go incrementSlice(slice, &wg, &mu)

    wg.Wait()
    fmt.Println(slice)
}

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

package main

import (
    "fmt"
    "sync"
)

func incrementSlice(slice []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := range slice {
        slice[i]++
    }
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup

    wg.Add(2)

    // Передаем копии слайса в горутины
    go incrementSlice(append([]int(nil), slice...), &wg)
    go incrementSlice(append([]int(nil), slice...), &wg)

    wg.Wait()
    fmt.Println(slice) // Исходный слайс не изменяется
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что будет, если элемент не вмещается в размер слайса?

Если добавляемый элемент превышает текущую ёмкость (capacity) слайса, append создаёт новый массив с увеличенной ёмкостью (обычно в два раза больше исходной), копирует существующие элементы и добавляет новый. Это может привести к перераспределению памяти.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое HAVING?

HAVING — это оператор в SQL, который фильтрует группированные (GROUP BY) данные по агрегатным функциям (SUM, COUNT, AVG, MAX, MIN).

🚩Чем отличается `HAVING` от `WHERE`?

WHERE фильтрует отдельные строки до группировки.
HAVING фильтрует группы строк после GROUP BY.

Теперь посчитаем сумму продаж по категориям и оставим только те, где сумма > 250

SELECT category, SUM(amount) AS total_sales
FROM sales
GROUP BY category
HAVING SUM(amount) > 250;

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое индексы в MySQL?

Это структуры данных, которые ускоряют поиск строк в таблицах MySQL. Они работают аналогично оглавлению в книге, позволяя БД быстро находить нужные записи без полного сканирования таблицы.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 У ресивера имеется звёздочка - что это значит?

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

🚩Разница между `T` и `*T` в методах

🟠Метод с ресивером-значением (`T`)
Метод работает с копией структуры, а не с оригиналом.

package main

import "fmt"

type Person struct {
    Name string
}

// Метод работает с копией, оригинал не изменится
func (p Person) SetName(name string) {
    p.Name = name
}

func main() {
    p := Person{Name: "Alice"}
    p.SetName("Bob")
    fmt.Println(p.Name) // Выведет: Alice (не изменилось)
}

🟠Метод с ресивером-указателем (`*T`)
Метод работает с оригиналом и может изменять его поля.

type Person struct {
    Name string
}

// Метод изменяет оригинал структуры
func (p *Person) SetName(name string) {
    p.Name = name
}

func main() {
    p := Person{Name: "Alice"}
    p.SetName("Bob")
    fmt.Println(p.Name) // Выведет: Bob (изменилось!)
}

🚩 Когда использовать `*T`?

Если метод изменяет структуру → нужен указатель (*T).
Если метод только читает данные → можно использовать значение (T).
Использование *T также избегает копирования больших структур.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие типы каналов существуют?

В Go существует два типа каналов: буферизованные (buffered) и небуферизованные (unbuffered). Небуферизованные каналы требуют, чтобы отправляющая и принимающая горутина синхронизировались друг с другом, что делает их блокирующими. Буферизованные каналы имеют определённый размер буфера, и горутина может отправить сообщение в канал, не ожидая немедленного получения, пока буфер не заполнится. Оба типа каналов используются для передачи данных между горутинами и синхронизации их работы.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое mutex, какие они бывают и как их использовать?

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

🚩Какие бывают Mutex

🟠Блокирующие Mutex (Blocking Mutexes)
Это наиболее распространённый тип мьютексов. При попытке захватить мьютекс, если он уже занят другим потоком, поток блокируется и ожидает, пока мьютекс не будет освобождён.

🟠Неблокирующие Mutex (Non-blocking or Spinlocks)
Вместо блокирования потока, потоки активно проверяют состояние мьютекса в цикле. Это может быть эффективно, если мьютекс захватывается на очень короткое время, так как избегается затрата времени на блокировку и разблокировку потока.

🚩Использование Mutex

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

package main

import (
    "fmt"
    "sync"
)

var (
    balance int
    mutex   sync.Mutex
)

func deposit(value int, wg *sync.WaitGroup) {
    mutex.Lock() // Захват мьютекса перед изменением переменной balance
    fmt.Printf("Depositing %d to account with balance: %d\n", value, balance)
    balance += value
    mutex.Unlock() // Освобождение мьютекса после изменения
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go deposit(100, &wg)
    go deposit(200, &wg)
    wg.Wait()
    fmt.Printf("New Balance %d\n", balance)
}

🚩Рекомендации по использованию

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

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

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

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как передаются параметры в функцию — по указателю или по значению?

По умолчанию в Go все параметры передаются по значению, т.е. копируются.
Но если передать указатель на переменную, можно изменить её содержимое. Это единственный способ передать значение по ссылке.
Тип *T указывает, что это указатель, а не значение.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🚨 60 минут до финала

Через час мы закроем краудфандинг easyoffer 2.0
Это последний шанс вписаться в самые выгодные условия.

👉 https://planeta.ru/campaigns/easyoffer

🤔 Можно ли сделать int(string) и string(int) соответственно?

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

🚩Преобразование строки в целое число

Для этого используется функция strconv.Atoi. Она возвращает два значения: само число и ошибку, если преобразование не удалось.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "123"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error converting string to int:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

🚩Преобразование целого числа в строку

Для этого используется функция strconv.Itoa.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 123
    str := strconv.Itoa(num)
    fmt.Println("Converted string:", str)
}

🚩Обработка ошибок при преобразовании

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

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "abc"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как можно откопировать слайс?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как строки работают в Golang внутри?

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

🚩Неизменяемость

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

🚩Структура строки

Внутренне строка представлена структурой, которая содержит два поля:
Указатель на массив байтов: Это указатель на первый элемент массива байт, который фактически хранит символы строки в кодировке UTF-8.
Длина: Количество байт в строке, а не количество рун или символов. Это важное различие, поскольку в UTF-8 один символ может занимать от 1 до 4 байт.

🚩UTF-8 как стандартная кодировка

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

🚩Срезы строк

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

🚩Производительность и память

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

s := "Hello, world"      // Создание строки
t := s[7:]               // Срез строки, создает новую строку "world"

fmt.Println(s)           // Выводит: Hello, world
fmt.Println(t)           // Выводит: world

Ставь 👍 и забирай 📚 Базу знаний