Go tests
7.82K subscribers
318 photos
7 videos
117 links
По всем вопросам- @haarrp

@itchannels_telegram - 🔥полезные ит-каналы

https://t.iss.one/Golang_google - Golang программирование

@golangl - golang chat

@GolangJobsit - golang channel jobs

@golang_jobsgo - go chat jobs
Download Telegram
Что выведет код?
❓ Как объявить канал только для чтения в аргументе функции
Anonymous Quiz
12%
func receive(ch chan-> int)
27%
func receive(ch chan<- int)
56%
func receive(ch <-chan int)
5%
func receive(ch readonly chan int)
👏2❤1
❓ Какая команда запустит тестирование всех пакетов проекта, если вы находитесь в корневой директории проекта
Anonymous Quiz
11%
go test --all
5%
go test -r
67%
go test ./...
10%
go test *
6%
Узнать ответ
👣 Golang-задача с подвохом

Версия: Go 1.23+

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


package main

import "fmt"

func numbers(yield func(int) bool) {
defer fmt.Println("iterator: defer")

for i := 0; i < 5; i++ {
if !yield(i) {
fmt.Println("iterator: stopped")
return
}

fmt.Println("iterator: after yield", i)
}
}

func main() {
for n := range numbers {
fmt.Println("main:", n)

if n == 2 {
break
}
}

fmt.Println("main: done")
}


Многие ждут, что после break итератор просто мгновенно исчезнет.

Но в Go 1.23 появился range по функции.

Под капотом yield возвращает false, если внешний цикл остановился через break.

Ответ:

```txt id="5glpxa"
main: 0
iterator: after yield 0
main: 1
iterator: after yield 1
main: 2
iterator: stopped
iterator: defer
main: done
```

Подвох в том, что `break` происходит во внешнем цикле, но функция-итератор получает сигнал остановки через `yield`.

Если не проверить `!yield(i)`, можно продолжить работу после того, как потребитель уже вышел из цикла.
Please open Telegram to view this post
VIEW IN TELEGRAM
❤3👍2🔥1
👣 Go давно починил старую ловушку с замыканиями в цикле.

Но concurrency всё ещё может кусаться.

Что не так с этим кодом?


package main

import (
"fmt"
"sync"
)

func main() {
nums := []int{1, 2, 3, 4}

var wg sync.WaitGroup
result := make([]int, 0, len(nums))

for i, n := range nums {
wg.Go(func() {
result = append(result, i*n)
})
}

wg.Wait()

fmt.Println(result)
}


На первый взгляд всё нормально.

i и n уже не общие для всех итераций. В современном Go каждая итерация получает свои переменные, поэтому старого бага с замыканием тут нет.

Проблема в другом месте.

`append` меняет slice header и может трогать общий backing array. Несколько горутин делают это одновременно. Значит, здесь data race, даже если loop variables теперь безопасные.

Правильный вариант:

```go id="9f32ws"
package main

import (
"fmt"
"sync"
)

func main() {
nums := []int{1, 2, 3, 4}

var wg sync.WaitGroup
result := make([]int, len(nums))

for i, n := range nums {
wg.Go(func() {
result[i] = i * n
})
}

wg.Wait()

fmt.Println(result)
}
```

Теперь каждая горутина пишет в свой индекс.

Без mutex.
Без channel.
Без лишнего копирования переменных.

Хороший тест на то, понимаешь ли ты Go после 1.22, а не просто помнишь старую страшилку про closures.
Please open Telegram to view this post
VIEW IN TELEGRAM
👍6🔥3❤1👎1
В Go 1.26 появился типобезопасный errors.AsType, который ищет ошибку нужного типа внутри дерева обёрток.


package main

import (
"errors"
"fmt"
)

type CodeError struct {
Code int
}

func (e *CodeError) Error() string {
return fmt.Sprintf("code=%d", e.Code)
}

type MaskError struct {
Value int
}

func (e MaskError) Error() string {
return "masked"
}

func (e MaskError) As(target any) bool {
dst, ok := target.(**CodeError)
if !ok {
return false
}

*dst = &CodeError{Code: e.Value}
return true
}

func main() {
err := errors.Join(
fmt.Errorf("left: %w", MaskError{Value: 10}),
errors.Join(
&CodeError{Code: 20},
fmt.Errorf("right: %w", &CodeError{Code: 30}),
),
)

result, ok := errors.AsType[*CodeError](err)
fmt.Println(ok, result.Code)
}


Что будет выведено?

true 10

Кажется, ответ должен быть 20: это первая настоящая ошибка типа *CodeError. Но errors.AsType обходит дерево в глубину, начиная с первой ветки.

MaskError встречается раньше и через собственный метод As притворяется *CodeError, записывая значение с кодом 10. Поэтому дальнейший поиск прекращается.

Cлучай, когда тип ошибки определяется не только её реальным типом, но и поведением метода As.
❤5👍1
🧠 Редкая задача для Go-разработчиков

Версия: Go 1.23+
Именно в Go 1.23 появился range по функциям-итераторам и пакет iter.

Нужно реализовать:


func MergeSorted(a, b iter.Seq[int]) iter.Seq[int]


Функция получает два ленивых отсортированных итератора и возвращает один общий поток в отсортированном порядке.

Пример:


a := Seq(1, 4, 7, 10)
b := Seq(2, 3, 8, 9)

for v := range MergeSorted(a, b) {
fmt.Println(v)
}


Результат:


1 2 3 4 7 8 9 10


Но есть условия:

* нельзя превращать входы в []int;
* нельзя использовать горутины и каналы;
* память должна быть O(1);
* если внешний цикл сделал break, оба исходных итератора должны прекратить работу;
* каждый элемент исходного iterator можно получить только один раз.

🔥 Дополнительный уровень: сделать generic-версию:


func MergeSorted[T cmp.Ordered](
a, b iter.Seq[T],
) iter.Seq[T]


На первый взгляд обычный merge. На практике придётся хорошо понять, как устроены push/pull iterators, `yield` и раннее завершение `range` в Go 1.23.
👍10
Задача Go 1.26, на которой легко ошибиться даже опытному разработчику

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


package main

import "fmt"

type Config struct {
Timeout *int
}

func main() {
a := Config{
Timeout: new(30),
}

b := a
*b.Timeout = 60

c := Config{
Timeout: new(*a.Timeout),
}
*c.Timeout = 90

fmt.Println(
*a.Timeout,
*b.Timeout,
*c.Timeout,
)
}


Попробуйте определить ответ до запуска.

```text
60 60 90
```

Почему?

```go
b := a
```

Структура копируется, но указатель внутри неё остаётся тем же. Поэтому `a.Timeout` и `b.Timeout` указывают на одну переменную:

```go
*b.Timeout = 60
```

Изменение видно через обе структуры.

А здесь создаётся уже новая переменная:

```go
Timeout: new(*a.Timeout)
```

Go сначала получает значение `60`, затем выделяет для него отдельную память. Поэтому изменение `c.Timeout` не влияет на `a` и `b`.

```text
a ─┐
├──► 60
b ─┘

c ─────► 90
```

Это важный нюанс: копирование структуры с указателями, слайсами или map не создаёт глубокую копию данных.

Синтаксис `new(30)` появился в **Go 1.26**. Раньше `new` принимал только тип, а теперь может сразу создать указатель на переданное значение.

Код актуален для последней стабильной версии **Go 1.26.5**.

#Golang #Go126 #Programming
👍15❤3
Go-задача: что выведет этот код?


package main

import "fmt"

func main() {
var funcs []func()

for i := range 3 {
funcs = append(funcs, func() {
fmt.Println(i)
})
}

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


Что будет в выводе?


A)

0
0
0

😎

2
2
2

C)

0
1
2

D) Код не скомпилируется


Правильный ответ: C — 0, 1, 2

Почему?

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

Плюс range теперь можно использовать прямо по integer:

```go
for i := range 3
```

Это даёт значения:

```go
0
1
2
```

Поэтому каждое замыкание запоминает своё i.

Несколько лет назад похожие примеры часто ломались из-за захвата одной общей переменной цикла, и разработчики писали:

```go
i := i
```
внутри цикла.

Хороший вопрос на собеседовании:

Почему этот код сегодня выводит 0, 1, 2, хотя раньше похожий пример мог вести себя иначе?
❤5🔥5🥰2
👣 Go 1.27: почему две разные closure внезапно могут иметь одинаковый адрес функции?

Что выведет этот код и почему на Go 1.27 поведение стало особенно интересным?


package main

import (
"fmt"
"reflect"
)

func makeFn(x int) func() int {
return func() int {
return x
}
}

func main() {
a := makeFn(10)
b := makeFn(20)

pa := reflect.ValueOf(a).Pointer()
pb := reflect.ValueOf(b).Pointer()

fmt.Println(a(), b())
fmt.Println(pa == pb)
}


Интуитивно хочется сказать:

a и b замыкают разные значения, значит это две разные функции и адреса должны отличаться.

Но в Go 1.27 компилятор стал агрессивнее объединять одинаковый машинный код function literals.

У a и b может быть:

один и тот же code pointer
но разное closure data
поэтому a() возвращает 10, а b() - 20

То есть функция в Go на уровне runtime - это не просто адрес машинного кода.

У замыкания фактически есть ещё окружение с захваченными данными.

Именно поэтому сравнивать функции по reflect.Value.Pointer() как способ определить, «одна ли это функция», нельзя.

Go 1.27 специально предупреждает: разные closure с разными захваченными данными теперь могут чаще иметь одинаковые code pointers из-за оптимизаций компилятора.
Please open Telegram to view this post
VIEW IN TELEGRAM
👍10🔥5❤1🥰1
🔥 Хочешь расти в IT быстрее остальных? Перестань учиться в одиночку

Можно годами смотреть курсы, читать документацию и всё равно топтаться на месте.

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

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

AI: t.iss.one/ai_machinelearning_big_data
Python: t.iss.one/pythonl
Linux: t.iss.one/linuxacademiya
Хакинг: t.iss.one/linuxkalii
DevOps: t.iss.one/DevOPSitsec
Docker: https://t.iss.one/+90Z5TAyfuNU5YmRi
Golang: t.iss.one/Golang_google
Rust: t.iss.one/rust_code
C++: t.iss.one/cpluspluc
C#: t.iss.one/csharp_ci
Java: t.iss.one/javatg
JavaScript: t.iss.one/javascriptv
React: t.iss.one/react_tg
Frontend: t.iss.one/front
PHP: t.iss.one/phpshka
Android: t.iss.one/android_its
Мобильная разработка: t.iss.one/mobdevelop
Базы данных: t.iss.one/sqlhub
Data Science: t.iss.one/data_analysis_ml
Big Data: t.iss.one/bigdatai
Математика: t.iss.one/data_math
Физика: t.iss.one/fizmat
Kubernetes: t.iss.one/kubernetc
GameDev: https://t.iss.one/gamedev
Haskell: t.iss.one/haskell_tg

Собеседования и карьера:

DS собеседования: t.iss.one/machinelearning_interview
Python собеседования: t.iss.one/python_job_interview

Папка с вакансиями: t.iss.one/addlist/_zyy_jQ_QUsyM2Vi
Папка Go разработчика: t.iss.one/addlist/MUtJEeJSxeY2YTFi
Папка Python разработчика: t.iss.one/addlist/eEPya-HF6mkxMGIy
Папка ML: https://t.iss.one/addlist/2Ls-snqEeytkMDgy
Папка Frontend: https://t.iss.one/addlist/mzMMG3RPZhY2M2Iy

Полезное сверху:

ИТ-мемы: t.iss.one/memes_prog
Английский для программистов: t.iss.one/english_forprogrammers
ИИ и технологии: t.iss.one/vistehno
954 ГБ open-source курсов: https://t.iss.one/+rKBQEMccAA01MTcy
ИТ-книги бесплатно: https://t.iss.one/addlist/BkskQciUW_FhNjEy

Max Ai: https://max.ru/ai_machinelearning_big_data
Max python: https://max.ru/pythonl
ТЕХНО: https://max.ru/vistehno
Max Go: https://max.ru/Golang_google
Max Linux: https://max.ru/linuxkalii
Devops: https://max.ru/DevOPSitsec
C#: https://max.ru/csharp_ci
C++: https://max.ru/cpluspluc
SQL: https://max.ru/sqlhub
Java: https://max.ru/javatg

Подпишись и сохрани, здесь регулярно появляются новые подборки, инструменты и материалы, которые реально помогают расти быстрее.
❤2👍1🔥1
👣 Задача на Go 1.27: concurrent job scheduler с generic methods

Нужно реализовать библиотеку scheduler, которая запускает задачи параллельно, ограничивает concurrency, поддерживает context.Context, retry, timeout и возвращает типизированные результаты.

💡 Требования

Создайте generic-тип:


type Scheduler[T any] struct {
// ...
}

Он должен поддерживать регистрацию задач:

type Job[T any] func(ctx context.Context) (T, error)

И новый generic method Go 1.27:

func (s *Scheduler[T]) Map[R any](
ctx context.Context,
fn func(context.Context, T) (R, error),
) ([]R, error)
Функциональность

Scheduler должен уметь:

выполнять не более N задач одновременно;
отменять все оставшиеся задачи при отмене context.Context;
задавать timeout для каждой задачи;
делать до K retry с exponential backoff;
сохранять исходный порядок результатов;
не иметь data race;
корректно завершать goroutines без утечек;
возвращать ошибку с информацией, какая задача упала.

Пример API:

```go
s := scheduler.New[int](
scheduler.WithWorkers(8),
scheduler.WithRetries(3),
scheduler.WithTimeout(2*time.Second),
)

for i := range 100 {
n := i

s.Add(func(ctx context.Context) (int, error) {
return expensiveOperation(ctx, n)
})
}

values, err := s.Run(ctx)

strings, err := s.Map(ctx, func(
ctx context.Context,
value int,
) (string, error) {
return strconv.Itoa(value), nil
})


Ограничения

• Нельзя использовать сторонние worker-pool библиотеки.
• Можно использовать только standard library.
• Нельзя запускать goroutine на каждую задачу без ограничения.
• Нельзя игнорировать ctx.Done().

Решение должно проходить:

go test ./...
go test -race ./...
go vet ./...
Дополнительный уровень


Добавьте:


func (s *Scheduler[T]) Stream(
ctx context.Context,
) <-chan Result[T]


где результаты приходят сразу после завершения задач, а не после окончания всего batch.

Ещё сложнее:


priority queue;
dynamic worker count;
graceful shutdown;
metrics через expvar;
retry только для определённых типов ошибок;
panic recovery внутри job;
benchmark;
fuzz tests.


Главный вопрос

Как реализовать Scheduler так, чтобы одновременно обеспечить:

bounded concurrency + cancellation + ordering + retries + no goroutine leaks + no races
Please open Telegram to view this post
VIEW IN TELEGRAM
❤6🥰2
Не застревайте в прошлом — учитесь новым навыкам и ИИ

Чтобы успевать за требованиями рынка, освойте новую профессию и нейросети в Практикуме. До 30 сентября действует скидка 16% на все курсы. 

Выбрать курс

Как всё устроено: 

— нейросети уже в каждом курсе: учим профессиям сразу с ИИ, чтобы ваше резюме было заметнее, а трудоустройство — увереннее;

— эксперты — практики, которые двигают ИИ-индустрию: перенимайте опыт у профи из Яндекса, Сбера, Т-Банка и других бигтех-компаний;

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

Начните учиться бесплатно и получите скидку 16% — она автоматически появится в личном кабинете. 

Учиться!

Erid: 2SDnjeMs7zT
Название: ООО "ЯНДЕКС"
ИНН: 7736207543
Задача по Go: `select` и побочные эффекты

Что выведет программа?


package main

import "fmt"

func value() int {
fmt.Print("A")
return 42
}

func main() {
var ch chan int

select {
case ch <- value():
fmt.Print("B")
default:
fmt.Print("C")
}
}


Варианты:

1. C
2. AC
3. AB
4. Программа зависнет

Ответ: 2. Вывод будет `AC`.

ch равен nil, поэтому отправка никогда не может выполниться и select выбирает default.

Но перед выбором ветки Go один раз вычисляет каналы и правые части всех операций отправки. Поэтому value() всё равно вызывается и печатает A. Затем выполняется default, который печатает C.

#Golang #GoLang #Programming
👍11❤2
Media is too big
VIEW IN TELEGRAM
Nil-интерфейс в Go: почему err == nil выдаёт false?


Nil-интерфейс в Go ломает даже опытных разработчиков: функция возвращает nil-указатель *E, а проверка err == nil всё равно даёт false. Причина в том, что интерфейс хранит пару из типа и значения, и пока тип *E на месте, интерфейс не считается пустым. Хочешь вернуть «нет ошибки», возвращай nil явно.

youtube.com/shorts/6LK-o-BSjHA?feature=share
❤4😁3🥰2👍1
3 года опыта в IT, зарплата 120к. Через пару месяцев — ОФФЕР НА 360К. 😎😎

И это далеко не единственный такой случай))

Меня зовут Даниил Белман, я Senior Go-разработчик. За последние 1.5 года помог трудоустроиться 200+ разработчикам в Авито, Т-Банк, Ozon, VK, Яндекс и другие компании с зарплатами до 680к на руки.

За это время я повидал огромное количество диких ситуаций на рынке IT. Когда человек с 3 годами опыта получает 120к, а вчерашний студент залетает на 350к. Когда разработчики работают на 2-3 работах и зарабатывают по миллиону+ в месяц.

И собственно об этом я рассказываю в своем канале.

Что вообще из интересного для тебя там:

— Как выйти на ЗАРПЛАТУ 350-500К ₽ в российском IT и проходить собесы в бигтех

— Как искать ВАЛЮТНУЮ УДАЛЕНКУ НА $6-8k, даже находясь в РФ

— Как совмещать несколько работ, использовать нейронки и выходить на 1КК+ В МЕСЯЦ?

Ну и периодически пишу про бизнес, деньги и собственную жизнь АйТиШнИка)

И КРУТЫЕ ИСТОРИИ МОИХ ПОДПИСЧИКОВ:

1. Ученик получил оффер на 1.000.000 ₽ GROSS

2. Не взяли на стажировку за 80к, через 3 месяца залетел на 400к

В общем если ты работаешь в IT или только собираешься вкатиться и хочешь зарабатывать как можно больше — you're absolutely welcome =)

Даниил Белман. Подписаться
Please open Telegram to view this post
VIEW IN TELEGRAM
👎8😁4🤬2
🐹 Go 1.27: задача с подвохом

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


package main

import (
"fmt"
"math"
"maps"
)

func main() {
x := math.NaN()
m := map[float64]int{}

m[x] = 10
m[x] = 20

fmt.Println(len(m), m[x])

maps.DeleteFunc(m, func(k float64, v int) bool {
return true
})

fmt.Println(len(m))

clear(m)
fmt.Println(len(m))
}


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

A ) 1 20, 0, 0
B ) 2 0, 0, 0
C ) 2 0, 2, 0
D ) 1 0, 1, 0
E ) Ошибка компиляции

Попробуйте объяснить, почему maps.DeleteFunc() и clear() могут вести себя по-разному.
👍1🔥1