Программирование на Go. Разработка приложений XXI века

Программирование на Go

Разработка приложений XXI века

Марк Саммерфильд

Programming in Go:

Creating Applications 
for the 21st Century

Mark Summerfield

Москва, 2023

Программирование на Go

Разработка приложений XXI века

Марк Саммерфильд

2-е издание, электронное

УДК 004.438Go
ББК 32.973.26-018.1

С17

С17
Саммерфильд, Марк.
Программирование на Go. Разработка приложений XXI века / М. Сам-
мерфильд ; пер. с англ. А. Н. Киселёва. — 2-е изд., эл. — 1 файл pdf : 581 с. — 
Москва : ДМК Пресс, 2023. — Систем. требования: Adobe Reader XI либо 
Adobe Digital Editions 4.5 ; экран 10». — Текст : электронный.
ISBN 978-5-89818-611-1

На сегодняшний день Go — самый впечатляющий из новых языков программирования. 
Изначально он создавался для того, чтобы помочь задействовать всю мощь 
современных многоядерных процессоров. В этом руководстве Марк Саммерфильд, 
один из основоположников программирования на языке Go, показывает, как писать 
программы, в полной мере использующие его революционные возможности и идиомы.
Данная книга представляет собой одновременно и учебник, и справочник, сводя 
воедино все знания, необходимые для того, чтобы продолжать освоение Go, думать 
на Go и писать на нем высокопроизводительные программы. Автор приводит множество 
сравнений идиом программирования, демонстрируя преимущества Go перед 
более старыми языками и уделяя особое внимание ключевым инновациям. Попутно, 
начиная с самых основ, Марк Саммерфильд разъясняет все аспекты параллельного 
программирования на языке Go с применением каналов и без использования блокировок, 
а также показывает гибкость и необычность подхода к объектно-ориентированному 
программированию с применением механизма динамической типизации.
Издание предназначено для программистов разной квалификации, желающих 
освоить и применять в своей практике язык Go.

УДК 004.438Go 
ББК 32.973.26-018.1

Электронное издание на основе печатного издания: Программирование на Go. Разработка 
приложений XXI века / М. Саммерфильд ; пер. с англ. А. Н. Киселёва. — Москва : ДМК Пресс, 
2016. — 580 с. — ISBN 978-5-97060-338-3. — Текст : непосредственный.

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

В соответствии со ст. 1299 и 1301 ГК РФ при устранении ограничений, установленных техническими средствами 
защиты авторских прав, правообладатель вправе требовать от нарушителя возмещения убытков или выплаты компенсации.


ISBN 978-5-89818-611-1
© Copyright Qtrac Ltd. 
© Оформление, ДМК Пресс, 2016

Содержание

Введение ........................................................ 11

Зачем изучать язык Go? ...................................................... 12

Структура книги .................................................................. 16

Благодарности ................................................................... 17

1. Обзор в пяти примерах ................................... 19

1.1. Начало ......................................................................... 19

1.2. Правка, компиляция и запуск ....................................... 22

1.3. Hello кто? ...................................................................... 28

1.4. Большие цифры – двумерные срезы ............................ 32

1.5. Стек – пользовательские типы данных с методами ....... 38

1.6. Американизация – файлы, отображения и замыкания ......49

1.7. Из полярных координат в декартовы – 
параллельное программирование ...................................... 65

1.8. Упражнение .................................................................. 74

2. Логические значения и числа .......................... 76

2.1. Начальные сведения .................................................... 76
2.1.1. Константы и переменные ...................................... 78

2.2. Логические значения и выражения ............................... 83

2.3. Числовые типы ............................................................. 84
2.3.1. Целочисленные типы ............................................ 87
2.3.2. Вещественные типы.............................................. 93

Содержание

2.4. Пример: statistics ........................................................ 103
2.4.1. Реализация простых статистических функций ...... 104
2.4.2. Реализация простого HTTP-сервера ................... 106

2.5. Упражнения ................................................................ 111

3. Строки ....................................................... 113

3.1. Литералы, операторы и экранированные 
последовательности ......................................................... 115

3.2. Сравнение строк ........................................................ 117

3.3. Символы и строки ...................................................... 121

3.4. Индексирование и получение срезов строк ................ 124

3.5. Форматирование строк с помощью пакета fmt ........... 128
3.5.1. Форматирование логических значений ............... 134
3.5.2. Форматирование целочисленных значений ........ 134
3.5.3. Форматирование символов ................................ 136
3.5.4. Форматирование вещественных значений .......... 137
3.5.5. Форматирование строк и срезов ........................ 139
3.5.6. Форматирование для отладки ............................. 141

3.6. Другие пакеты для работы со строками ...................... 145
3.6.1. Пакет strings ....................................................... 145
3.6.2. Пакет strconv ....................................................... 153
3.6.3. Пакет utf8 ............................................................ 158
3.6.4. Пакет unicode ...................................................... 160
3.6.5. Пакет regexp ....................................................... 161

3.7. Пример: m3u2pls ........................................................ 173

3.8. Упражнения ................................................................ 180

4. Типы коллекций .......................................... 183

4.1. Значения, указатели и ссылочные типы ...................... 184

4.2. Массивы и срезы........................................................ 195
4.2.1. Индексирование срезов и извлечение 
срезов из срезов .......................................................... 201

4.2.2. Итерации по срезам ........................................... 202
4.2.3. Изменение срезов .............................................. 204
4.2.4. Сортировка и поиск по срезам ............................ 209

4.3. Отображения ............................................................. 214
4.3.1. Создание и заполнение отображений ................. 216
4.3.2. Поиск в отображениях ........................................ 219
4.3.3. Изменение отображений .................................... 220
4.3.4. Итерации по отображениям 
с упорядоченными ключами ......................................... 221
4.3.5. Инвертирование отображений ............................ 222

4.4. Примеры .................................................................... 223
4.4.1. Пример: угадай разделитель .............................. 223
4.4.2. Пример: частота встречаемости слов ................. 226

4.5. Упражнения ................................................................ 234

5. Процедурное программирование ................... 238

5.1. Введение в инструкции .............................................. 238
5.1.1. Преобразование типа ......................................... 243
5.1.2. Приведение типов .............................................. 245

5.2. Ветвление .................................................................. 247
5.2.1. Инструкция if ...................................................... 247
5.2.2. Инструкция switch ............................................... 249

5.3. Инструкция цикла for .................................................. 259

5.4. Инструкции организации взаимодействий 
и параллельного выполнения ............................................ 263
5.4.1. Инструкция select ............................................... 267

5.5. Инструкция defer и функции panic() и recover() ........... 272
5.5.1. Функции panic() и recover() ................................. 273

5.6. Пользовательские функции ........................................ 281
5.6.1. Аргументы функций ............................................ 283
5.6.2. Функции init() и main() ......................................... 287
5.6.3. Замыкания .......................................................... 289
5.6.4. Рекурсивные функции ......................................... 291

Содержание

Содержание

5.6.5. Выбор функции во время выполнения ................. 295
5.6.6. Обобщенные функции......................................... 298
5.6.7. Функции высшего порядка .................................. 305

5.7. Пример: сортировка с учетом отступов ...................... 312

5.8. Упражнения ................................................................ 319

6. Объектно-ориентированное программирование .. 322

6.1. Ключевые понятия ...................................................... 323

6.2. Пользовательские типы .............................................. 326
6.2.1. Добавление методов .......................................... 328
6.2.2. Типы с проверкой ................................................ 334

6.3. Интерфейсы ............................................................... 336
6.3.1. Встраивание интерфейсов ................................. 343

6.4. Структуры .................................................................. 348
6.4.1. Структуры: агрегирование и встраивание ........... 349

6.5. Примеры .................................................................... 357
6.5.1. Пример: FuzzyBool – пользовательский тип 
с единственным значением .......................................... 357
6.5.2. Пример: фигуры – семейство пользовательских 
типов ............................................................................ 365
6.5.3. Пример: упорядоченное отображение – 
обобщенный тип коллекций ......................................... 381

6.6. Упражнения ................................................................ 392

7. Параллельное программирование ................. 397

7.1. Ключевые понятия ...................................................... 399

7.2. Примеры .................................................................... 406
7.2.1. Пример: фильтр .................................................. 407
7.2.2. Пример: параллельный поиск ............................. 412
7.2.3. Пример: поточно-ориентированное 
отображение ................................................................ 422
7.2.4. Пример: отчет о работе веб-сервера .................. 430
7.2.5. Пример: поиск дубликатов .................................. 441

7.3. Упражнения ................................................................ 451

8. Обработка файлов ....................................... 455

8.1. Файлы с пользовательскими данными ....................... 455
8.1.1. Обработка файлов в формате JSON .................... 460
8.1.2. Обработка файлов в формате XML ...................... 467
8.1.3. Обработка простых текстовых файлов ................ 475
8.1.4. Обработка файлов в двоичном формате Go ........ 484
8.1.5. Обработка файлов в пользовательском 
двоичном формате ....................................................... 488

8.2. Архивные файлы ........................................................ 499
8.2.1. Создание zip-архивов ......................................... 499
8.2.2. Создание тарболлов ........................................... 502
8.2.3. Распаковывание zip-архивов .............................. 504
8.2.4. Распаковывание тарболлов ................................ 506

8.3. Упражнения ................................................................ 509

9. Пакеты ...................................................... 512

9.1. Пользовательские пакеты .......................................... 512
9.1.1. Создание пользовательских пакетов .................. 513
9.1.2. Импортирование пакетов ................................... 523

9.2. Сторонние пакеты ...................................................... 524

9.3. Краткий обзор команд компилятора Go ...................... 525

9.4. Краткий обзор стандартной библиотеки языка Go ...... 526
9.4.1. Пакеты для работы с архивами 
и сжатыми файлами ..................................................... 527
9.4.2. Пакеты для работы с байтами и строками ........... 527
9.4.3. Пакеты для работы с коллекциями ...................... 529
9.4.4. Пакеты для работы с файлами и ресурсами 
операционной системы ................................................ 532
9.4.5. Пакеты для работы с графикой ........................... 534
9.4.6. Математические пакеты ..................................... 534
9.4.7. Различные пакеты ............................................... 535
9.4.8. Пакеты для работы с сетью ................................. 536
9.4.9. Пакет reflect ........................................................ 537

9.5. Упражнения ................................................................ 541

Содержание

Содержание

A. Эпилог ...................................................... 545

B. Опасность патентов 
на программное обеспечение ........................... 548

C. Список литаратуры ..................................... 553

Предметный указатель .................................... 556

Эта книга посвящается 
Жасмин Бланшетт (Jasmin Blanchette) и Трентону Шульцу (Trenton 
Schulz)

Введение

Цель этой книги – научить специфике программирования на языке 
Go с использованием всех его характерных особенностей, а также 
рассказать о наиболее часто применяемых пакетах, входящих в состав 
стандартной библиотеки Go. Книга также задумывалась как 
справочник для тех, кто уже знаком с языком. Чтобы соответствовать 
этим двум целям, была сделана попытка охватить сразу все 
темы в одной книге, и в текст были добавлены перекрестные ссылки.
По духу Go подобен языку C – это компактный и эффективный 
язык программирования с низкоуровневыми возможностями, такими 
как указатели. Однако Go обладает множеством особенностей, 
характерных для высоко- и очень высокоуровневых языков, таких 
как поддержка строк Юникода, высокоуровневые структуры данных, 
динамическая типизация, автоматическая сборка мусора и высокоуровневая 
поддержка взаимодействий, основанных на обмене 
сообщениями, а не на блокировках и разделяемых данных. Кроме 
того, язык Go имеет обширную и всестороннюю стандартную библиотеку.

Предполагается, что читатель уже имеет опыт программирования 
на распространенных языках, таких как C, C++, Java, Python и 
им подобных, тем не менее все уникальные особенности и идиомы 
языка Go демонстрируются на законченных, работающих примерах, 
подробно описываемых в тексте.
Для успешного освоения любого языка программирования совершенно 
необходимо писать программы на этом языке. С этой 
точки зрения в книге предпринят абсолютно практический подход: 
читателям предлагается не бояться экспериментировать с примерами, 
выполнять предлагаемые упражнения и писать собственные 
программы, чтобы обрести практический опыт. Как и во всех моих 
предыдущих книгах, все фрагменты программного кода являются 
«живым кодом», то есть этот код автоматически извлекался из исходных 
файлов .go и вставлялся в документ PDF перед передачей 
издателю, поэтому все примеры гарантированно работоспособны и 

Введение

в них исключены ошибки, возможные при копировании вручную. 
Везде, где только возможно, в качестве примеров демонстрируются 
небольшие, но законченные программы и пакеты. Все примеры, 
упражнения и решения доступны на сайте www.qtrac.eu/gobook.html .
Основной целью книги является обучение языку Go, здесь рассказывается 
о многих пакетах из стандартной библиотеки Go, но 
далеко не обо всех. Однако в этом нет никакой проблемы, поскольку 
книга дает достаточный объем информации о Go, чтобы читатель 
смог самостоятельно использовать любые стандартные или сторонние 
пакеты и конечно же создавать собственные.

Зачем изучать язык Go?

Разработка языка Go началась в 2007 году как внутренний проект 
компании Google. Оригинальная архитектура языка была разработана 
Робертом Гризмером (Robert Griesemer) и корифеями ОС Unix – 
Робом Пайком (Rob Pike) и Кеном Томпсоном (Ken Thompson) . 10 
ноября 2009 года были опубликованы исходные тексты реализации 
языка Go под либеральной открытой лицензией. Развитие языка Go 
продолжается группой разработчиков из компании Google, в состав 
которой входят основатели языка, а также Расс Кокс (Russ Cox), Эндрю 
Джерранд (Andrew Gerrand), Ян Ланс Тейлор (Ian Lance Taylor)  
и многие другие. Разработка ведется с использованием открытой 
модели, благодаря чему в процессе участвуют многие разработчики 
со всего мира, порой настолько известные и уважаемые, что им 
предоставлены те же привилегии доступа к репозиторию с исходными 
текстами, что и специалистам из компании Google. Кроме того, 
в общественном доступе имеется множество сторонних пакетов для 
языка Go, доступных на сайте Go Dashboard (godashboard.appspot.
com/project).
Go – один из самых удивительных языков, появившихся в последние 
15 лет, и первый, нацеленный на программистов и компьютеры 
XXI века.
Go проектировался с прицелом на эффективное масштабирование, 
благодаря чему его можно использовать для создания очень 
больших приложений и компиляции даже очень больших программ 
за секунды на единственном компьютере. Молниеносная скорость 
компиляции обеспечивается отчасти простотой синтаксического 
анализа программ на этом языке, но главным образом благодаря особенностям 
управления зависимостями. Например, если файл app.

Зачем изучать язык Go?

go зависит от файла pkg1.go, который, в свою очередь, зависит от 
файла pkg2.go, в обычных компилирующих языках для компиляции 
файла app.go необходимо иметь объектные модули, полученные в 
результате компиляции обоих файлов, pkg1.go и pkg2.go. Но в Go 
все, что экспортирует pkg2.go, включено в объектный модуль для 
файла pkg1.go, поэтому для компиляции app.go достаточно иметь 
только объектный модуль для файла pkg1.go. Для случая с тремя 
файлами это едва ли имеет большое значение, но в огромных приложениях 
с большим количеством зависимостей эта особенность дает 
весьма значительный прирост скорости компиляции.
Благодаря высокой скорости компиляции программ на языке Go 
появляется возможность использовать этот язык в областях, где 
обычно применяются языки сценариев (см. врезку «Сценарии на 
языке Go» ниже). Кроме того, язык Go можно использовать для 
создания веб-приложений с применением Google App Engine.
Язык Go имеет очень простой и понятный синтаксис, в котором 
отсутствуют сложные и замысловатые конструкции, характерные 
для более старых языков, таких как C++ (появившегося в 1983 году) 
или Java (появившегося в 1995 году). И относится к категории языков 
со строгой статической типизацией, что многими программистами 
считается важным условием для разработки крупных программ. 
Однако система типов данных в языке Go не слишком обременительна 
благодаря поддержке синтаксиса объявления переменных 
одновременно с их инициализацией (когда компилятор определяет 
тип автоматически, избавляя от необходимости явно указывать его) 
и наличию мощного и удобного механизма динамической типизации.
Языки программирования, такие как C и C++, требуют от программистов 
выполнения массы работы, когда дело доходит до управления 
памятью, которую можно переложить на плечи компьютера, 
особенно в многопоточных приложениях, где учет использования 
динамической памяти может оказаться невероятно сложной задачей. 
В последние годы ситуация в этой области в языке C++ намного 
улучшилась благодаря появлению «интеллектуальных» указателей, 
но он пока не способен догнать язык Java с его библиотекой поддержки 
многопоточной модели выполнения. Язык Java освобождает 
программиста от бремени управления памятью с помощью механизма 
сборки мусора. Поддержка многопоточной модели выполнения 
в языке C++ в настоящее время включена в состав стандартной библиотеки, 
однако в языке C она реализована только в виде сторонних 
библиотек. Но, несмотря на все это, создание многопоточных 

Введение

программ на языке C, C++ или Java требует от программиста немалых 
усилий, чтобы обеспечить своевременное приобретение и 
освобождение ресурсов.
Все сложности, связанные с  учетом ресурсов в языке Go, берут 
на себя компилятор и среда выполнения. Для управления памятью в 
Go имеется механизм сборки мусора, что избавляет от необходимости 
использовать «интеллектуальные» указатели или освобождать 
память вручную. А поддержка параллелизма в языке Go реализована 
в форме механизма взаимодействующих последовательных 
процессов (Communicating Sequential Processes, CSP), основанного 
на идеях специалиста в области теории вычислительных машин и 
систем Чарльза Энтони Ричарда Хоара (C. A. R. Hoare) , благодаря 
которому во многих многопоточных программах на языке Go 
вообще отпадает необходимость блокировать доступ к ресурсам. 
Кроме того, в языке Go имеются так называемые go-подпрограммы 
(goroutines) – очень легковесные процессы, которых можно создать 
великое множество. Выполнение этих процессов автоматически будет 
распределяться по доступным процессорам и ядрам, что обеспечивает 
возможность более тонкого деления программ на параллельно 
выполняющиеся задачи, чем это позволяют другие языки программирования, 
основанные на потоках выполнения. Фактически 
поддержка параллелизма в языке Go реализована настолько просто 
и естественно, что при переносе однопоточных программ на язык 
Go часто обнаруживается возможность параллельного выполнения 
нескольких задач, ведущая к увеличению скорости выполнения и 
более оптимальному использованию машинных ресурсов.
Go – практичный язык, где во главу угла поставлены эффективность 
программ и удобство программиста. Например, встроенные и 
определяемые пользователем типы данных в языке Go существенно 
отличаются – операции с первыми из них могут быть значительно 
оптимизированы, что невозможно для последних. В Go имеются также 
два встроенных фундаментальных типа коллекций: срезы (slices) 
(фактически ссылки на массивы переменной длины) и отображения 
(maps) (словари, или хеши пар ключ/значение). Коллекции этих типов 
высокооптимизированы и с успехом могут использоваться для 
решения самых разных задач. В языке Go также поддерживаются 
указатели (это действительно компилирующий язык программирования – 
в нем отсутствует какая-либо виртуальная машина, снижающая 
производительность), что позволяет с непринужденностью 

создавать собственные, весьма сложные типы данных, такие как 
сбалансированные двоичные деревья.
В то время как C поддерживает только процедурное программирование, 
а Java вынуждает программистов писать все программы в 
объектно-ориентированном стиле, Go позволяет использовать парадигму, 
наиболее подходящую для конкретной задачи. Go можно 
использовать как исключительно процедурный язык программирования, 
но он также обладает превосходной поддержкой объектно-
ориентированного стиля программирования. Однако, как будет 
показано далее в книге, реализация объектно-ориентированной парадигмы 
в Go радикально отличается от реализации этой же парадигмы 
в таких языках, как C++, Java или Python. Она намного 
проще в использовании и значительно гибче.
Как и в языке C, в Go отсутствуют генерики (generics) (шаблоны, 
в терминологии C++), однако в Go имеется масса других возможностей, 
которые во многих случаях устраняют потребность в генери-
ках. В языке Go отсутствует препроцессор и не используются подключаемые 
заголовочные файлы (что является еще одной причиной, 
объясняющей высокую скорость компиляции), поэтому в нем нет 
необходимости дублировать сигнатуры функций, как в C и C++. А 
благодаря отсутствию препроцессора семантика программы не может 
измениться незаметно для программиста, как это может произойти 
при небрежном обращении с директивами #define в языках C и C++.
Возможно, языки C++, Objective-C и Java создавались как улучшенные 
версии языка C (а последний – как улучшенная версия 
языка C++). В языке Go тоже можно усмотреть попытку создать 
улучшенную версию языка C, даже при том, что простой и ясный 
синтаксис Go больше напоминает язык Python – срезы и отображения 
в Go сильно напоминают списки и словари в Python. Однако по 
духу Go все-таки ближе к языку C, чем к любым другим языкам, и 
его можно считать попыткой устранить недостатки  языка C, взять 
из него все самое лучшее и добавить множество новых возможностей, 
уникальных для Go.
Первоначально Go задумывался как язык системного программирования 
с высокой скоростью компиляции для разработки высо-
комасштабируемых программ, которые могли бы использовать преимущества 
распределенных систем и многоядерных компьютеров. В 
настоящее время область применения языка Go стала значительно 
шире первоначальной концепции, и сейчас он используется как высокопроизводительный 
язык программирования общего назначения, 
использовать который – одно удовольствие.

Зачем изучать язык Go?

Введение

Структура книги

Глава 1 начинается с описания, как компилировать и запускать программы 
на языке Go. Затем в этой главе дается краткий обзор синтаксиса 
и возможностей языка Go, а также вводятся некоторые пакеты из 
стандартной библиотеки. В ней будут представлены и описаны пять 
коротких примеров, иллюстрирующих различные возможности языка 
Go. Эта глава написана так, чтобы сформировать представление о языке 
и вселить в читателя уверенность в необходимости освоения языка 
Go. (В этой главе также описывается, как получить и установить Go.)
Главы со 2 по 7 детально рассматривают язык Go. Три главы посвящены 
встроенным типам данных: в главе 2 рассказывается об 
идентификаторах, логических и числовых типах. В главе 3 рассматриваются 
строки. И в главе 4 – коллекции.
Глава 5 описывает и демонстрирует инструкции и управляющие 
конструкции языка Go. Она также рассказывает, как создавать и 
использовать собственные функции, и заканчивает главы, демонстрирующие 
создание на языке Go однопоточных программ в процедурном 
стиле.
Глава 6 показывает особенности объектно-ориентированного 
программирования на языке Go. Данная глава включает описание 
структур языка Go, используемых для объединения и встраивания 
(делегирования) значений, и интерфейсов, применяемых для определения 
абстрактных типов, а также демонстрирует, как в некоторых 
ситуациях добиться эффекта наследования. В главе будут представлены 
несколько законченных примеров с подробным описанием, 
чтобы помочь читателю разобраться в объектно-ориентированном 
стиле программирования на языке Go, который может существенно 
отличаться от привычного стиля.
Глава 7 охватывает механизмы параллельного выполнения задач 
в языке Go и приводит еще больше примеров, чем глава об объектно-
ориентированном программировании, опять же чтобы помочь 
читателю лучше понять эти новые аспекты.
Глава 8 демонстрирует, как читать из файлов и записывать в них 
собственные и стандартные двоичные данные, текст, а также данные 
в формате JSON и XML. (Работа с текстовыми файлами коротко рассматривается 
в главе 1 и в нескольких последующих главах, потому что 
это позволяет приводить более практичные примеры и упражнения.)
Глава 9 завершает книгу. Она начинается с демонстрации импортирования 
и использования пакетов из стандартной библиотеки, а 
затем собственных и сторонних пакетов. В ней также рассказывается,