❓ Что точно выведет программа на экран при запуске?

Учитывай, что используется default в select, и что между отправками и чтениями есть time.Sleep.

package main

import (
 "fmt"
 "time"
)

func main() {
 ch := make(chan int)
 done := make(chan struct{})

 go func() {
  defer close(done)
  for i := 0; i < 3; i++ {
   ch <- i
   time.Sleep(100 * time.Millisecond)
  }
  close(ch)
 }()

 go func() {
  for {
   select {
   case v, ok := <-ch:
    if !ok {
     fmt.Println("channel closed")
     return
    }
    fmt.Println("received:", v)
   default:
    fmt.Println("default case")
    time.Sleep(50 * time.Millisecond)
   }
  }
 }()

 <-done
 time.Sleep(500 * time.Millisecond)
}

Хинт: Код показывает, как работает select с default при чтении из канала — если данных нет, выбирается default, не блокируя выполнение.

Ответ:

🔄 Что делает программа:
Одна горутина пишет 0, 1, 2 в канал ch с паузой 100мс, затем закрывает канал.

Вторая горутина читает из ch через select:

если данные есть → received: N

если нет → default case

если канал закрыт → channel closed

📤 Что выведет (примерно):

default case
default case
received: 0
default case
received: 1
default case
received: 2
channel closed
Порядок может немного отличаться из-за гонки между горутинами, но общая структура будет именно такая.

@golangtests

❓Вопрос:
Что будет выведено на экран? Напиши полный вывод программы и объясни, почему именно так.

package main

import (
 "fmt"
 "time"
)

type Speaker interface {
 Speak() string
}

type Person struct {
 name string
}

func (p Person) Speak() string {
 return "Hi, I'm " + p.name
}

func main() {
 var s Speaker
 p := Person{name: "Alice"}
 s = p

 p.name = "Bob"

 fmt.Println(s.Speak()) // (1)

 func() {
  s := p // shadowing: s — это теперь Person, а не Speaker
  fmt.Println(s.Speak()) // (2)
 }()
 go func(p Person) {
  time.Sleep(10 * time.Millisecond)
  fmt.Println(p.Speak()) // (3)
 }(p)

 p.name = "Charlie"

 time.Sleep(20 * time.Millisecond)
}

💡Подсказки:
Что происходит с интерфейсами в Go при присвоении структур?

Что такое shadowing и как это влияет на s внутри анонимной функции?

Как работает передача аргументов в goroutine?

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



✅ Ответ:

Hi, I'm Alice
Hi, I'm Bob
Hi, I'm Bob

@golangtests

🧪 Задача на Go 1.24: Range и поведение переменной цикла

Что выведет следующий код в Go 1.24?

package main

import "fmt"

func main() {
 values := []int{10, 20, 30}
 funcs := []func(){}

 for v := range values {
  funcs = append(funcs, func() {
   fmt.Println(v)
  })
 }

 for _, f := range funcs {
  f()
 }
}

Варианты ответа:
A)

1
2

B)

2
2

C)

20
30

D)

0
0

---

✅ Правильный ответ: A

Почему:
В Go 1.24 при использовании for v := range, переменная v копируется на каждой итерации, а не переиспользуется. Таким образом, замыкания получают своё собственное значение v на каждой итерации.
Здесь range возвращает индексы (0, 1, 2), а не значения среза.

Чтобы получить значения (10, 20, 30), нужно использовать for _, v := range values.

🧠 Что выведет следующий код?

package main

import (
    "fmt"
)

func change(val *int) {
    defer fmt.Println("defer:", *val)
    *val = 20
    fmt.Println("changed:", *val)
}

func main() {
    num := 10
    change(&num)
    fmt.Println("main:", num)
}

Варианты ответа:
A)

defer: 20
main: 20

B)

defer: 10
main: 20

C)

changed: 20
main: 20

D)

defer: 20
main: 20

Код выведет:
changed: 20
defer: 10
main: 20

Объяснение:
main: Переменная num инициализируется значением 10.
change(&num): Вызывается функция change, и ей передается адрес переменной num (указатель на num). Теперь параметр val внутри change указывает на ту же ячейку памяти, где хранится num.
defer fmt.Println("defer:", *val): Внутри change встречается оператор defer.
Важно: Аргументы для отложенного вызова (*val в данном случае) вычисляются сразу в момент объявления defer, а не в момент выполнения отложенной функции. На этом этапе *val (значение по адресу, на который указывает val, то есть значение num) равно 10. Таким образом, вызов fmt.Println("defer:", 10) ставится в очередь на выполнение перед выходом из функции change.
*val = 20: Значение по адресу, на который указывает val, изменяется на 20. Поскольку val указывает на num, это напрямую изменяет значение переменной num в функции main на 20.
fmt.Println("changed:", *val): Выводится текущее значение по адресу val, которое теперь равно 20. Печатается changed: 20.
Конец change: Функция change собирается завершиться. Перед выходом выполняется отложенный вызов.
Выполнение defer: Выполняется ранее запланированный вызов fmt.Println("defer:", 10). Печатается defer: 10.
Возврат в main: Управление возвращается в main.
fmt.Println("main:", num): Выводится текущее значение переменной num. Так как функция change изменила его через указатель, num теперь равно 20. Печатается main: 20.

@golangtests

🔍 Вопрос: что выведет этот код?

package main

import (
 "fmt"
)

func main() {
 m := map[string]int{"a": 1, "b": 2}
 keys := make([]string, 0, len(m))
 
 for k := range m {
  keys = append(keys, k)
 }
 
 for i := range keys {
  delete(m, keys[i])
  m["z"] = i
 }

 fmt.Println("map:", m)
 fmt.Println("keys:", keys)
}

---
✅ Ответ: Вывод программы будет зависеть от порядка итерации по ключам в исходной мапе m.

В Go порядок итерации по элементам map не гарантируется и может меняться от запуска к запуску.
Рассмотрим возможные варианты развития событий, предполагая два наиболее вероятных порядка итерации:

Сценарий 1: Порядок итерации - "a", "b"
Итерация 1:
k становится "a".
keys становится ["a"].
Удаляется элемент с ключом "a" из m. m теперь {"b": 2}.
Добавляется элемент {"z": 0} в m. m теперь {"b": 2, "z": 0}.
Итерация 2:
k становится "b".
keys становится ["a", "b"].
Удаляется элемент с ключом "b" из m. m теперь {"z": 0}.
Добавляется элемент {"z": 1} в m (перезаписывая предыдущее значение). m теперь {"z": 1}.
В этом случае вывод будет:
map: map["z":1]
keys: [a b]
Сценарий 2: Порядок итерации - "b", "a"

Итерация 1:
k становится "b".
keys становится ["b"].
Удаляется элемент с ключом "b" из m. m теперь {"a": 1}.
Добавляется элемент {"z": 0} в m. m теперь {"a": 1, "z": 0}.

Итерация 2:
k становится "a".
keys становится ["b", "a"].
Удаляется элемент с ключом "a" из m. m теперь {"z": 0}.
Добавляется элемент {"z": 1} в m (перезаписывая предыдущее значение). m теперь {"z": 1}.
В этом случае вывод будет:
map: map["z":1]
keys: [b a]

Итог:
Гарантируется, что:
Значение в мапе m после выполнения цикла всегда будет map["z":1]. Это происходит потому, что в каждой итерации старое значение ключа "z" перезаписывается.

Слайс keys будет содержать ключи исходной мапы в том порядке, в котором они были получены при первой итерации. Это может быть ["a", "b"] или ["b", "a"], или какой-либо другой порядок, если мапа была больше.

Поэтому возможные варианты вывода:
Вариант 1:
map: map["z":1]
keys: [a b]
Вариант 2:
map: map["z":1]
keys: [b a]
Какой именно вариант вы увидите при запуске, предсказать невозможно из-за недетерминированного порядка итерации по map в Go.

🧠 Задача на Go (1.22+)

package main

import "fmt"

func main() {
    m = map[string]int{"a": 1, "b": 2, "c": 3}

    defer fmt.Println("done")

    for k, v := range m {
        defer fmt.Println(k, v)
    }
}

Что выведет этот код?

A.
c 3
b 2
a 1
done

B.
done
a 1
b 2
c 3

C.
done
c 3
b 2
a 1

D.
a 3
a 3
a 3
done

Почему A? — в Go 1.22 range-переменные k и v создаются на каждом шаге заново, а defer захватывает копии, не ссылки.

🐹 Задача с подвохом: Generics и интерфейсы (Go 1.24)

Условие:

Что выведет следующий код и почему?

package main

import (
    "fmt"
)

type Stringer interface {
    String() string
}

type MyInt int

func (m MyInt) String() string {
    return fmt.Sprintf("MyInt: %d", m)
}

func printValue[T any](val T) {
    var s Stringer
    if v, ok := any(val).(Stringer); ok {
        s = v
    }
    if s != nil {
        fmt.Println("Stringer:", s.String())
    } else {
        fmt.Println("Default:", val)
    }
}

func main() {
    var x MyInt = 5
    printValue(x)
    printValue(10)
}

❓ Вопрос:
Что будет напечатано? Почему результат может удивить даже опытных Go-разработчиков?

🔍 Разбор:

Этот код использует generics и проверяет, реализует ли val интерфейс Stringer.

Пошагово:

1️⃣ var x MyInt = 5
Тип MyInt реализует интерфейс Stringer через метод:

```go
func (m MyInt) String() string { ... }
```

2️⃣ printValue(x)
- val здесь типа MyInt.
- В строке: any(val).(Stringer)
- Приведение типа успешно, потому что MyInt реализует Stringer.
- Печатается:
```
Stringer: MyInt: 5
```

3️⃣ printValue(10)
- Тип val здесь int.
- int не реализует Stringer.
- Приведение any(val).(Stringer) не срабатывает (ok == false).
- Печатается:
```
Default: 10
```

✅ Ожидаемый вывод:

```
Stringer: MyInt: 5
Default: 10
```

💥 Подвох:

- Даже если MyInt — это просто int, метод String() делает его другим типом, который реализует интерфейс.
- Многие забывают, что встроенные типы (int, string, и т.д.) никогда не реализуют интерфейсы напрямую, даже если они похожи на пользовательские типы.
- Ключевой момент: any(val) оборачивает значение в интерфейс{}, поэтому приведение типа срабатывает только если исходный тип действительно реализует интерфейс.

🆕 Почему это актуально для Go 1.24:

Generics в Go 1.22+ улучшились по типовой проверке и стали более гибкими. Go 1.24 сделал generics более стабильными и оптимизированными, но все еще важно понимать различия между типами и интерфейсами, особенно при работе с any и приведения типов внутри параметризованных функций.

🛡️ Лайфхак:

Если вы хотите печатать всё одинаково для типов с String(), можно сделать generic-констрейн с интерфейсом:

```go
func printValue2[T fmt.Stringer](val T) {
fmt.Println("Stringer (generic):", val.String())
}
```

✅ Вывод:

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

🤖 Хотите создать Telegram-бота с нуля на Go?

📅 13 мая в 20:00 МСК на открытом вебинаре мы разберем, как создать простого, но эффективного Telegram-бота для управления задачами, а также заложим правильную архитектуру для его дальнейшего расширения.

❗️Что разберем:

— Принципы разработки Telegram-ботов на Go.

— Архитектуру и структуры данных.

— Реализацию минимального набора функций для бота.

➡️ Открытый урок проходит в преддверие старта курса «Go (Golang) Developer Basic». Все участники получат скидку на обучение. Запишитесь прямо сейчас: https://otus.pw/4222/?erid=2W5zFGaggqW

Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🧠 Хитрая задача на Go: "Петля Блуждающего Робота"

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

- 'G' — идти вперед
- 'L' — повернуть налево (90°)
- 'R' — повернуть направо (90°)

Робот стартует из точки (0, 0) и смотрит на север. Команды повторяются бесконечно. Нужно определить:

👉 Зациклится ли движение робота?
(т.е. вернётся ли он в исходную точку или навсегда останется в замкнутом цикле)

📌 Примеры:

isLooping("GLGLGLG") => true    // движется по квадрату
isLooping("GG")       => false  // уходит навсегда

🧩 Подвох задачи:

На первый взгляд кажется, что нужно бесконечно симулировать команды. Но на самом деле всё решается за один проход строки!
Важно: если после одного прохода робот:
- вернулся в (0,0) или
- сменил направление — значит, будет цикл.

✅ Go-реализация:

```go
func isLooping(commands string) bool {
dirs := [][2]int{{0,1}, {1,0}, {0,-1}, {-1,0}} // север, восток, юг, запад
x, y, d := 0, 0, 0

for _, c := range commands {
switch c {
case 'G':
x += dirs[d][0]
y += dirs[d][1]
case 'L':
d = (d + 3) % 4
case 'R':
d = (d + 1) % 4
}
}

return (x == 0 && y == 0) || d != 0
}
```

🎯 Отличная задача для собеседования: она проверяет
• понимание направления и симуляции
• знание работы с векторами
• умение заменить бесконечный цикл на математический анализ

@golangtests