Как правильно подсоединить warning canceller

package main import "fmt" func main()

2. Неиспользуемые переменные

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

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

package main var gvar int // not an error func main() < var one int // ошибка, неиспользуемая переменная two := 2 // ошибка, неиспользуемая переменная var three int // ошибка, даже несмотря на присваивание значения 3 в следующей строке three = 3 func(unused string) < fmt.Println("Unused arg. No compile error") >("what?") > 

/tmp/sandbox473116179/main.go:6: one declared and not used /tmp/sandbox473116179/main.go:7: two declared and not used /tmp/sandbox473116179/main.go:8: three declared and not used 

package main import "fmt" func main()

Другое решение: комментировать или удалять неиспользуемые переменные.

3. Неиспользуемые импорты

Если вы импортируете пакет и потом не используете какие-либо из его функций, интерфейсов, структур или переменных, то код не скомпилируется. Если нужно импортировать пакет, идентификатор «_» в качестве его имени поможет избежать ошибок компилирования. Идентификатор «_» чаще всего применяется для использования сайд-эффектов импортированных библиотек.

package main import ( "fmt" "log" "time" ) func main()

/tmp/sandbox627475386/main.go:4: imported and not used: "fmt" /tmp/sandbox627475386/main.go:5: imported and not used: "log" /tmp/sandbox627475386/main.go:6: imported and not used: "time" 

package main import ( _ "fmt" "log" "time" ) var _ = log.Println func main()

Другое решение: удалить или закомментировать неиспользуемые импорты. В этом поможет инструмент goimports.

4. Короткие объявления переменных можно использовать только внутри функций

package main myvar := 1 // ошибка func main()

/tmp/sandbox265716165/main.go:3: non-declaration statement outside function body 

package main var myvar = 1 func main()

5. Переобъявления переменных с помощью коротких объявлений

В одной области видимости выражения нельзя переобъявлять переменные, но это можно делать в объявлении нескольких переменных (multi-variable declarations), среди которых хотя бы одна — новая. Переобъявляемые переменные должны располагаться в том же блоке, иначе получится скрытая переменная (shadowed variable).
Неправильно:

package main func main() < one := 0 one := 1 // ошибка >

/tmp/sandbox706333626/main.go:5: no new variables on left side of := 

package main func main()

6. Нельзя использовать короткие объявления переменных для настройки значений полей

package main import ( "fmt" ) type info struct < result int >func work() (int,error) < return 13,nil >func main() < var data info data.result, err := work() // ошибка fmt.Printf("info: %+v\n",data) >

prog.go:18: non-name data.result on left side of := 

Хотя разработчикам Go уже предлагали это исправить, не стоит надеяться на перемены: Робу Пайку нравится всё «как есть». Вам помогут временные переменные. Или предварительно объявляйте все свои переменные и используйте стандартный оператор присваивания.

package main import ( "fmt" ) type info struct < result int >func work() (int,error) < return 13,nil >func main() < var data info var err error data.result, err = work() // ok if err != nil < fmt.Println(err) return >fmt.Printf("info: %+v\n",data) // выводит: info: > 

7. Случайное сокрытие переменных

Синтаксис короткого объявления переменных так удобен (особенно для тех, кто пришёл в Go из динамических языков), что его легко принять за регулярную операцию присваивания. Если вы сделаете эту ошибку в новом блоке кода, то компилятор не выдаст ошибку, но приложение будет работать некорректно.

package main import "fmt" func main() < x := 1 fmt.Println(x) // выводит 1 < fmt.Println(x) // выводит 1 x := 2 fmt.Println(x) // выводит 2 >fmt.Println(x) // выводит 1 (плохо, если нужно было 2) > 

Это очень распространённая ошибка даже среди опытных Go-разработчиков. Её легко совершить и трудно заметить. Для выявления подобных ситуаций можно использовать команду vet. По умолчанию она не выполняет проверку переменных на скрытость. Поэтому используйте флаг -shadow: go tool vet -shadow your_file.go

8. Нельзя использовать nil для инициализации переменной без явного указания типа

Идентификатор nil можно использовать как «нулевое значение» (zero value) для интерфейсов, функций, указателей, хеш-таблиц (map), слайсов (slices) и каналов. Если не задать тип переменной, то компилятор не сможет завершить работу, потому что не сумеет угадать тип.

package main func main() < var x = nil // ошибка _ = x >

/tmp/sandbox188239583/main.go:4: use of untyped nil 

package main func main() < var x interface<>= nil _ = x > 

9. Использование nil-слайсов (slice) и хеш-таблиц (map)

Можно добавлять элементы в nil -слайс, но если то же самое сделать с хеш-таблицей, то это приведёт к runtime panic.

package main func main()

package main func main() < var m map[string]int m["one"] = 1 // ошибка >

10. Ёмкость хеш-таблиц

Можно устанавливать ёмкость при создании хеш-таблиц, но нельзя применять к ним функцию cap() .

package main func main() < m := make(map[string]int,99) cap(m) // ошибка >

/tmp/sandbox326543983/main.go:5: invalid argument m (type map[string]int) for cap 

11. Строки не могут быть nil

Это подводный камень для начинающих, которые присваивают строковым переменным nil -идентификаторы.

package main func main() < var x string = nil // ошибка if x == nil < // ошибка x = "default" >> 

/tmp/sandbox630560459/main.go:4: cannot use nil as type string in assignment /tmp/sandbox630560459/main.go:6: invalid operation: x == nil (mismatched types string and nil) 

func main() < var x string // возвращает значение по умолчанию "" (нулевое значение) if x == "" < x = "default" >> 

12. Передача массивов в функции

Если вы разрабатываете на С/С++, то массивы для вас — указатели. Когда вы передаёте массивы функциям, функции ссылаются на ту же область памяти и поэтому могут обновлять исходные данные. В Go массивы являются значениями, так что, когда мы передаём их функциям, те получают копию исходного массива. Это может стать проблемой, если вы пытаетесь обновлять данные в массиве.

package main import "fmt" func main() < x := [3]intfunc(arr [3]int) < arr[0] = 7 fmt.Println(arr) // выводит [7 2 3] >(x) fmt.Println(x) // выводит [1 2 3] (плохо, если вам нужно было [7 2 3]) > 

Если нужно обновить исходные данные в массиве, используйте типы указателей массива.

package main import "fmt" func main() < x := [3]intfunc(arr *[3]int) < (*arr)[0] = 7 fmt.Println(arr) // выводит &[7 2 3] >(&x) fmt.Println(x) // выводит [7 2 3] > 

Другое решение: слайсы. Хотя ваша функция получает копию переменной слайса, та всё ещё является ссылкой на исходные данные.

package main import "fmt" func main() < x := []intfunc(arr []int) < arr[0] = 7 fmt.Println(arr) // выводит [7 2 3] >(x) fmt.Println(x) // выводит [7 2 3] > 

13. Неожиданные значения в выражениях range в слайсах и массивах

Это может произойти, если вы привыкли к выражениям for-in или foreach в других языках. Но в Go выражение range отличается тем, что оно генерирует два значения: первое — это индекс элемента (item index), а второе — данные элемента (item data).

package main import "fmt" func main() < x := []stringfor v := range x < fmt.Println(v) // выводит 0, 1, 2 >> 

package main import "fmt" func main() < x := []stringfor _, v := range x < fmt.Println(v) // выводит a, b, c >> 

14. Одномерность слайсов и массивов

Кажется, что Go поддерживает многомерные массивы и слайсы? Нет, это не так. Хотя можно создавать массивы из массивов и слайсы из слайсов. С точки зрения производительности и сложности — далеко не идеальное решение для приложений, которые выполняют числовые вычисления и основаны на динамических многомерных массивах.

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

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

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

package main func main() < x := 2 y := 4 table := make([][]int,x) for i:= range table < table[i] = make([]int,y) >> 

Создание динамического многомерного массива с помощью слайсов из слайсов «с совместно используемыми данными» состоит из трёх шагов. Сначала нужно создать слайс, выполняющий роль «контейнера» данных, он содержит исходные данные (raw data). Затем — внешний слайс. В конце мы инициализируем каждый из внутренних слайсов, перенарезая слайс с исходными данными.

package main import "fmt" func main() < h, w := 2, 4 raw := make([]int,h*w) for i := range raw < raw[i] = i >fmt.Println(raw,&raw[4]) // выводит: [0 1 2 3 4 5 6 7] table := make([][]int,h) for i:= range table < table[i] = raw[i*w:i*w + w] >fmt.Println(table,&table[1][0]) // выводит: [[0 1 2 3] [4 5 6 7]] > 

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

15. Обращение к несуществующим ключам в map

Эту ошибку совершают разработчики, которые при обращении к несуществующему ключу ожидают получить nil -значение (как это происходит в некоторых языках). Возвращаемое значение будет nil , если «нулевое значение» для соответствующего типа данных — nil . Но для других типов возвращаемое значение окажется другим. Определять, существует ли запись в хеш-таблице (map record), можно с помощью проверки на правильное «нулевое значение». Но это не всегда надёжно (например, что вы будете делать, если у вас есть таблица булевых значений, где «нулевое значение» — false). Самый надёжный способ узнать, существует ли запись, — проверить второе значение, возвращаемое операцией доступа к таблице.

package main import "fmt" func main() < x := map[string]stringif v := x["two"]; v == "" < // некорректно fmt.Println("no entry") >> 

package main import "fmt" func main() < x := map[string]stringif _,ok := x["two"]; !ok < fmt.Println("no entry") >> 

16. Неизменяемость строк

Если вы попытаетесь обновить отдельные символы строковой переменной с помощь оператора индекса, то это не сработает. Строки — это байт-слайсы (byte slices), доступные только для чтения. Если вам все-таки нужно обновить строку, то стоит использовать байт-слайс и преобразовывать его в строку по необходимости.

package main import "fmt" func main()

/tmp/sandbox305565531/main.go:7: cannot assign to x[0] 

package main import "fmt" func main() < x := "text" xbytes := []byte(x) xbytes[0] = 'T' fmt.Println(string(xbytes)) // выводит Text >

Стоит заметить, что это неправильный способ обновления символов в текстовой строке, потому что символ может состоять из нескольких байтов. В этом случае лучше конвертировать строку в слайс из «рун» (rune). Но даже внутри слайсов из «рун» одиночный символ может быть разбит на несколько рун, например если есть символ апострофа (grave accent). Такая непростая и запутанная природа «символов» является причиной того, что в Go строковые значения представляют собой последовательностей байтов.

17. Преобразование строк в байт-слайсы (Byte Slices), и наоборот

Когда вы преобразуете строку в байт-слайс (и наоборот), вы получаете полную копию исходных данных. Это не операция приведения (cast operation), как в других языках, и не перенарезка (reslicing), когда переменная нового слайса указывает на один и тот же массив, занятый исходным байт-слайсом.

В Go есть несколько оптимизаций для преобразований из []byte в string и из string в []byte , позволяющих избегать дополнительных выделений памяти (ещё больше оптимизаций в списке todo).

Первая оптимизация позволяет избежать дополнительного выделения памяти, когда ключи []byte используются для поиска записей в коллекциях map[string]: m[string(key)] .

Вторая оптимизация позволяет избегать дополнительного выделения в выражениях for range , когда строки преобразуются в []byte: for i,v := range []byte(str) <. >.

18. Строки и оператор индекса

Оператор индекса, применяемый к строке, возвращает байтовое значение (byte value), а не символ (как в других языках).

package main import "fmt" func main() < x := "text" fmt.Println(x[0]) // выводит 116 fmt.Printf("%T",x[0]) // выводит uint8 >

Если нужно обратиться к конкретным «символам» (кодовым точкам/рунам Unicode), то используйте выражение for range . Также вам будут полезны официальный пакет unicode/utf8 и экспериментальный utf8string (golang.org/x/exp/utf8string). utf8string включает в себя удобный метод At() . Можно также преобразовать строку в слайс рун (slice of runes).

19. Строки — не всегда текст в кодировке UTF-8

Строковые значения необязательно должны быть представлены в виде текста в кодировке UTF-8. Здесь возможен произвольный набор байтов. Единственный случай, когда строки должны быть в кодировке UTF-8, — когда они используются как строковые литералы. Но даже они могут включать в себя данные с экранированными последовательностями.

Чтобы узнать кодировку строки, используйте функцию ValidString() из пакета unicode/utf8.

package main import ( "fmt" "unicode/utf8" ) func main() < data1 := "ABC" fmt.Println(utf8.ValidString(data1)) // выводит: true data2 := "A\xfeC" fmt.Println(utf8.ValidString(data2)) // выводит: false >

20. Длина строк

Допустим, вы разрабатываете на Python и у вас есть такой код:

data = u'♥' print(len(data)) # выводит: 1 

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

package main import "fmt" func main() < data := "♥" fmt.Println(len(data)) // выводит: 3 >

Встроенная функция len() возвращает не символ, а количество байт, как это происходит с Unicode-строками в Python.

Чтобы получить такой же результат в Go, используйте функцию RuneCountInString() из пакета unicode/utf8.

package main import ( "fmt" "unicode/utf8" ) func main() < data := "♥" fmt.Println(utf8.RuneCountInString(data)) // выводит: 1 

Технически функция RuneCountInString() не возвращает количество символов, потому что один символ может занимать несколько рун.

package main import ( "fmt" "unicode/utf8" ) func main() < data := "é" fmt.Println(len(data)) // выводит: 3 fmt.Println(utf8.RuneCountInString(data)) // выводит: 2 >

21. Отсутствующая запятая в многострочных литералах slice/array/map

package main func main() < x := []int< 1, 2 // error >_ = x > 

/tmp/sandbox367520156/main.go:6: syntax error: need trailing comma before newline in composite literal /tmp/sandbox367520156/main.go:8: non-declaration statement outside function body /tmp/sandbox367520156/main.go:9: syntax error: unexpected > 

package main func main() < x := []int< 1, 2, >x = x y := []int // ошибки нет y = y > 

Вы не получите ошибку компилирования, если оставите замыкающую запятую при объявлении в одну строчку.

22. log.Fatal и log.Panic не только журналируют

Библиотеки для логирования часто обеспечивают различные уровни для сообщений. В отличие от других языков, пакет логирования в Go делает больше. Если вызвать его функции Fatal*() и Panic*() , то приложение будет закрыто.

package main import "log" func main() < log.Fatalln("Fatal Level: log entry") // здесь выполняется выход из приложения log.Println("Normal Level: log entry") >

23. Несинхронизированные операции встроенных структур данных

Некоторые возможности Go нативно поддерживают многозадачность (concurrency), но в их число не входят потокобезопасные коллекции (concurrency safe). Вы сами отвечаете за атомарность обновления коллекций. Для реализации атомарных операций рекомендуется использовать горутины и каналы, но можно задействовать и пакет sync, если это целесообразно для вашего приложения.

24. Итерационные значения для строк в выражениях range

Значение индекса (первое значение, возвращаемое операцией range ) — это индекс первого байта текущего «символа» (кодовая точка/руна Unicode), возвращённый во втором значении. Это не индекс текущего «символа», как в других языках. Обратите внимание, что настоящий символ может быть представлен несколькими рунами. Если вам нужно работать именно с символами, то стоит использовать пакет norm (golang.org/x/text/unicode/norm).

Выражения for range со строковыми переменными пытаются интерпретировать данные как текст в кодировке UTF-8. Если они не распознают какую-либо последовательность байтов, то возвращают руны 0xfffd (символы замены Unicode), а не реальные данные. Если в вашей строке хранятся произвольные данные (не UTF-8), то для сохранения преобразуйте их в байт-слайсы.

package main import "fmt" func main() < data := "A\xfe\x02\xff\x04" for _,v := range data < fmt.Printf("%#x ",v) >// выводит: 0x41 0xfffd 0x2 0xfffd 0x4 (нехорошо) fmt.Println() for _,v := range []byte(data) < fmt.Printf("%#x ",v) >// выводит: 0x41 0xfe 0x2 0xff 0x4 (хорошо) > 

25. Итерирование хеш-таблиц (map) с помощью выражения for range

На этот подводный камень натыкаются те, кто ожидают, что элементы будут располагаться в определённом порядке (например, отсортированные по значению ключа). Каждая итерация хеш-таблицы приводит к разным результатам. Среда исполнения (runtime) Go пытается сделать всё возможное, рандомизируя порядок итерирования, но ей это не всегда удаётся, поэтому вы можете получить несколько одинаковых итераций (например, пять) подряд.

package main import "fmt" func main() < m := map[string]intfor k,v := range m < fmt.Println(k,v) >> 

А если вы используете Go Playground (https://play.golang.org/), то всегда будете получать одинаковые результаты, потому что код не перекомпилируется, пока вы его не измените.

26. Сбойное поведение в выражениях switch

Блоки case в выражениях switch по умолчанию прерываются (break). В других языках поведение по умолчанию другое: переход (fall through) к следующему блоку case .

package main import "fmt" func main() < isSpace := func(ch byte) bool < switch(ch) < case ' ': // ошибка case '\t': return true >return false > fmt.Println(isSpace('\t')) // выводит true (хорошо) fmt.Println(isSpace(' ')) // выводит false (плохо) > 

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

package main import "fmt" func main() < isSpace := func(ch byte) bool < switch(ch) < case ' ', '\t': return true >return false > fmt.Println(isSpace('\t')) // выводит true (хорошо) fmt.Println(isSpace(' ')) // выводит true (хорошо) > 

27. Инкременты и декременты

Во многих языках есть операторы инкрементирования и декрементирования. Но в Go не поддерживаются их префиксные версии. Также нельзя в одном выражении использовать оба этих выражения.

package main import "fmt" func main() < data := []inti := 0 ++i // error fmt.Println(data[i++]) // ошибка > 

/tmp/sandbox101231828/main.go:8: syntax error: unexpected ++ /tmp/sandbox101231828/main.go:9: syntax error: unexpected ++, expecting : 

package main import "fmt" func main() < data := []inti := 0 i++ fmt.Println(data[i]) > 

28. Побитовый NOT-оператор

Во многих языках символ ~ используется в качестве унарной NOT-операции (aka побитовое дополнение, bitwise complement), однако в Go для этого применяется XOR-оператор (^).

package main import "fmt" func main() < fmt.Println(~2) // ошибка >

/tmp/sandbox965529189/main.go:6: the bitwise complement operator is ^ 

package main import "fmt" func main()

Кого-то может запутать, что ^ в Go — это XOR-оператор. Если хотите, выражайте унарную NOT-операцию (например, NOT 0x02 ) с помощью бинарной XOR-операции (например, 0x02 XOR 0xff ). Это объясняет, почему ^ используется для выражения унарной NOT-операции.

Также в Go есть специальный побитовый оператор AND NOT (&^), который легко принять за оператор NOT. AND NOT выглядит как специальная функция/хак ради поддержки A AND (NOT B) без обязательного использования фигурных скобок.

package main import "fmt" func main()

29. Различия приоритетов операторов

Помимо «довольно понятных» (bit clear) операторов (&^), в Go есть набор стандартных операторов, используемых многими другими языками. Но их приоритеты в данном случае не всегда такие же.

package main import "fmt" func main() < fmt.Printf("0x2 & 0x2 + 0x4 ->%#x\n",0x2 & 0x2 + 0x4) //prints: 0x2 & 0x2 + 0x4 -> 0x6 //Go: (0x2 & 0x2) + 0x4 //C++: 0x2 & (0x2 + 0x4) -> 0x2 fmt.Printf("0x2 + 0x2 %#x\n",0x2 + 0x2 << 0x1) //prints: 0x2 + 0x2 0x6 //Go: 0x2 + (0x2 << 0x1) //C++: (0x2 + 0x2) 0x8 fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n",0xf | 0x2 ^ 0x2) //prints: 0xf | 0x2 ^ 0x2 -> 0xd //Go: (0xf | 0x2) ^ 0x2 //C++: 0xf | (0x2 ^ 0x2) -> 0xf > 

30. Неэкспортированные поля структур не кодируются

Поля структур (struct fields), начинающиеся со строчных букв, не будут кодироваться (JSON, XML, GON и т. д.), так что при декодировании структуры вы получите в этих неэкспортированных полях нулевые значения.

package main import ( "fmt" "encoding/json" ) type MyData struct < One int two string >func main() < in := MyDatafmt.Printf("%#v\n",in) // выводит main.MyData encoded,_ := json.Marshal(in) fmt.Println(string(encoded)) // выводит var out MyData json.Unmarshal(encoded,&out) fmt.Printf("%#v\n",out) // выводит main.MyData > 

31. Выход из приложений с помощью активных горутин

Приложение не будет ждать завершения ваших горутин. Новички часто об этом забывают. Все когда-то начинают — в таких ошибках нет ничего стыдного.

package main import ( "fmt" "time" ) func main() < workerCount := 2 for i := 0; i < workerCount; i++ < go doit(i) >time.Sleep(1 * time.Second) fmt.Println("all done!") > func doit(workerId int)

[0] is running [1] is running all done! 

Одно из самых популярных решений — переменная WaitGroup . Это позволит главной горутине ожидать завершения работы всех рабочих горутин. Если ваше приложение использует долго выполняемые рабочие горутины с циклами обработки сообщений, то вам понадобится как-то сигнализировать им о том, что пора выходить. Можно отправлять каждой такой горутине сообщение kill . Или закрывать каналы, из которых рабочие горутины получают данные: это простой способ сигнализировать оптом.

package main import ( "fmt" "sync" ) func main() < var wg sync.WaitGroup done := make(chan struct<>) workerCount := 2 for i := 0; i < workerCount; i++ < wg.Add(1) go doit(i,done,wg) >close(done) wg.Wait() fmt.Println("all done!") > func doit(workerId int,done ,wg sync.WaitGroup)

Если запустить это приложение, вы увидите:

[0] is running [0] is done [1] is running [1] is done 

Похоже, все горутины закончили работать до выхода главной горутины. Замечательно! Однако вы увидите и это:

fatal error: all goroutines are asleep - deadlock! 

Нехорошо! Что происходит? Откуда взялась взаимоблокировка? Ведь все вышли и выполнили wg.Done() . Приложение должно работать.

Блокировка возникает, потому что каждый рабочий получает копию исходной переменной WaitGroup . И когда все они выполняют wg.Done() , это никак не влияет на переменную WaitGroup в главной горутине.

package main import ( "fmt" "sync" ) func main() < var wg sync.WaitGroup done := make(chan struct<>) wq := make(chan interface<>) workerCount := 2 for i := 0; i < workerCount; i++ < wg.Add(1) go doit(i,wq,done,&wg) >for i := 0; i < workerCount; i++ < wq close(done) wg.Wait() fmt.Println("all done!") > func doit(workerId int, wq ,done ,wg *sync.WaitGroup) < fmt.Printf("[%v] is running\n",workerId) defer wg.Done() for < select < case m := %v\n",workerId,m) case > > 

Теперь всё работает правильно.

32. При отправке в небуферизованный канал данные возвращаются по мере готовности получателя

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

package main import "fmt" func main() < ch := make(chan string) go func() < for m := range ch < fmt.Println("processed:",m) >>() ch 

33. Отправка в закрытый канал приводит к panic

Получение из закрытого канала безопасно. Возвращаемое значение ok в получаемом выражении (receive statement) станет false , что говорит о том, что никакие данные не были получены. Если вы получаете из буферизованного канала, то получите сначала буферизованные данные, а когда они закончатся, выражение ok станет false .

Отправка данных в закрытый канал приводит к panic. Это задокументированное поведение, но оно не всегда интуитивно ожидаемо разработчиками, которые могут считать, что поведение при отправке будет аналогично поведению при приёме.

package main import ( "fmt" "time" ) func main() < ch := make(chan int) for i := 0; i < 3; i++ < go func(idx int) < ch (i) > // get the first result fmt.Println( <-ch) close(ch) //нехорошо (у вас всё ещё есть другие отправители) // do other work time.Sleep(2 * time.Second) >

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

Пример с багом можно исправить, сигнализируя через специальный канал отмены (special cancellation channel) остальным рабочим горутинам, что их результаты больше не нужны.

package main import ( "fmt" "time" ) func main() < ch := make(chan int) done := make(chan struct<>) for i := 0; i < 3; i++ < go func(idx int) < select < case ch >(i) > // get first result fmt.Println("result:", <-ch) close(done) // do other work time.Sleep(3 * time.Second) >

34. Использование «nil»-каналов

В канале nil операции отправки и приёма блокируются навсегда. Это хорошо задокументированное поведение, но оно может стать сюрпризом для новичков.

package main import ( "fmt" "time" ) func main() < var ch chan int for i := 0; i < 3; i++ < go func(idx int) < ch (i) > // get first result fmt.Println("result:", <-ch) // do other work time.Sleep(2 * time.Second) >

При выполнении этого кода вы увидите ошибку runtime наподобие fatal error: all goroutines are asleep - deadlock!

Это поведение можно использовать для динамического включения и отключения блоков case в выражении select .

package main import "fmt" import "time" func main() < inch := make(chan int) outch := make(chan int) go func() < var in > >() go func() < for r := range outch < fmt.Println("result:",r) >>() time.Sleep(0) inch

35. Методы, принимающие параметры по значению, не меняют исходных значений

Параметры методов — это как обычные аргументы функций. Если они объявляются значением, то функция/метод получает копию вашего аргумента (receiver argument). Изменения в принятом значении не повлияют на исходное значение, если значение — переменная хеш-таблицы (map) или слайса и вы обновляете элементы коллекции или если обновляемые поля в значении — это указатели.

package main import "fmt" type data struct < num int key *string items map[string]bool >func (this *data) pmethod() < this.num = 7 >func (this data) vmethod() < this.num = 8 *this.key = "v.key" this.items["vmethod"] = true >func main() < key := "key.1" d := datafmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items) // prints num=1 key=key.1 items=map[] d.pmethod() fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items) // prints num=7 key=key.1 items=map[] d.vmethod() fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items) // prints num=7 key=v.key items=map[vmethod:true] > 

36. Закрытие тела HTTP-ответа

Делая запрос с помощью стандартной HTTP-библиотеки, вы получаете переменную HTTP-ответа. Даже если вы не читаете тело ответа, всё равно нужно его закрыть. Обратите внимание: это относится и к пустым ответам. О них очень легко забыть, особенно новичкам.

Некоторые новички пытаются закрывать тело ответа, но в неправильном месте.

package main import ( "fmt" "net/http" "io/ioutil" ) func main() < resp, err := http.Get("https://api.ipify.org?format=json") defer resp.Body.Close()// неправильно if err != nil < fmt.Println(err) return >body, err := ioutil.ReadAll(resp.Body) if err != nil < fmt.Println(err) return >fmt.Println(string(body)) > 

Этот код будет работать с успешными HTTP-запросами, но в случае сбоя переменная resp может быть nil , что приведёт к runtime panic.

Самый распространённый способ закрыть тело ответа — с помощью вызова defer после проверки ошибочности HTTP-ответа.

package main import ( "fmt" "net/http" "io/ioutil" ) func main() < resp, err := http.Get("https://api.ipify.org?format=json") if err != nil < fmt.Println(err) return >defer resp.Body.Close()// допустимо, в большинстве случаев :-) body, err := ioutil.ReadAll(resp.Body) if err != nil < fmt.Println(err) return >fmt.Println(string(body)) > 

В большинстве случаев, когда возникают сбои HTTP-запросов, переменная resp будет nil , а переменная err — non-nil . Но при сбое переадресации обе переменные будут non-nil . Это означает возникновение утечки.

Её можно предотвратить, добавив вызов для закрытия тел ответов non-nil в блоке обработки ошибок HTTP-запросов. Другое решение: использовать один вызов defer для закрытия тел ответов для всех сбойных и успешных запросов.

package main import ( "fmt" "net/http" "io/ioutil" ) func main() < resp, err := http.Get("https://api.ipify.org?format=json") if resp != nil < defer resp.Body.Close() >if err != nil < fmt.Println(err) return >body, err := ioutil.ReadAll(resp.Body) if err != nil < fmt.Println(err) return >fmt.Println(string(body)) > 

Исходная реализация resp.Body.Close() также считывает и отклоняет данные оставшихся тел ответов. Благодаря этому HTTP-соединение может быть повторно использовано для другого запроса, если включено поведение keep alive . Поведение самого последнего HTTP-клиента отличается. Теперь вы ответственны за чтение и отклонение оставшихся данных ответов. Если этого не сделать, то HTTP-соединение вместо повторного использования может быть закрыто. Надеюсь, этот маленький подводный камень будет задокументирован в Go 1.5.

Если для вашего приложения важно повторно использовать HTTP-соединения, то в конце логики обработки ответа может понадобиться добавить что-то вроде этого:

_, err = io.Copy(ioutil.Discard, resp.Body) 

Это будет необходимо, если вы не считываете всё тело ответа немедленно, например при обработке ответов JSON API с помощью подобного кода:

json.NewDecoder(resp.Body).Decode(&data) 

37. Закрытие HTTP-соединений

Некоторые HTTP-серверы какое-то время держат сетевые соединения открытыми (согласно спецификации HTTP 1.1 и серверной конфигурации keep alive ). По умолчанию стандартная HTTP-библиотека закрывает соединения, только когда об этом просит целевой HTTP-сервер. Тогда при определённых условиях в вашем приложении могут закончиться сокеты / файловые дескрипторы.

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

Другое решение: добавить заголовок запроса Connection и задать ему значение close . Целевой HTTP-сервер тоже должен ответить заголовком Connection: close . Когда библиотека его увидит, она закроет соединение.

package main import ( "fmt" "net/http" "io/ioutil" ) func main() < req, err := http.NewRequest("GET","http://golang.org",nil) if err != nil < fmt.Println(err) return >req.Close = true //or do this: //req.Header.Add("Connection", "close") resp, err := http.DefaultClient.Do(req) if resp != nil < defer resp.Body.Close() >if err != nil < fmt.Println(err) return >body, err := ioutil.ReadAll(resp.Body) if err != nil < fmt.Println(err) return >fmt.Println(len(string(body))) > 

Можно ещё глобально отключить повторное использование HTTP-соединений. Для этого создайте кастомную конфигурацию HTTP-транспорта.

package main import ( "fmt" "net/http" "io/ioutil" ) func main() < tr := &http.Transportclient := &http.Client resp, err := client.Get("http://golang.org") if resp != nil < defer resp.Body.Close() >if err != nil < fmt.Println(err) return >fmt.Println(resp.StatusCode) body, err := ioutil.ReadAll(resp.Body) if err != nil < fmt.Println(err) return >fmt.Println(len(string(body))) > 

Если вы отправляете на один сервер много запросов, то этого достаточно для сохранения соединения открытым. Но если приложение за короткое время шлёт один-два запроса на много разных серверов, то лучше закрывать соединения сразу после получения ответов. Также можно увеличить лимит на количество открытых файлов. Что лучше — зависит от вашего приложения.

38. Десериализация (unmarshalling) JSON-чисел в интерфейсные значения

Когда вы декодируете/десериализуете JSON-данные в интерфейс, Go по умолчанию обращается с числовыми значениями в JSON как с числами float64 . Значит, вот такой код вызовет panic:

package main import ( "encoding/json" "fmt" ) func main() < var data = []byte(``) var result map[string]interface<> if err := json.Unmarshal(data, &result); err != nil < fmt.Println("error:", err) return >var status = result["status"].(int) // ошибка fmt.Println("status value:",status) > 

panic: interface conversion: interface is float64, not int

Если JSON-значение, которое вы пытаетесь декодировать, целочисленное, есть несколько вариантов.

• Использовать значение с плавающей запятой как есть 🙂
• Преобразовать значение с плавающей запятой в целочисленный тип, который вам нужен.

package main import ( "encoding/json" "fmt" ) func main() < var data = []byte(``) var result map[string]interface<> if err := json.Unmarshal(data, &result); err != nil < fmt.Println("error:", err) return >var status = uint64(result["status"].(float64)) // хорошо fmt.Println("status value:",status) > 

package main import ( "encoding/json" "bytes" "fmt" ) func main() < var data = []byte(``) var result map[string]interface<> var decoder = json.NewDecoder(bytes.NewReader(data)) decoder.UseNumber() if err := decoder.Decode(&result); err != nil < fmt.Println("error:", err) return >var status,_ = result["status"].(json.Number).Int64() // хорошо fmt.Println("status value:",status) > 

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

package main import ( "encoding/json" "bytes" "fmt" ) func main() < var data = []byte(``) var result map[string]interface<> var decoder = json.NewDecoder(bytes.NewReader(data)) decoder.UseNumber() if err := decoder.Decode(&result); err != nil < fmt.Println("error:", err) return >var status uint64 if err := json.Unmarshal([]byte(result["status"].(json.Number).String()), &status); err != nil < fmt.Println("error:", err) return >fmt.Println("status value:",status) > 

package main import ( "encoding/json" "bytes" "fmt" ) func main() < var data = []byte(``) var result struct < Status uint64 `json:"status"` >if err := json.NewDecoder(bytes.NewReader(data)).Decode(&result); err != nil < fmt.Println("error:", err) return >fmt.Printf("result => %+v",result) //prints: result => > 

Это полезно, если вы должны выполнить декодирование условного JSON-поля (conditional field) в условиях возможности изменения структуры или типа поля.

package main import ( "encoding/json" "bytes" "fmt" ) func main() < records := [][]byte< []byte(``), []byte(``), > for idx, record := range records < var result struct < StatusCode uint64 StatusName string Status json.RawMessage `json:"status"` Tag string `json:"tag"` >if err := json.NewDecoder(bytes.NewReader(record)).Decode(&result); err != nil < fmt.Println("error:", err) return >var sstatus string if err := json.Unmarshal(result.Status, &sstatus); err == nil < result.StatusName = sstatus >var nstatus uint64 if err := json.Unmarshal(result.Status, &nstatus); err == nil < result.StatusCode = nstatus >fmt.Printf("[%v] result => %+v\n",idx,result) > > 

39. Сравнение struct, array, slice и map

Можно использовать оператор эквивалентности == для сравнения переменных структур, если каждое поле структуры можно сравнить с помощью этого оператора.

package main import "fmt" type data struct < num int fp float32 complex complex64 str string char rune yes bool events ref *byte raw [10]byte > func main() < v1 := data<>v2 := data<> fmt.Println("v1 == v2:",v1 == v2) // выводит: v1 == v2: true > 

Если хоть одно из полей несравниваемо, то применение оператора эквивалентности приведёт к ошибке компилирования. Обратите внимание, что сравнивать массивы можно только тогда, когда сравниваемы их данные.

package main import "fmt" type data struct < num int // ok checks [10]func() bool // несравниваемо doit func() bool // несравниваемо m map[string] string // несравниваемо bytes []byte // несравниваемо >func main() < v1 := data<>v2 := data<> fmt.Println("v1 == v2:",v1 == v2) > 

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

Самое популярное решение: использовать функцию DeepEqual() из пакета reflect.

package main import ( "fmt" "reflect" ) type data struct < num int // ok checks [10]func() bool // несравниваемо doit func() bool // несравниваемо m map[string] string // несравниваемо bytes []byte // несравниваемо >func main() < v1 := data<>v2 := data<> fmt.Println("v1 == v2:",reflect.DeepEqual(v1,v2)) // prints: v1 == v2: true m1 := map[string]string m2 := map[string]string fmt.Println("m1 == m2:",reflect.DeepEqual(m1, m2)) // prints: m1 == m2: true s1 := []int s2 := []int fmt.Println("s1 == s2:",reflect.DeepEqual(s1, s2)) // prints: s1 == s2: true > 

Помимо невысокой скорости (что может быть критично для вашего приложения), DeepEqual() имеет свои собственные подводные камни.

package main import ( "fmt" "reflect" ) func main() < var b1 []byte = nil b2 := []byte<>fmt.Println("b1 == b2:",reflect.DeepEqual(b1, b2)) // prints: b1 == b2: false > 

DeepEqual() не считает пустой слайс эквивалентным nil -слайсу. Это поведение отличается от того, что вы получите при использовании функции bytes.Equal() : она считает эквивалентными nil и пустые слайсы.

package main import ( "fmt" "bytes" ) func main() < var b1 []byte = nil b2 := []byte<>fmt.Println("b1 == b2:",bytes.Equal(b1, b2)) // prints: b1 == b2: true > 

DeepEqual() не всегда идеальна при сравнении слайсов.

package main import ( "fmt" "reflect" "encoding/json" ) func main() < var str string = "one" var in interface<>= "one" fmt.Println("str == in:",str == in,reflect.DeepEqual(str, in)) //prints: str == in: true true v1 := []string v2 := []interface<> fmt.Println("v1 == v2:",reflect.DeepEqual(v1, v2)) //prints: v1 == v2: false (not ok) data := map[string]interface<>< "code": 200, "value": []string, > encoded, _ := json.Marshal(data) var decoded map[string]interface<> json.Unmarshal(encoded, &decoded) fmt.Println("data == decoded:",reflect.DeepEqual(data, decoded)) //prints: data == decoded: false (not ok) > 

Если ваши байт-слайсы (или строки) содержат текстовые данные, то, когда понадобится сравнить значения без учёта регистра, вы можете использовать ToUpper() или ToLower() из пакетов bytes и strings (прежде чем прибегнуть к == , bytes.Equal() или bytes.Compare() ). Это сработает для англоязычных текстов, но не для многих других языков. Так что лучше выбрать strings.EqualFold() и bytes.EqualFold() .

Если ваши байт-слайсы содержат секретные данные (криптографические хеши, токены и т. д.), которые нужно сравнивать с предоставленной пользователями информацией, обойдитесь без reflect.DeepEqual() , bytes.Equal() или bytes.Compare() . Эти функции сделают приложение уязвимым к атакам по времени. Чтобы избежать утечки информации о времени, используйте функции из пакета crypto/subtle (например, subtle.ConstantTimeCompare() ).

40. Восстановление после panic

Функцию recover() можно использовать для поимки/перехвата panic. Это получится, только если вызвать её в блоке defer.

package main import "fmt" func main() < recover() // ничего не делает panic("not good") recover() // не будет выполнено :) fmt.Println("ok") >

package main import "fmt" func main() < defer func() < fmt.Println("recovered:",recover()) >() panic("not good") > 

Вызов recover() сработает, только если будет выполнен в блоке defer.

package main import "fmt" func doRecover() < fmt.Println("recovered =>",recover()) // prints: recovered => > func main() < defer func() < doRecover() // восстановление panic не произошло >() panic("not good") > 

41. Обновление и привязка значений полей в slice, array и map в выражениях for range

Сгенерированные в выражениях range значения данных — это копии реальных элементов коллекций, а не ссылки на исходные элементы. Стало быть, обновление значений не изменит исходные данные. Кроме того, если взять адрес значения, то вы не получите указатель на исходные данные.

package main import "fmt" func main() < data := []intfor _,v := range data < v *= 10 // оригинал не изменился >fmt.Println("data:",data) // выводит: [1 2 3] > 

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

package main import "fmt" func main() < data := []intfor i,_ := range data < data[i] *= 10 >fmt.Println("data:",data) // выводит: [10 20 30] > 

Если коллекция содержит значения указателей, то правила немного меняются. Вам всё ещё нужно использовать индексный оператор, чтобы исходная запись указывала на другое значение. Но вы можете обновлять данные, хранящиеся в целевом месте, с помощью второго значения в выражении for range .

package main import "fmt" func main() < data := []*struct,,> for _,v := range data < v.num *= 10 >fmt.Println(data[0],data[1],data[2]) // prints & & & > 

42. «Скрытые данные» в слайсах

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

package main import "fmt" func get() []byte < raw := make([]byte,10000) fmt.Println(len(raw),cap(raw),&raw[0]) // выводит: 10000 10000 return raw[:3] > func main() < data := get() fmt.Println(len(data),cap(data),&data[0]) // выводит: 3 10000 > 

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

package main import "fmt" func get() []byte < raw := make([]byte,10000) fmt.Println(len(raw),cap(raw),&raw[0]) // выводит: 10000 10000 res := make([]byte,3) copy(res,raw[:3]) return res > func main() < data := get() fmt.Println(len(data),cap(data),&data[0]) // выводит: 3 3 > 

43. «Повреждение» данных в слайсах

Допустим, вам нужно переписать путь (хранящийся в слайсе). Чтобы ссылаться на каждую папку, вы его перенарезаете, изменяя имя первой папки, а затем комбинируете имена в новый путь.

package main import ( "fmt" "bytes" ) func main() < path := []byte("AAAA/BBBBBBBBB") sepIndex := bytes.IndexByte(path,'/') dir1 := path[:sepIndex] dir2 := path[sepIndex+1:] fmt.Println("dir1 =>",string(dir1)) // выводит: dir1 => AAAA fmt.Println("dir2 =>",string(dir2)) // выводит: dir2 => BBBBBBBBB dir1 = append(dir1,"suffix". ) path = bytes.Join([][]byte,[]byte) fmt.Println("dir1 =>",string(dir1)) // выводит: dir1 => AAAAsuffix fmt.Println("dir2 =>",string(dir2)) // выводит: dir2 => uffixBBBB (not ok) fmt.Println("new path =>",string(path)) > 

Так не сработает. Вместо AAAAsuffix/BBBBBBBBB вы получите AAAAsuffix/uffixBBBB. Причина в том, что слайсы обеих папок ссылаются на один и тот же массив данных из исходного слайса пути. То есть исходный путь тоже изменился. Это может быть проблемой для вашего приложения.

Ее можно решить, разместив в памяти новые слайсы и скопировав туда нужные данные. Другой выход: использовать полное выражение слайса (full slice expression).

package main import ( "fmt" "bytes" ) func main() < path := []byte("AAAA/BBBBBBBBB") sepIndex := bytes.IndexByte(path,'/') dir1 := path[:sepIndex:sepIndex] // полное выражение слайса dir2 := path[sepIndex+1:] fmt.Println("dir1 =>",string(dir1)) // выводит: dir1 => AAAA fmt.Println("dir2 =>",string(dir2)) // выводит: dir2 => BBBBBBBBB dir1 = append(dir1,"suffix". ) path = bytes.Join([][]byte,[]byte) fmt.Println("dir1 =>",string(dir1)) // выводит: dir1 => AAAAsuffix fmt.Println("dir2 =>",string(dir2)) // выводит: dir2 => BBBBBBBBB (ok now) fmt.Println("new path =>",string(path)) > 

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

44. «Устаревшие» слайсы

На одни и те же данные могут ссылаться несколько слайсов. Например, когда вы создаёте новый слайс на основе имеющегося. Если такое поведение важно для вашего приложения, позаботьтесь об «устаревших» слайсах.

В какой-то момент добавление данных в один из слайсов приведёт к размещению в памяти нового массива, потому что в старом не хватит места для новых данных. Теперь на старый массив (со старыми данными) ссылаются несколько слайсов.

import "fmt" func main() < s1 := []intfmt.Println(len(s1),cap(s1),s1) // выводит 3 3 [1 2 3] s2 := s1[1:] fmt.Println(len(s2),cap(s2),s2) // выводит 2 2 [2 3] for i := range s2 < s2[i] += 20 >// всё ещё ссылается на тот же массив fmt.Println(s1) // выводит [1 22 23] fmt.Println(s2) // выводит [22 23] s2 = append(s2,4) for i := range s2 < s2[i] += 10 >//s1 is now "stale" fmt.Println(s1) // выводит [1 22 23] fmt.Println(s2) // выводит [32 33 14] > 

45. Методы и объявления типов

Когда вы определяете новый тип на основе существующего (не интерфейсного), тем самым вы создаёте объявление типа и не наследуете методы, объявленные в существующем типе.

package main import "sync" type myMutex sync.Mutex func main() < var mtx myMutex mtx.Lock() // ошибка mtx.Unlock() // ошибка >

/tmp/sandbox106401185/main.go:9: mtx.Lock undefined (type myMutex has no field or method Lock) /tmp/sandbox106401185/main.go:10: mtx.Unlock undefined (type myMutex has no field or method Unlock) 

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

package main import "sync" type myLocker struct < sync.Mutex >func main() < var lock myLocker lock.Lock() // ok lock.Unlock() // ok >

Объявления интерфейсных типов также сохраняют свои наборы методов.

package main import "sync" type myLocker sync.Locker func main() < var lock myLocker = new(sync.Mutex) lock.Lock() // ok lock.Unlock() // ok >

46. Как выбраться из кодовых блоков for switch и for select

• уровень: более опытный

package main import "fmt" func main() < loop: for < switch < case true: fmt.Println("breaking out. ") break loop >> fmt.Println("out!") > 

То же самое и с выражением goto …

47. Итерационные переменные и замыкания в выражениях for

Самая распространённая проблема в Go. Итерационные переменные в выражении for снова используются для каждой итерации. Это значит, что каждое замыкание (aka функциональный литерал), созданное в вашем цикле for , будет ссылаться на ту же переменную (и они получат значение переменной в тот момент, когда начнётся исполнение их горутин).

package main import ( "fmt" "time" ) func main() < data := []stringfor _,v := range data < go func() < fmt.Println(v) >() > time.Sleep(3 * time.Second) // горутины выводят: three, three, three > 

Простейшее решение (не требующее менять горутины): сохранить текущее значение итерационной переменной в локальной переменной внутри блока цикла for .

package main import ( "fmt" "time" ) func main() < data := []stringfor _,v := range data < vcopy := v // go func() < fmt.Println(vcopy) >() > time.Sleep(3 * time.Second) // горутины выводят: one, two, three > 

Другое решение: передать текущую итерационную переменную анонимной горутине в виде параметра.

package main import ( "fmt" "time" ) func main() < data := []stringfor _,v := range data < go func(in string) < fmt.Println(in) >(v) > time.Sleep(3 * time.Second) // горутины выводят: one, two, three > 

Здесь чуть более сложная версия ловушки.

package main import ( "fmt" "time" ) type field struct < name string >func (p *field) print() < fmt.Println(p.name) >func main() < data := []field,,> for _,v := range data < go v.print() >time.Sleep(3 * time.Second) // горутины выводят: three, three, three > 

package main import ( "fmt" "time" ) type field struct < name string >func (p *field) print() < fmt.Println(p.name) >func main() < data := []field,,> for _,v := range data < v := v go v.print() >time.Sleep(3 * time.Second) // горутины выводят: one, two, three > 

Как вы думаете, что вы увидите (и почему), запустив этот код?

package main import ( "fmt" "time" ) type field struct < name string >func (p *field) print() < fmt.Println(p.name) >func main() < data := []*field,,> for _,v := range data < go v.print() >time.Sleep(3 * time.Second) > 

48. Вычисление аргумента блока defer (Deferred Function Call Argument Evaluation)

Аргументы для вызовов отложенных функций вычисляются тогда же, когда и выражение defer (а не когда на самом деле выполняется функция).

package main import "fmt" func main() < var i int = 1 defer fmt.Println("result =>",func() int < return i * 2 >()) i++ //выводит: result => 2 (not ok if you expected 4) > 

49. Вызов блока defer

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

package main import ( "fmt" "os" "path/filepath" ) func main() < if len(os.Args) != 2 < os.Exit(-1) >start, err := os.Stat(os.Args[1]) if err != nil || !start.IsDir() < os.Exit(-1) >var targets []string filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error < if err != nil < return err >if !fi.Mode().IsRegular() < return nil >targets = append(targets,fpath) return nil >) for _,target := range targets < f, err := os.Open(target) if err != nil < fmt.Println("bad target:",target,"error:",err) //выводит ошибку: too many open files break >defer f.Close() // не будет закрыто в конце этого блока // сделай что-нибудь с файлом. > > 

Один из способов решения проблемы — обернуть кодовый блок в функцию.

package main import ( "fmt" "os" "path/filepath" ) func main() < if len(os.Args) != 2 < os.Exit(-1) >start, err := os.Stat(os.Args[1]) if err != nil || !start.IsDir() < os.Exit(-1) >var targets []string filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error < if err != nil < return err >if !fi.Mode().IsRegular() < return nil >targets = append(targets,fpath) return nil >) for _,target := range targets < func() < f, err := os.Open(target) if err != nil < fmt.Println("bad target:",target,"error:",err) return >defer f.Close() // ok // сделай что-нибудь с файлом. >() > > 

Другое решение: избавиться от выражения defer 🙂

50. Ошибки при приведении типов

Сбойные утверждения типов возвращают «нулевое значение» для целевых типов, использованных в операторе утверждения. Наложившись на сокрытие переменных, это может привести к непредсказуемому поведению.

package main import "fmt" func main() < var data interface<>= "great" if data, ok := data.(int); ok < fmt.Println("[is an int] value =>",data) > else < fmt.Println("[not an int] value =>",data) //выводит: [not an int] value => 0 (not "great") > > 

package main import "fmt" func main() < var data interface<>= "great" if res, ok := data.(int); ok < fmt.Println("[is an int] value =>",res) > else < fmt.Println("[not an int] value =>",data) // выводит: [not an int] value => great (as expected) > > 

51. Блокированные горутины и утечки ресурсов

В выступлении «Go Concurrency Patterns» на конференции Google I/O в 2012-м Роб Пайк рассказал о нескольких фундаментальных concurrency-шаблонах. Один из них — извлечение первого результата.

func First(query string, replicas . Search) Result < c := make(chan Result) searchReplica := func(i int) < c for i := range replicas < go searchReplica(i) >return

Для каждой копии (replica) поиска функция запускает отдельную горутину. Каждая из горутин отправляет свои поисковые результаты в канал результатов. Возвращается первое значение из канала.

А что с результатами от других горутин? И что насчёт них самих?

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

Чтобы этого избежать, все горутины должны завершиться (exit). Одно из возможных решений: использовать достаточно большой буферизованный канал результатов, способный вместить все результаты.

func First(query string, replicas . Search) Result < c := make(chan Result,len(replicas)) searchReplica := func(i int) < c for i := range replicas < go searchReplica(i) >return

Другое решение: использовать выражение select со сценарием (case) default и буферизованный канал на одно значение. Сценарий default позволяет быть уверенным, что горутина не застряла, даже если канал результатов не может принимать сообщения.

func First(query string, replicas . Search) Result < c := make(chan Result,1) searchReplica := func(i int) < select < case c > for i := range replicas < go searchReplica(i) >return

Также можно использовать специальный канал отмены (special cancellation channel) для прерывания рабочих горутин.

func First(query string, replicas . Search) Result < c := make(chan Result) done := make(chan struct<>) defer close(done) searchReplica := func(i int) < select < case c > for i := range replicas < go searchReplica(i) >return

Почему в презентации есть такие баги? Роб Пайк просто не хотел усложнять слайды (slides) своей презентации. Такое объяснение имеет смысл, но это может быть проблемой для новичков, которые используют код, не думая о вероятных проблемах.

52. Применение методов, принимающих значение по ссылке (pointer receiver), к экземплярам значений

Пока значение адресуемо (addressable), к нему можно применять метод, принимающий значение по ссылке. Иными словами, в некоторых случаях вам не нужно иметь версию метода, принимающего параметр по значению.

Но не каждая переменная адресуема. Элементы хеш-таблицы (map) неадресуемы. Переменные, на которые ссылаются через интерфейсы, тоже неадресуемы.

package main import "fmt" type data struct < name string >func (p *data) print() < fmt.Println("name:",p.name) >type printer interface < print() >func main() < d1 := datad1.print() //ok var in printer = data // ошибка in.print() m := map[string]data > m["x"].print() //ошибка > 

/tmp/sandbox017696142/main.go:21: cannot use data literal (type data) as type printer in assignment: data does not implement printer (print method has pointer receiver) /tmp/sandbox017696142/main.go:25: cannot call pointer method on m["x"] /tmp/sandbox017696142/main.go:25: cannot take the address of m["x"] 

53. Обновление полей значений в хеш-таблице

Если у вас есть таблица, состоящая из структур, то вы не можете обновлять отдельные структурные поля.

package main type data struct < name string >func main() < m := map[string]data > m["x"].name = "two" // error > 

/tmp/sandbox380452744/main.go:9: cannot assign to m["x"].name 

Это не работает, потому что элементы таблицы не адресуемы.

Новичков может дополнительно путать то, что элементы слайсов — адресуемы.

package main import "fmt" type data struct < name string >func main() < s := []data > s[0].name = "two" // ok fmt.Println(s) // prints: [] > 

Обратите внимание, что когда-то в одном из компиляторов (gccgo) можно было обновлять поля элементов таблицы. Но это быстро пофиксили 🙂 Также считалось, что такая возможность появится в Go 1.3. Но в то время это было не так важно, так что фича всё ещё висит в списке todo.

Первое обходное решение: использовать временную переменную.

package main import "fmt" type data struct < name string >func main() < m := map[string]data > r := m["x"] r.name = "two" m["x"] = r fmt.Printf("%v",m) //выводит: map[x:] > 

Второе обходное решение: использовать хеш-таблицу с указателями.

package main import "fmt" type data struct < name string >func main() < m := map[string]*data > m["x"].name = "two" //ok fmt.Println(m["x"]) //выводит: & > 

Кстати, что будет, если выполнить этот код?

package main type data struct < name string >func main() < m := map[string]*data > m["z"].name = "what?" //. > 

54. nil-интерфейсы и nil-интерфейсные значения

Это вторая по распространённости ловушка Go. Интерфейсы — не указатели, даже если они так выглядят. Интерфейсные переменные будут nil только тогда, когда их типы и поля значений будут nil .

Интерфейсный тип и поля значений заполняются на основе типа и значения переменной, использованной для создания соответствующей интерфейсной переменной. Если вы попытаетесь проверить, эквивалентна ли переменная nil , то это может привести к непредсказуемому поведению.

package main import "fmt" func main() < var data *byte var in interface<>fmt.Println(data,data == nil) // выводит: true fmt.Println(in,in == nil) // выводит: true in = data fmt.Println(in,in == nil) // выводит: false //'data' является 'nil', но 'in' — не 'nil' > 

Остерегайтесь этой ловушки, когда у вас есть функция, возвращающая интерфейсы.

package main import "fmt" func main() < doit := func(arg int) interface<> < var result *struct<>= nil if(arg > 0) < result = &struct<><> > return result > if res := doit(-1); res != nil < fmt.Println("good result:",res) // выводит: good result: // 'res' не является 'nil', но его значение — 'nil' > > 

package main import "fmt" func main() < doit := func(arg int) interface<> < var result *struct<>= nil if(arg > 0) < result = &struct<><> > else < return nil // возвращает явный 'nil' >return result > if res := doit(-1); res != nil < fmt.Println("good result:",res) >else < fmt.Println("bad result (res is nil)") // здесь — как и ожидалось >> 

55. Переменные стека и кучи

Не всегда известно, находится ли переменная в стеке или в куче. Если в С++ создать переменную с помощью оператора new , то она всегда будет в куче. В Go место размещения переменной выбирает компилятор, даже если используются функции new() или make() . Компилятор делает выбор на основании размера и результата «анализа локальности» (escape analysis). Это также означает, что можно возвращать ссылки на локальные переменные, что недопустимо в других языках, например в С и С++.

Если вы хотите знать, где находятся переменные, то передайте -gcflags -m в go build или go run (например, go run -gcflags -m app.go ).

56. GOMAXPROCS, согласованность (concurrency) и параллелизм

Go 1.4 и ниже используют только один тред контекста исполнения / ОС. Это значит, что в каждый момент времени может исполняться лишь одна горутина. Начиная с Go 1.5 количество контекстов исполнения стало равно количеству логических процессорных ядер, возвращаемому runtime.NumCPU() . Оно может не совпадать с общим количеством логических ядер в системе, в зависимости от настроек привязки CPU для процесса. Количество можно настроить, изменив переменную среды GOMAXPROCS или вызвав функцию runtime.GOMAXPROCS() .

Существует распространённое заблуждение, что GOMAXPROCS представляет собой количество процессоров, которые Go будет использовать для запуска горутин. Документация к функции runtime.GOMAXPROCS() только добавляет неразберихи. Но в описании к переменной GOMAXPROCS (https://golang.org/pkg/runtime/) говорится именно о тредах ОС.

Значение GOMAXPROCS может превышать количество ваших процессоров, верхний предел — 256.

package main import ( "fmt" "runtime" ) func main() < fmt.Println(runtime.GOMAXPROCS(-1)) // выводит: X (1 on play.golang.org) fmt.Println(runtime.NumCPU()) // выводит: X (1 on play.golang.org) runtime.GOMAXPROCS(20) fmt.Println(runtime.GOMAXPROCS(-1)) // выводит: 20 runtime.GOMAXPROCS(300) fmt.Println(runtime.GOMAXPROCS(-1)) // выводит: 256 >

57. Изменение порядка операций чтения и записи

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

package main import ( "runtime" "time" ) var _ = runtime.GOMAXPROCS(3) var a, b int func u1() < a = 1 b = 2 >func u2() < a = 3 b = 4 >func p() < println(a) println(b) >func main()

Если запустить этот код несколько раз, то можно увидеть такие комбинации переменных a и b :

1 2 3 4 0 2 0 0 1 4 

Самая интересная комбинация — 02 — говорит о том, что b была обновлена раньше a .

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

58. Диспетчеризация по приоритетам (Preemptive Scheduling)

Могут появляться разбойничьи (rogue) горутины, не дающие другим горутинам выполняться. Такое случается, если у вас есть цикл for , не позволяющий запустить диспетчер.

package main import "fmt" func main() < done := false go func()< done = true >() for !done < >fmt.Println("done!") > 

Цикл for не должен быть пустым. Проблема не исчезнет, пока в цикле содержится код, не запускающий исполнение диспетчера.

Он запускается после сборки мусора, выражений go , операций блокирования каналов, блокирующих системных вызовов и операций блокирования. Также он может работать, когда вызвана невстроенная (non-inlined) функция.

package main import "fmt" func main() < done := false go func()< done = true >() for !done < fmt.Println("not done!") // не встроена >fmt.Println("done!") > 

Чтобы узнать, встроена ли вызываемая вами в цикле функция, передайте -gcflags –m в go build или go run (например, go build -gcflags -m ).

Другое решение: явно вызвать диспетчер. Это можно сделать с помощью функции Gosched() из пакета runtime.

package main import ( "fmt" "runtime" ) func main() < done := false go func()< done = true >() for !done < runtime.Gosched() >fmt.Println("done!") > 

Если вы дочитали до конца и у вас есть комментарии или идеи, добро пожаловать в дискуссию на Reddit (и в комментарии здесь, на Хабре. — Примеч. пер.).

• Блог компании VK
• Программирование
• Совершенный код
• Go