⇐ Назад

О научном редакторе............................................................................................22
Предисловие.........................................................................................................23
Для кого предназначена эта книга...................................................................23
О чем эта книга...............................................................................................23
Как получить максимальную пользу от этой книги...........................................26
Загрузите файлы с примерами кода............................................................27
Где скачать цветные иллюстрации..............................................................27
Условные обозначения ..............................................................................27
От издательства..............................................................................................28
Глава 1. Go и операционная система...................................................................29
История Go......................................................................................................29
Куда движется Go?..........................................................................................30
Преимущества Go............................................................................................30
Идеален ли Go?..........................................................................................31
Утилита godoc.............................................................................................32
Компиляция Go-кода........................................................................................33
Выполнение Go-кода .......................................................................................34
Два правила Go...............................................................................................35
Правило пакетов Go: не нужен — не подключай.........................................35
Правильный вариант размещения фигурных скобок — всего один..............36
Как скачивать Go-пакеты.................................................................................37
Стандартные потоки UNIX: stdin, stdout и stderr...............................................39
Вывод результатов..........................................................................................39
Использование стандартного потока вывода...................................................41
Получение данных от пользователя.................................................................42
Что такое := и =.........................................................................................42
Чтение стандартного потока ввода.............................................................43
Работа с аргументами командной строки....................................................45
Вывод ошибок.................................................................................................47
Запись в журнальные файлы...........................................................................49
Уровни журналирования.............................................................................49
Средства журналирования..........................................................................50
Серверы журналов......................................................................................50
Пример Go-программы, которая записывает информацию
в журнальные файлы..................................................................................51
Функция log.Fatal()......................................................................................54
Функция log.Panic().....................................................................................54
Запись в специальный журнальный файл...................................................56
Вывод номеров строк в записях журнала....................................................58
Обработка ошибок в Go...................................................................................59
Тип данных error.........................................................................................59
Обработка ошибок......................................................................................61
Использование Docker.....................................................................................64
Упражнения и ссылки......................................................................................68
Резюме............................................................................................................69
Глава 2. Go изнутри............................................................................................70
Компилятор Go................................................................................................71
Сборка мусора.................................................................................................72
Трехцветный алгоритм................................................................................74
Подробнее о работе сборщика мусора Go...................................................78
Хеш-таблицы, срезы и сборщик мусора Go..................................................79
Небезопасный код......................................................................................82
Пакет unsafe...............................................................................................84
Еще один пример использования пакета unsafe..........................................84
Вызов C-кода из Go..........................................................................................86
Вызов C-кода из Go в одном файле.............................................................86
Вызов из Go C-кода в отдельных файлах....................................................87
C-код..........................................................................................................87
Go-код........................................................................................................88
Сочетание кода на Go и C...........................................................................89
Вызов Go-функций из C-кода...........................................................................90
Go-пакет.....................................................................................................90
C-код..........................................................................................................91
Ключевое слово defer......................................................................................92
Использование defer для журналирования..................................................95
Функции panic() и recover()..............................................................................97
Самостоятельное использование функции panic().......................................98
Две полезные UNIX-утилиты............................................................................99
Утилита strace...........................................................................................100
Утилита dtrace..........................................................................................101
Среда Go.......................................................................................................102
Команда go env..............................................................................................104
Go-ассемблер.................................................................................................105
Узловые деревья...........................................................................................106
Хотите знать больше о go build?....................................................................111
Создание кода WebAssembly..........................................................................113
Краткое введение в WebAssembly.............................................................113
Почему WebAssembly так важен................................................................113
Go и WebAssembly.....................................................................................114
Пример.....................................................................................................114
Использование сгенерированного кода WebAssembly................................115
Общие рекомендации по программированию на Go.......................................117
Упражнения и ссылки....................................................................................118
Резюме..........................................................................................................118
Глава 3. Работа с основными типами данных Go...............................................120
Числовые типы данных..................................................................................120
Целые числа.............................................................................................121
Числа с плавающей точкой.......................................................................121
Комплексные числа..................................................................................121
Числовые литералы в Go 2.......................................................................123
Циклы Go.......................................................................................................124
Цикл for....................................................................................................124
Цикл while................................................................................................125
Ключевое слово range..............................................................................125
Пример применения нескольких циклов Go...............................................125
Массивы в Go.................................................................................................127
Многомерные массивы..............................................................................128
Недостатки массивов Go...........................................................................130
Срезы в Go....................................................................................................131
Выполнение основных операций со срезами.............................................131
Автоматическое расширение срезов.........................................................133
Байтовые срезы........................................................................................135
Функция copy().........................................................................................135
Многомерные срезы..................................................................................137
Еще один пример использования срезов...................................................137
Сортировка срезов с помощью sort.Slice().................................................139
Добавление массива к срезу.....................................................................141
Хеш-таблицы Go............................................................................................142
Запись в хеш-таблицу со значением nil.....................................................144
Когда использовать хеш-таблицы.............................................................145
Константы Go ...............................................................................................145
Генератор констант iota............................................................................147
Указатели в Go..............................................................................................149
Зачем нужны указатели............................................................................152
Время и дата.................................................................................................152
Работа с временем....................................................................................153
Синтаксический анализ времени...............................................................154
Работа с датами........................................................................................156
Синтаксический анализ дат......................................................................156
Изменение формата даты и времени.........................................................157
Измерение времени выполнения программы..................................................159
Измерение скорости работы сборщика мусора Go.....................................160
Веб-ссылки и упражнения..............................................................................161
Резюме..........................................................................................................161
Глава 4. Использование составных типов данных..............................................163
Составные типы данных.................................................................................164
Структуры......................................................................................................164
Указатели на структуры............................................................................166
Ключевое слово new.................................................................................168
Кортежи........................................................................................................169
Регулярные выражения и сопоставление с образцом.....................................170
Немного теории........................................................................................171
Простой пример........................................................................................171
Более сложный пример.............................................................................174
Проверка IPv4-адресов.............................................................................176
Строки...........................................................................................................180
Что такое руны.........................................................................................183
Пакет unicode...........................................................................................184
Пакет strings.............................................................................................185
Оператор switch.............................................................................................189
Вычисление числа π с высокой точностью.....................................................192
Разработка на Go хранилища типа «ключ — значение».................................195
Go и формат JSON.........................................................................................200
Чтение данных из формата JSON..............................................................200
Сохранение данных в формате JSON.........................................................202
Использование функций Marshal() и Unmarshal()......................................203
Синтаксический анализ данных в формате JSON.......................................205
Go и XML...................................................................................................207
Чтение XML-файла....................................................................................210
Настройка вывода данных в формате XML................................................211
Go и формат YAML.........................................................................................213
Дополнительные ресурсы..............................................................................213
Упражнения...................................................................................................214
Резюме..........................................................................................................214
Глава 5. Как улучшить код Go с помощью структур данных...............................216
О графах и узлах...........................................................................................217
Сложность алгоритма....................................................................................217
Двоичные деревья в Go.................................................................................218
Реализация двоичного дерева в Go...........................................................219
Преимущества двоичных деревьев...........................................................221
Пользовательские хеш-таблицы в Go.............................................................222
Реализация пользовательской хеш-таблицы в Go.....................................222
Реализация функции поиска.....................................................................225
Преимущества пользовательских хеш-таблиц...........................................226
Связные списки в Go......................................................................................226
Реализация связного списка в Go..............................................................227
Преимущества связных списков................................................................231
Двусвязные списки в Go................................................................................231
Реализация двусвязного списка в Go........................................................232
Преимущества двусвязных списков...........................................................235
Очереди в Go.................................................................................................236
Реализация очереди в Go.........................................................................236
Стеки в Go.....................................................................................................239
Реализация стека в Go..............................................................................239
Пакет container..............................................................................................242
Использование пакета container/heap.......................................................242
Использование пакета container/list..........................................................245
Использование пакета container/ring.........................................................247
Генерация случайных чисел...........................................................................248
Генерация случайных строк......................................................................251
Генерация безопасной последовательности случайных чисел........................253
Выполнение матричных вычислений..............................................................255
Сложение и вычитание матриц.................................................................255
Умножение матриц...................................................................................258
Деление матриц........................................................................................261
Разгадывание головоломок судоку.................................................................267
Дополнительные ресурсы..............................................................................270
Упражнения...................................................................................................271
Резюме..........................................................................................................272
Глава 6. Неочевидные знания о пакетах и функциях Go....................................273
Что такое Go-пакеты......................................................................................274
Что такое функции Go...................................................................................274
Анонимные функции.................................................................................275
Функции, которые возвращают несколько значений.................................275
Функции, возвращающие именованные значения.....................................277
Функции, принимающие указатели...........................................................279
Функции, которые возвращают указатели.................................................280
Функции, которые возвращают другие функции.......................................281
Функции, которые принимают другие функции в качестве параметров.....282
Функции с переменным числом параметров..............................................283
Разработка Go-пакетов..................................................................................285
Компиляция Go-пакета.............................................................................287
Закрытые переменные и функции.............................................................287
Функция init()............................................................................................287
Go-модули.....................................................................................................290
Создание и использование Go-модулей.....................................................290
Использование двух версий одного и того же Go-модуля..........................298
Где хранятся Go-модули...........................................................................299
Команда go mod vendor............................................................................300
Как писать хорошие Go-пакеты......................................................................300
Пакет syscall..................................................................................................302
Как на самом деле работает fmt.Println()...................................................304
Пакеты go/scanner, go/parser и go/token.........................................................306
Пакет go/ast..............................................................................................307
Пакет go/scanner......................................................................................307
Пакет go/parser.........................................................................................309
Практический пример...............................................................................311
Поиск имен переменных заданной длины.................................................313
Шаблоны для текста и HTML..........................................................................318
Вывод простого текста..............................................................................318
Вывод текста в формате HTML..................................................................320
Дополнительные ресурсы..............................................................................327
Упражнения...................................................................................................328
Резюме..........................................................................................................328
Глава 7. Рефлексия и интерфейсы на все случаи жизни....................................330
Методы типов................................................................................................330
Интерфейсы в Go...........................................................................................332
Операции утверждения типа.....................................................................333
Как писать свои интерфейсы.........................................................................335
Использование интерфейса Go.................................................................336
Использование переключателей для интерфейсов
и типов данных.........................................................................................338
Рефлексия.....................................................................................................340
Простой пример рефлексии......................................................................340
Более сложный пример рефлексии...........................................................343
Три недостатка рефлексии.......................................................................345
Библиотека reflectwalk..............................................................................346
Объектно-ориентированное программирование на Go...................................348
Основы git и GitHub.......................................................................................351
Использование git.....................................................................................351
Отладка с помощью Delve..............................................................................357
Пример отладки........................................................................................358
Дополнительные ресурсы..............................................................................362
Упражнения...................................................................................................362
Резюме..........................................................................................................362
Глава 8. Как объяснить UNIX-системе, что она должна делать..........................364
О процессах в UNIX.......................................................................................365
Пакет flag......................................................................................................365
Пакет viper....................................................................................................370
Простой пример использования viper........................................................371
От flag к viper............................................................................................372
Чтение конфигурационных файлов в формате JSON.................................373
Чтение конфигурационных файлов в формате YAML.................................375
Пакет cobra....................................................................................................377
Простой пример cobra...............................................................................378
Создание псевдонимов команд.................................................................382
Интерфейсы io.Reader и io.Writer...................................................................385
Буферизованный и небуферизованный ввод и вывод в файл ...................385
Пакет bufio....................................................................................................386
Чтение текстовых файлов..............................................................................386
Построчное чтение текстового файла.......................................................386
Чтение текстового файла по словам.........................................................388
Посимвольное чтение текстового файла...................................................390
Чтение из /dev/random..............................................................................392
Чтение заданного количества данных............................................................393
Преимущества двоичных форматов...............................................................395
Чтение CSV-файлов.......................................................................................396
Запись в файл...............................................................................................399
Загрузка и сохранение данных на диске........................................................401
И снова пакет strings.....................................................................................404
Пакет bytes....................................................................................................406
Полномочия доступа к файлам......................................................................407
Обработка сигналов в UNIX...........................................................................408
Обработка двух сигналов..........................................................................409
Обработка всех сигналов..........................................................................411
Программирование UNIX-каналов на Go.........................................................413
Реализация утилиты cat(1) на Go..............................................................414
Структура syscall.PtraceRegs...........................................................................416
Отслеживание системных вызовов.................................................................418
Идентификаторы пользователя и группы.......................................................422
Docker API и Go.............................................................................................423
Дополнительные ресурсы..............................................................................426
Упражнения...................................................................................................427
Резюме..........................................................................................................428
Глава 9. Конкурентность в Go: горутины, каналы и конвейеры.........................429
О процессах, потоках и горутинах.................................................................430
Планировщик Go.......................................................................................430
Конкурентность и параллелизм.................................................................431
Горутины.......................................................................................................431
Создание горутины...................................................................................432
Создание нескольких горутин...................................................................433
Как дождаться завершения горутин, прежде чем закончить
программу.....................................................................................................435
Что происходит, если количество вызовов Add() и Done()
не совпадает.............................................................................................437
Каналы..........................................................................................................439
Запись в канал..........................................................................................439
Чтение из канала......................................................................................440
Прием данных из закрытого канала..........................................................442
Каналы как аргументы функции................................................................443
Конвейеры.....................................................................................................444
Состояние гонки............................................................................................447
Сравнение моделей конкурентности в Go и Rust............................................449
Сравнение моделей конкурентности в Go и Erlang.........................................449
Дополнительные ресурсы..............................................................................450
Упражнения...................................................................................................450
Резюме..........................................................................................................451
Глава 10. Конкурентность в Go: расширенные возможности.............................452
И снова о планировщике Go..........................................................................453
Переменная среды GOMAXPROCS..............................................................455
Ключевое слово select...................................................................................456
Принудительное завершение горутины..........................................................459
Принудительное завершение горутины, способ 1......................................459
Принудительное завершение горутины, способ 2......................................461
И снова о Go-каналах....................................................................................463
Сигнальные каналы..................................................................................464
Буферизованные каналы..........................................................................464
Нулевые каналы.......................................................................................466
Каналы каналов........................................................................................467
Выбор последовательности исполнения горутин.......................................470
Как не надо использовать горутины..........................................................472
Общая память и общие переменные..............................................................473
Тип sync.Mutex..........................................................................................474
Тип sync.RWMutex.....................................................................................478
Пакет atomic.............................................................................................481
Совместное использование памяти с помощью горутин............................483
И снова об операторе go................................................................................485
Распознавание состояния гонки.....................................................................488
Пакет context.................................................................................................493
Расширенный пример использования пакета context.................................497
Еще один пример использования пакета context.......................................502
Пулы обработчиков..................................................................................503
Дополнительные ресурсы..............................................................................508
Упражнения...................................................................................................508
Резюме..........................................................................................................509
Глава 11. Тестирование, оптимизация и профилирование кода..........................510
Оптимизация.................................................................................................511
Оптимизация кода Go....................................................................................512
Профилирование кода Go..............................................................................513
Стандартный Go-пакет net/http/pprof........................................................513
Простой пример профилирования.............................................................513
Удобный внешний пакет для профилирования..........................................521
Веб-интерфейс Go-профилировщика.........................................................523
Утилита go tool trace......................................................................................527
Тестирование кода Go...................................................................................532
Написание тестов для существующего кода Go.........................................532
Тестовое покрытие кода...........................................................................536
Тестирование HTTP-сервера с базой данных..................................................539
Пакет testing/quick....................................................................................545
Бенчмаркинг кода Go.....................................................................................551
Простой пример бенчмаркинга......................................................................552
Неправильно определенные функции бенчмаркинга.................................557
Бенчмаркинг буферизованной записи............................................................558
Обнаружение недоступного кода Go..............................................................562
Кросс-компиляция.........................................................................................564
Создание примеров функций.........................................................................565
От кода Go до машинного кода......................................................................567
Использование ассемблера в Go...............................................................568
Генерация документации...............................................................................570
Использование образов Docker......................................................................575
Дополнительные ресурсы..............................................................................577
Упражнения...................................................................................................578
Резюме..........................................................................................................579
Глава 12. Основы сетевого программирования на Go........................................580
Что такое net/http, net и http.RoundTripper.....................................................581
Тип http.Response.....................................................................................581
Тип http.Request.......................................................................................582
Тип http.Transport.....................................................................................582
Что такое TCP/IP............................................................................................583
Что такое IPv4 и IPv6.....................................................................................584
Утилита командной строки nc(1)....................................................................584
Чтение конфигурации сетевых интерфейсов..................................................585
Выполнение DNS-поиска................................................................................589
Получение NS-записей домена..................................................................591
Получение MX-записей домена.................................................................593
Создание веб-сервера на Go..........................................................................594
Использование пакета atomic....................................................................597
Профилирование HTTP-сервера................................................................599
Создание веб-сайта на Go.........................................................................604
HTTP-трассировка..........................................................................................613
Тестирование HTTP-обработчиков............................................................616
Создание веб-клиента на Go..........................................................................618
Как усовершенствовать наш веб-клиент Go..............................................620
Задержки HTTP-соединений...........................................................................623
Подробнее о SetDeadline...........................................................................625
Установка периода ожидания на стороне сервера....................................625
Еще один способ определить период ожидания........................................627
Инструменты Wireshark и tshark.....................................................................629
Go и gRPC......................................................................................................629
Определение файла описания интерфейса...............................................629
gRPC-клиент.............................................................................................632
gRPC-сервер.............................................................................................633
Дополнительные ресурсы..............................................................................635
Упражнения...................................................................................................636
Резюме..........................................................................................................637
Глава 13. Сетевое программирование: создание серверов и клиентов..............638
Работа с HTTPS-трафиком..............................................................................639
Создание сертификатов............................................................................639
HTTPS-клиент...........................................................................................640
Простой HTTPS-сервер..............................................................................642
Разработка TLS-сервера и TLS-клиента.....................................................643
Стандартный Go-пакет net.............................................................................646
TCP-клиент....................................................................................................646
Другая версия TCP-клиента......................................................................648
TCP-сервер....................................................................................................650
Другая версия TCP-сервера.......................................................................652
UDP-клиент....................................................................................................654
Разработка UDP-сервера................................................................................656
Конкурентный TCP-сервер.............................................................................658
Удобный конкурентный TCP-сервер..........................................................662
Создание образа Docker для TCP/IP-сервера на Go........................................668
Дистанционный вызов процедур....................................................................670
RPC-клиент...............................................................................................671
RPC-сервер...............................................................................................672
Низкоуровневое сетевое программирование..................................................674
Получение необработанных сетевых данных ICMP....................................676
Дополнительные ресурсы..............................................................................680
Упражнения...................................................................................................681
Резюме..........................................................................................................682
Глава 14. Машинное обучение на Go................................................................683
Вычисление простых статистических показателей.........................................684
Регрессия......................................................................................................688
Линейная регрессия..................................................................................688
Реализация линейной регрессии...............................................................688
Вывод данных...........................................................................................690
Классификация..............................................................................................694
Кластеризация...............................................................................................698
Выявление аномалий.....................................................................................700
Нейронные сети.............................................................................................702
Анализ выбросов...........................................................................................704
Работа с TensorFlow.......................................................................................707
Поговорим о Kafka.........................................................................................712
Дополнительные ресурсы..............................................................................716
Упражнения...................................................................................................717
Резюме..........................................................................................................717
Что дальше?.......................................................................................................718

Оглавление