Введение в язык программирования Go

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

Числа int8, int16, int32, int64, uint8, unit16, uint32, uint64, float32, float64. Как видно все типы имеют в названии размер, занимаемой памяти в битах. Для всех чисел пустое значение — 0. Также любой числовой тип можно привести к любому другому числовому типу, использовав тип как функцию:

С числами можно производить следующие бинарные арифметические операции: сложение (+), вычитание (-), умножение (*), деление (/), а для целых чисел также доступна операция деления по модулю (%). Кроме того для знаковых типов можно инвертировать знак с помощью приписывания к числу слева знака -. Для всех бинарных операций есть краткая форма записи в случае, если результат необходимо присвоить переменной, являющейся первым операндом:

Также существуют операции инкрементирования и декрементирования:

Есть также типы алиасы к числовым типам. Например, тип byte является тем же типом int8, а rune — int32. Но есть и менее предсказуемые типы int и uint, являющиеся алиасами к типам int32 и uint32 или int64 и uint64 соответственно в зависимости от битности операционной системы, на которой выполняется программа.

Булевый тип bool может принимать значение true или false, последнее является пустым значением для этого типа. Для булевых переменных и констант доступны следующие операции: инверсия (!), логическое и (&&) и логическое или (||).

И, наконец, скалярным типом в Go является строка (тип string). Вообще говоря строка представляет из себя срез (slice), о которых мы будем говорить позже. Но компилятор не позволяет модифицировать отдельные символы строки, так что она подходит под определение скалярного типа. Пустым значением для переменных типа строка является пустая строка. Для объявления строковых констант можно использовать либо двойные кавычки ("), либо обратные кавычки (`), при этом в первых можно использовать специальные символы, такие как \n, \t и так далее, а в обратных кавычках можно использовать непосредственно переносы строк. То есть следующие две константы равны:

Строки можно складывать (конкатенировать), используя операцию +. А также можно использовать синтаксис срезов для получения подстроки:

Для всех скалярных типов можно также определить константу с помощью ключевого слова const. Объявление аналогично определению с ключевым словом var, но полученный объект нельзя использовать в левой части оператора присваивания. Также во время объявления констант доступно ключевое слово iota:

В результате будет объявлены следующие константы типа int: Foo равная 0, Bar равная 1, Baz равная 2 и Qux равная 3. При этом iota в рамках одного блока определений будет принимать значения от 0 до максимума типа int, увеличиваясь для каждого следующего определения. Для констант можно задать тип, отличный от int, а с iota можно составить выражение, допустимое в определении констант:

Такой встроенный итератор можно использовать как некоторую замену отсутствующему в языке enum'у, но в придачу к iota понадобится Генерация кода

Областью видимости переменной называется область кода, где доступно значение этой переменной. Всегда есть глобальная область видимости пакета, туда попадают константы, функции, типы и переменные, объявленные вне функций. Глобальную переменную можно объявить только с использованием ключевого слова var. То есть можно написать

но нельзя использовать оператор :=.

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

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

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

Если выполнено условие <condition 1>, то будут выполнены инструкции, перечисленные в <body 1>, если не выполнено условие <condition 1>, но выполнено условие <condition 2>, то будут выполнены инструкции из <body 2>, наконец, если ни одно условие не выполнено, то будут выполнены инструкции из блока else (<body 3>). Блоков else if может быть сколько угодно от 0 и до бесконечности. Блок else может быть пропущен.

В качестве условий могут быть использованы любые выражения, результатом которых имеет тип bool, например:

В Go есть особая форма конструкции if, позволяющая выполнить инструкцию прямо внутри условия. Для примера рассмотрим следующую задачу: дана хеш таблица m, необходимо проверить наличие в ней ключа, если ключ есть, то вернуть значение по этому ключу, иначе вернуть defaultValue (аналог метода get словарей в Python). Подробнее о хеш-таблицах мы поговорим в соответствующем разделе, здесь отметим лишь то, что при получении значения по ключу из хеш-таблицы можно использовать синтаксис

Тогда, если ключ есть в хеш-таблице, то val будет присвоено значение, хранящееся по этому ключу, а в ok будет записано true. Если же ключ не найден, то val будет присвоено пустое значение, соответствующее типу значений хеш-таблицы, а в ok будет записано false.

Таким образом, задачу можно решить следующим способом:

Но в Go можно объединить первые две строки:

Это особенно удобно потому, что во втором случае область видимости переменных val и ok будет ограничена условием, в первом же случае они оказываются объявлены за пределами условия.

Для сопоставления значения выражения возможным значениям можно использовать оператор switch:

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

Знакомые с такими языками как Си или JavaScript могут удивиться отсутствию ключевых слов break в конце блоков. В Go поведение по умолчанию противоположно поведению этих языков. По умолчанию выполняется только один блок. Если необходимо выполнить также и следующий блок, необходимо использовать ключевое слово fallthrough. Например,

В данном примере, если значение переменной command равно строке "continue", то будет выполнена только функция next, если значение равно "save and continue", то будет выполнена функция save, после чего будет выполнена следующая ветка, то есть "continue", состоящая из вызова функции next. При любой другой команде будет выполнен блок default.

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

Часто конструкцию из множественных блоков else if переписывают в виде:

В Go в такой конструкции можно опустить выражение true вообще:

Одной из «фишек» Go является минимизация ключевых слов языка. Именно поэтому все циклы в нём определяются одним ключевым словом for. Но имеются следующие виды циклов:

Функции могут возвращать не одно значение, а кортеж. В качестве примера возьмём функцию, которая принимает два аргумента и возвращает их в обратном порядке:

Типы результатов могут быть разными, а также можно именовать результаты, превращая их в объявление переменных. Это особенно удобно, когда не очевидно назначение результатов. При этом если использовать ключевое слово return без дополнительных аргументов, то будет возвращёны значения именованных результатов:

При этом совсем не обязательно использовать для возврата именно именованные результаты:

В Go функции являются такими же данными, как переменные или константы. То есть функции можно передавать как аргументы в другие функции. Например, напишем функцию, находящую минимальное натуральное число (не включая 0), для которого выполнена некоторая проверка check, которая является функцией, принимающей целое число и возвращающей булево значение:

Теперь можно использовать эту функцию в комбинации с различными функциями проверки:

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

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

Получившаяся функция также называется замыканием, потому что ссылается на область видимости функции, которая её порождает (аргумент d). При этом в замыкании можно как читать, так и изменять контекст порождающей функции. С помощью замыканий можно реализовывать различные полезные паттерны проектирования. Например, с помощью замыкания можно создать итератор (объект возвращающий по запросу следующее значение из некоторой последовательности). Для примера напишем генератор чисел Фибоначчи:

Некоторые задачи требуют рекурсивного вызова функции. Например, вычисление факториала числа:

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

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

Теперь к моменту разбора тела функции переменная factorial уже объявлена и её можно использовать.

Иногда возникает необходимость определить функцию, которая может принимать переменное число аргументов. Например, функция, суммирующая все переданные в неё аргументы. Вообще говоря мы можем передать в такую функцию один аргумент с типом срез (см. Срезы):

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

В Go есть синтаксический сахар, позволяющий объявить последний аргумент функции как остаточный (rest):

Внутри функции это будет такой же срез, как и был, зато снаружи можно будет передавать аргументы обычным кортежем:

Этот синтаксис имеет ряд ограничений, но часто позволяет улучшить публичный интерфейс пакета. Старайтесь не злоупотреблять подобным синтаксисом.

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

Одной из важных особенностей срезов является то, что срез может быть пустым, а может быть nil:

Дело в том, что пустым значением для среза является nil. Но если мы объявим срез с пустым списком элементов, то получим не nil, а срез без элементов. При этом функция append ведёт себя одинаково.

Итак, при добавлении элементов в срез возможен перенос данных. Это, как уже упоминалось, достаточно долгая операция. Часто мы можем предсказать сколько будет элементов или по крайней мере знаем верхнюю границу их количества. В этом случае можно создать срез с заранее выделенной памятью под данные (в дальнейшем такой срез ничем не будет отличаться от любого другого, по необходимости также будет выделяться новая память и перенос данных). Для этого можно воспользоваться встроенной функцией make, доступной в двух вариантах записи:

В первом случае будет создан срез с элементами типа <type> с длинной и вместимостью <len>, а во втором с длинной <len> и вместимостью <cap>.

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

А при расширении среза всё ещё куда менее предсказуемо:

Для того, чтобы не попасться в подобную ловушку необходимо создать копию данных. Это можно сделать следующим способом:

Вместо написания цикла можно воспользоваться встроенной функцией copy(<dst>, <src>), которая копирует данные из <src> в <dst>:

Важно помнить, что функция copy копирует элементов не больше, чем есть в <src> и для которых есть место в <dst>, то есть для среза <dst> необходимо заранее выделить память, например, с использованием функции make.

Любопытный читатель может спросить, почему же срезы называются срезами, ведь пока они выглядят скорее как динамические массивы. Такое название определилось особым синтаксисом для получения части среза. Во многих языках есть функция или метод массива slice(<i>[, <j>]), которая возвращает кусочек оригинального массива от i-го элемента до j-1-го. В Go вместо функции для подобных выборок используется специальный синтаксис:

Можно не указать начало среза, тогда срез будет взят от 0. Аналогично, если не указать конец среза, то срез будет взят до конца оригинального среза.

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

Помните, что последний параметр функции с типом срез можно определить с использованием rest-синтаксиса. Мы также можем передать его с использованием подобного rest-синтаксиса:

Похожий интерфейс имеет функция append:

Несмотря на столь скромный набор встроенных методов по работе со срезами (append, [i:j], copy), с их помощью можно производить достаточно сложные манипуляции, например, вставка элемента в i-ю позицию среза:

Или удаление i-го элемента:

Другие операции над срезами вы можете найти в вики языка: https://github.com/golang/go/wiki/SliceTricks.

При итерировании по таблице возможны два варианта цикла:

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

Для модификации необходимо использовать доступ по ключу или обновлять значение в таблице принудительно.

Важно помнить про тот факт, что для работы хеш-таблицы необходимо выделить память для \(N\) пар. Без этого невозможно добавить в хеш-таблицу первую пару, то есть следующий код приведёт к ошибке:

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

или

Эти объявления эквивалентны. Рантайм Go не выделяет сразу большой объём памяти, вместо этого используется система бакетов или корзин, при которой по необходимости к хеш-таблице привязываются области памяти, называемые корзинами, в которых хранятся пары, и по необходимости количество корзин добавляется. Таким образом при инициализации хеш-таблицы без дополнительных указаний создаётся всего один бакет и вместе с заголовочной частью пустая таблица занимает 48 байт на 64-битной системе.

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

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

Также необходимо отметить, что для уменьшения количества коллизий таблице необходимо иметь достаточно свободного места. То есть помимо памяти, занятой парами, необходимо место, свободное для добавления. В среднем свободное место равно используемому месту под ключи. То есть, при использовании в качестве ключей int64, если в таблице находится 100 ключей, то примерно 80 байт выделено под ключи и столько же выделено под возможные вставки.

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

Часто возникает потребность в получении множества каких-то объектов. Например, для удаления дубликатов. В этом случае можно использовать хеш-таблицу, используя объекты в качестве ключей. При этом значения нам не важны, важно понимать — есть уже объект в виде ключа в множестве или нет. Для удобства будем хранить там булево значение, записывая истину для добавляемых элементов:

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

Однако, если нет задачи сохранять порядок, то код и с пустыми структурами останется простым и наглядным:

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

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

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

Тогда увеличение счётчика больше не требует дополнительных проверок:

Как и всё, что связано с ООП, тема интерфейсов неоднозначна и периодически вызывает холивары. О видении самих разработчиков можно прочитать в статье Go Code Review Comments в вики проекта на https://github.com/golang/go. Мы же рассмотрим имеющиеся ограничения как данность.

Первое о чём необходимо помнить, это то, что интерфейсы описывают только методы, никаких свойств объектов, только поведение. Когда мы говорим «плоская геометрическая фигура», мы не можем говорить о её радиусе или длине диагонали, однако мы можем говорить о том, что фигура имеет площадь или диаметр (максимальная длина отрезка, вмещающегося в эту фигуру). Также, например, для формирования отчёта по факту не нужны фамилия, имя и отчество объекта пользователь, необходимо, чтобы этот объект мог сериализоваться в строку.

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

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

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

пишите

Особенно, если интерфейс лежит в другом пакете.

Конструкция interface{} описывает объект без методов. Такому интерфейсу удовлетворяет всё, что угодно. Это некоторая замена any или unknown из других языков. Такой тип часто используют для определения аргументов функций, которые могут обрабатывать несколько типов. Например, функция fmt.Println принимает сколько угодно каких угодно аргументов и имеет объявление

Когда же возникает необходимость определить тип, спрятанный за интерфейсом, можно воспользоваться кастингом типов. Если вы абсолютно точно уверены какой тип спрятан под интерфейсом, то можно просто явно привести к конкретному типу (в том числе и к другому интерфейсу):

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

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

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

Инструкция fallthrough в данной конструкции не работает по очевидным причинам.

При кастинге типа необходимо помнить про следующее ограничение: если переменная содержит значение типа A, который основан на типе B, то её можно скастить в тип A, но нельзя в B. Например

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

Ещё одна проблема связана со значением nil. Проблема заключается в том, что под капотом каждая переменная описывается значением и типом. Таким образом даже пустое значение, даже nil имеет тип. Чтобы было понятнее приведём пример:

В первом случае переменная a имеет тип срез и nil приводится к этому типу, соответственно сравнение оказывается истинным. Во втором же случае переменная x имеет тип интерфейс, но при этом значение всё тот же неинициализированный срез, правая часть сравнения приводится к типу интерфейсу и сравнение оказывается ложным. Сложности с этим часто возникают при создании кастомных ошибок на основе срезов, например:

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

В данном случае будет возвращён именно интерфейсный nil. Также полезным оказывается добавление специального метода к такой ошибке:

С самой первой версии для работы с языком было необходимо настроить переменную окружения $GOPATH. Принцип работы этой переменной вызывало максимальное непонимание для новичков в языке, так что в итоге в версии 1.8 для этой переменной ввели значение по умолчанию (~/go), а начиная с версии 1.12 можно работать вообще не зная ничего об этой переменной. Однако, давайте всё же разберёмся — как она работает.

Переменная $GOPATH должна содержать путь к директории, в которой будет хранится информация обо всех сторонних пакетах, в том числе и разрабатываемых. Внутри этой директории будет созданы три директории: src, pkg и bin. В последнюю будут автоматически попадать скомпилированные исполняемые файлы, при установке пакетов, собирающихся в таковые. Например, если установить пакет stringer, из него будет собран исполняемый файл stringer. В директории pkg будет собираться кеш версий различных библиотек, а также промежуточные артефакты компиляций. Наконец, директория src содержит исходный код пакетов и модулей. Начиная с версии 1.13, установка пакета сохраняет его исходные коды только в pkg, так что в src остались только разрабатываемые вами исходные коды. И полное имя пакета для импорта совпадает с путём до пакета относительно директории src. Таким образом, если в директории src создать директорию foo/bar, в которую положить go-файлы, то для импорта этого пакета в другом пакете в директиве import будет необходимо прописать строку "foo/bar".

Для установки сторонних библиотек с самой первой версии существует команда go get <имя пакета>. В качестве источников пакетов используются git-репозитории, например, https://github.com или https://golang.org. Собственно для установки того же пакета stringer в консоли необходимо выполнить

Эта команда выполнит следующее:

Для обновления можно использовать дополнительный флаг -u. А после внесения изменений можно пересобрать исполняемый файл с помощью команды

При этом src будет лежать полноценный git-репозиторий, как есть.

Если одна библиотека использовала другую, то при установке устанавливались и зависимости. Конечно без всякого версионирования, просто последний коммит из master-ветки. Но что хорошо для монорепозитория, плохо для большого распределённого сообщества. Так в версии 1.5 появилась поддержка специальной папки vendor, содержащей в себе зависимости. Также правилом хорошего тона стало включение этой папки в репозитории. При сборке зависимость в первую очередь ищется в папках vendor рекурсивно от текущего пакета до $GOPATH/src, после чего ищется уже в $GOPATH/src. Но не смотря на поддержку этой папки во время компиляции, не было никакого официального тулинга для работы с содержимым этой папки. Так появились инструменты, разрабатываемые сообществом.

В конце февраля 2018 года один из корневых разработчиков языка Расс Кокс выпустил серию статей и прототип того, что в последствии стало называться go-модули. Начиная с версии языка 1.10 поддержка модулей появилась в наборе команд go mod.

Модули позволяют версионировать библиотеки и их зависимости, а также, при необходимости управлять директорией vendor. Для того, чтобы создать модуль, достаточно в любой директории выполнить команду go mod init. После этого в директории появится файл go.mod, в котором будут описываться зависимости текущего модуля. Первой строкой в таком файле указано название модуля. Это название важно в том смысле, что работать с модулем можно за пределами $GOPATH. При разрешении зависимостей, если зависимость начинается с названия модуля, то она будет искаться относительно этого модуля.

При выполнении команды go get внутри модуля будет подтянута в кеши последняя версия библиотеки. В качестве версий библиотек используются тэги git-репозитория. При этом используется строгий semver, то есть тэг должен иметь вид

Если в репозитории нет ни одного тэга, подходящего под это определение, то будет взята голова master-ветки. Информация об устанавливаемых версиях будет накапливаться в файле go.mod. При необходимости включения зависимости целиком можно выполнить команду go mod vendor, которая соберёт все зависимости с нужными версиями и скопирует их в директорию vendor.

Если две или более зависимости ссылаются на разные версии одной библиотеки, то для минорных версий будет выбрана максимальная из требуемых, а мажорные версии могут работать параллельно, используя суффиксы в импортах v2. Более подробно о разрешении зависимостей и других особенностях поведения модулей можно прочитать в серии статей Расса Кокса.