🤔 Какие циклы есть в 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)
   }

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

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

Дополнительный блок ({ ... }) внутри функции используется для:
- ограничения области видимости переменных;
- создания временной логической области, например, для вложенного вычисления;
- контроля жизни переменной, чтобы освободить её как можно раньше (особенно в длинных функциях или при работе с ресурсами)

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

🤔 Какие функции у map?

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

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

🟠Объявление карты
Для этого используется ключевое слово map, после которого указываются типы ключей и значений.

var myMap map[string]int

🟠Инициализация карты
Это можно сделать с помощью функции make или литерала карты.

// Инициализация с помощью make
myMap = make(map[string]int)

// Инициализация с помощью литерала карты
myMap = map[string]int{
    "Alice": 25,
    "Bob":   30,
}

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

myMap["Charlie"] = 35
myMap["Alice"] = 26 // обновление значения по ключу "Alice"

🟠Извлечение значения по ключу
Для этого используется синтаксис индексирования.

age := myMap["Alice"]
fmt.Println(age) // 26

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

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

🟠Удаление элемента
Для этого используется встроенная функция delete.

delete(myMap, "Bob")

🟠Итерация по карте
Для этого используется цикл for range.

for key, value := range myMap {
    fmt.Printf("Key: %s, Value: %d\n", key, value)
}

Пример

package main

import (
    "fmt"
)

func main() {
    // Инициализация карты с помощью литерала
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // Добавление нового элемента
    myMap["Charlie"] = 35

    // Обновление существующего элемента
    myMap["Alice"] = 26

    // Извлечение значения по ключу
    age := myMap["Alice"]
    fmt.Println("Age of Alice:", age) // 26

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

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

    // Итерация по карте
    for key, value := range myMap {
        fmt.Printf("Key: %s, Value: %d\n", key, value)
    }
}

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

🤔 Что такое closer и принцип его работы?

Это интерфейс, содержащий метод Close() error, который сигнализирует об освобождении ресурсов, например, файлов или соединений. Если объект реализует Closer, его можно безопасно завершить, вызвав Close, что предотвращает утечки ресурсов.

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

🤔 Зачем синхронизировать доступ данных?

В многопоточных (параллельных) программах горутины (goroutines) могут одновременно изменять одни и те же данные. Если не синхронизировать доступ, это приведёт к гонке данных (data race), когда несколько потоков читают/пишут одно и то же значение одновременно.

🚩`sync.Mutex` (мьютексы — блокировка данных)

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

package main

import (
  "fmt"
  "sync"
)

var (
  counter int
  mutex   sync.Mutex
)

func increment(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock()   // Блокируем доступ
  counter++      // Изменяем данные
  mutex.Unlock() // Разблокируем доступ
}

func main() {
  var wg sync.WaitGroup

  for i := 0; i < 1000; i++ {
    wg.Add(1)
    go increment(&wg)
  }

  wg.Wait()
  fmt.Println("Итоговый счетчик:", counter) // 1000
}

🚩`sync.RWMutex` (разделяемая блокировка)

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

var (
  data  int
  mutex sync.RWMutex
)

func readData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.RLock() // Разрешаем чтение
  fmt.Println("Читаем данные:", data)
  mutex.RUnlock()
}

func writeData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock() // Блокируем на запись
  data++
  mutex.Unlock()
}

🚩`sync.WaitGroup` (ожидание горутин)

Позволяет дождаться завершения всех горутин без блокировки данных.

var wg sync.WaitGroup

wg.Add(2)   // Ожидаем 2 горутины
go func() {
  defer wg.Done()
  fmt.Println("Горутина 1 завершилась")
}()
go func() {
  defer wg.Done()
  fmt.Println("Горутина 2 завершилась")
}()

wg.Wait()  // Ждём завершения всех горутин
fmt.Println("Все горутины завершены")

🚩`sync/atomic` (атомарные операции)

Атомарные операции быстрее мьютексов и гарантируют безопасное обновление переменных без гонок данных.

import "sync/atomic"

var counter int64

func incrementAtomic() {
  atomic.AddInt64(&counter, 1) // Атомарное увеличение
}

🚩Каналы (лучший способ в Go)

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

package main

import "fmt"

func main() {
  ch := make(chan int) // Канал для передачи данных

  go func() {
    ch <- 42 // Отправляем данные
  }()

  data := <-ch // Получаем данные
  fmt.Println("Получено:", data)
}

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

🤔 Что такое указатели?

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

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

Зарплата 207.000р у Middle-разработчика в Яндекс

«В день уходит несколько часов на созвоны, в остальное время закрываю задачки из спринта, редко перерабатываю. У компании топовый офис, но с коллективом как-то не заладилось. Радуюсь классному ДМС и стабильной зарплате» - middle разработчик из Яндекса.

Бигтех по-русски - канал с реальными зарплатами и историями IT-специалистов российского БигТеха. Там уже опубликованы рассказы программистов Альфа-банка, Сбера и Тинькофф 🤯

Читайте: @bigtech_russia

🤔 Что такое recover?

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

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

🤔 Что такое структура (stuct) в Go Зачем они нужны?

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

🚩Определение структуры

Определяются с использованием ключевого слова struct. В структуре могут быть поля различных типов.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Создание экземпляра структуры
    var p Person
    p.Name = "Alice"
    p.Age = 30

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

🚩Инициализация структур

Существует несколько способов инициализации структур.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация с использованием литерала структуры
    p := Person{Name: "Bob", Age: 25}
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

Инициализация по умолчанию

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация по умолчанию (поля будут нулевыми значениями)
    var p Person
    fmt.Println("Name:", p.Name) // Пустая строка
    fmt.Println("Age:", p.Age)   // 0
}

🚩Вложенные структуры

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

package main

import "fmt"

// Определение структур Address и Person
type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    // Инициализация структуры с вложенной структурой
    p := Person{
        Name: "Charlie",
        Age:  40,
        Address: Address{
            City:  "New York",
            State: "NY",
        },
    }

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
    fmt.Println("City:", p.Address.City)
    fmt.Println("State:", p.Address.State)
}

🚩Методы структур

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

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

// Метод для структуры Person
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{Name: "David", Age: 35}
    p.Greet()
}

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

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

🤔 В чём отличие длины и ёмкости у слайса?

1. Длина (len): количество элементов, содержащихся в слайсе.
2. Ёмкость (cap): максимальное количество элементов, которые слайс может вместить без перевыделения памяти.
3. При добавлении элементов с помощью append длина увеличивается, а если она превышает ёмкость, выделяется новый блок памяти с удвоенной ёмкостью.

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