Как хранятся переменные в golang
Для хранения данных в программе применяются переменные. Переменная представляет именованный участок в памяти, который может хранить некотоое значение. Для определения переменной применяется ключевое слово var , после которого идет имя переменной, а затем указывается ее тип:
Имя переменной представляет произвольный идентификатор, который состоит из алфавитных и цифровых символов и символа подчеркивания. При этом первым символом должен быть либо алфавитный символ, либо символ подчеркивания. При этом имена не должны представлять одно из ключевых слов: break, case, chan, const, continue, default, defer, else, fallthrough, for, func, go, goto, if, import, interface, map, package, range, return, select, struct, switch, type, var.
Например, простейшее определение переменной:
Данная переменная называется hello и она представляет тип string , то есть некоторую строку.
Можно одновременно объявить сразу несколько переменных через запятую:
В данном случае определены переменные a, b, c, которые имеют тип string . В этом случае опять же в конце указывается тип данных, и все переменные принадлежат этому типу.
После определения переменной ей можно присвоить какое-либо значение, которое соответствует ее типу:
Поскольку переменная hello представляет тип string, ей можно присвоить строку. В данном случае переменная hello хранит строку «Hello world». С помощью функции Println значение этой переменной выводится на консоль.
Также важно учитывать, что Go — регистрозависимый язык, то есть переменные с именами «hello» и «Hello» будут представлять разные переменные:
Также можно сразу при объявлении переменной присвоить ей начальное значение. Такой прием называется инициализацией:
Если мы хотим сразу определить несколько переменных и присвоить им начальные значения, то можно обернуть их в скобки:
Отличительной особенностью переменных является то, что их значение можно многократно изменять:
Краткое определение переменной
Также допустимо краткое определение переменной в формате:
После имени переменной ставится двоеточие и равно и затем указывается ее значение.
В этом случае тип данных явным образом не указывается, он выводится автоматически из присваиваемого значения.
Из техпода в программисты (или Golang для самых маленьких)
Мне 26 лет, 5.5 лет проработал в технической поддержке и окончательно выгорел. Решил заниматься тем, что меня действительно воодушевляет и от чего испытываю удовольствие.
Данный цикл статей предназначен в первую очередь для себя самого чтобы быстрее усвоить материал, а также для новичков в программировании которые как и я хотят освоить язык и заниматься интересными проектами.
На своём жизненном пути я уже знакомился с HTML, CSS и его препроцессорами, Javascript, PHP, SQL, немного Python, C#, Java. Даже реализовал несколько веб проектов, решил некоторые рабочие задачи, но меня постоянно что-то не устраивало. Я хотел найти “идеальный” для себя язык с которым мне было бы приятно работать и наткнулся на Golang.
Почему именно Golang? Go понравился мне по нескольким причинам.
“Из коробки” имеет многопоточность
Сборщик мусора о котором нет необходимости задумываться
Развивается как open source проект
Что рассмотрим в этой статье
Что нужно для работы с Go
Основные типы данных
Условные выражения и условные конструкции
Что нужно для работы с Go
Для работы с Go первое что необходимо это — текстовый редактор для написания кода, а так же компилятор который преобразует код в исполняемый файл.
Скачайте и установите компилятор с официального сайта — https://golang.org/dl/
Для написания кода можно использовать специальные интегрированные среды разработки (IDE), которые поддерживают Go.
Самая многофункциональная IDE представлена компанией JetBrains и называется она GoLand, но не спешите её устанавливать. Есть ряд причин почему нет необходимости в таком большом инструменте.
для знакомства с языком и написания своих первых пет-проектов хватит и инструментов описанных ниже
Другие инструменты для разработки на Go:
Visual Studio Code + плагин для разработки на Go
Atom + плагин для разработки на Go
Sublime Text + плагин для разработки на Go
Существуют и другие IDE у которых есть плагины для Go например: Intellij IDEA, Netbeans. Но не думаю что стоит заострять на них внимание т.к. это достаточно большие IDE с обширным функционалом и новичок в них очень легко запутается.
Также можно программировать на Go прямо из браузера не устанавливая ничего на своё устройство.
Repl.it — поддерживает полноценный ввод и терминал
Переменные
Для хранения данных в программе используются переменные. Переменная — это именованный участок в памяти, который может хранить в себе какое-то значение. Для определения переменной в Go используется специальное слово var, после которого идет имя переменной а потом тип
В Go имя переменной может быть произвольным и может состоять из алфавитных и цифровых символов, а также символа подчеркивания. При этом при объявлении переменной первый символ должен быть либо алфавитный символ, либо символ подчеркивания. Важно, что имена переменных не могут быть такими же как зарезервированные в Go кодовые слова: break, case, chan, const, continue, default, defer, else, fallthrough, for, func, go, goto, if, import, interface, map, package, range, return, select, struct, switch, type, var.
Самое простое определение переменной:
Эта переменная называется hello и представляет строковый тип данных string.
Можно одновременно объявить несколько переменных через запятую:
В этом случае объявлены переменные a, b и c которые имеют тип данных string. В конце также указывается тип данных и все переменные ему принадлежат.
Одновременно с объявлением переменной ей можно присвоить какое-то значение:
Такой прием называется инициализацией
Неявная типизация
При объявлении переменной можно не указывать её тип, если происходит явная инициализация переменной значением.
Так же можно объявить переменную сокращенным способом:
Такой способ эквивалентен предыдущему.
Если объявить переменную без указания типа и начального значения, это будет ошибкой.
Поэтому необходимо либо указать тип, либо начальное значение, либо и то и другое
Так же можно объявить несколько переменных
Основные типы данных
Стандартное значение для всех числовых типов = 0
Целочисленные типы
int8 — число от -128 до 127 занимает в памяти 1 байт (8 бит).
int16 — число от -32768 до 32767 занимает в памяти 2 байта (16 бит).
int32 — число от -2147483648 до 2147483647 занимает в памяти 4 байта (32 бита).
int64 — число от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 занимает в памяти 8 байт (64 бита).
uint8 — целое число от 0 до 255 занимает 1 байт.
uint16 — целое число от 0 до 65535 занимает 2 байта.
uint32 — целое число от 0 до 4294967295 занимает 4 байта.
uint64 — целое число от 0 до 18 446 744 073 709 551 615 занимает 8 байт.
byte — тоже самое что и uint8, целое число от 0 до 255 занимает 1 байт.
rune — тоже самое что и int32, число от -2147483648 до 2147483647 занимает в памяти 4 байта (32 бита).
int — аналог int32 или int64 целое число которое в зависимости от разрядности операционной системы может занимать либо 4 либо 8 байт.
uint — целое беззнаковое число, аналог типа int, соответствует типам int32 и int64 занимает 4 или 8 байт.
Тип с плавающей точкой
Они же десятичные дроби.
float32 — число с плавающей точкой от 1.410-45 до 3.41038 (для положительных). Занимает в памяти 4 байта (32 бита).
float64 — число с плавающей точкой от 4.910-324 до 1.810308 (для положительных) и занимает 8 байт (64 бита).
Комплексные типы
В Go присутствуют комплексные типы данных. На практике они имеют не очень большую популярность.
complex64 — комплексное число где вещественная и мнимая части представляют числа float32.
complex128 — комплексное число где вещественная и мнимая части представляют float64.
Подробнее про комплексные числа можете прочитать здесь
Логический тип
bool — логический тип данных и может иметь только 2 значения true (истина) или false (ложь)
Строковый тип
string — В Go строки это последовательность символов заключенная в двойные кавычки
Помимо обычных символов строка может содержать в себе специальные символы
\n — переход на новую строку
\r — возврат каретки (возвращает курсор в начало текущей строки)
\t — табуляция
« — двойная кавычка внутри строк
Константы
Константы как и переменные хранят в себе некоторые данные, но в отличие от переменных их значения невозможно изменить т.к. они устанавливаются только один раз.
Для определения константы используется ключевое слово const.
Если мы попробуем изменить значение константы, то получим ошибку.
В одном представлении можно объявить сразу несколько констант
Если у константы не указан тип, то он выводится неявно в зависимости от того значения каким инициализируется константа
Также константам обязательно необходимо присваивать значения при объявлении.
Такое объявление констант недопустимо, потому что они не инициализируются.
Если определяется последовательность констант, то инициализацию значений можно опустить для всех констант кроме первой. В этом случае константа без значения получит его от предыдущей константы:
Важно, константы можно инициализировать только константными значениями, например числами, строками или значениями других констант. Но инициализировать константу значениями переменной нельзя:
Арифметические операции
У переменных есть разные операции, как в алгебре.
+ сложение
— вычитание
* умножение
/ деление
При делении необходимо быть внимательным! Если в операции два целых числа, то результат деления будет округляться до целого числа даже если результат деления присваивается переменной типа float32/float64:
Чтобы получить в результате деления вещественное число, хотя бы один из операндов должен быть вещественным числом:
% (деление по модулю) возвращает остаток от деления. В этой операции могут быть использованы только целые числа:
Постфиксный инкремент (x++). Увеличивает значение переменной на единицу:
Постфиксный декремент (x—). Уменьшает значение переменной на единицу:
Комментарии
Программа может содержать в себе комментарии. Комментарии необходимы для описания действий которые производит программа или какие-то её части. При компиляции программы комментарии не учитываются и не оказывают никакого влияния на работы программы. Комментарии бывают однострочными и многострочными.
Однострочный комментарий пишется в одну строку после двойного слеша (//), многострочный комментарий может заключаться между символами /* и */ и занимать несколько строк:
Ввод/вывод данных
Работать с переменными конечно интересно, но намного интереснее работать с ними и видеть как их значения выводятся через консоль. Для того чтобы это сделать, необходимо воспользоваться методом Scan из стандартного пакета Go под названием fmt, например:
&a — ссылка на переменную (или адрес переменной) под названием a
Если проще, то введённое число или слово в консоль, запишется в эту переменную и будет в ней храниться пока не понадобится изменить значение переменной.
Теперь можно прочитать например, имя и возраст. Для начала создадим файл в любом удобном для вас месте на вашем компьютере. В моём случае это файл main.go расположенный по пути E:\main.go и содержит в себе следующий код:
В моем коде используется форматированный вывод, об этом способе вывода информации я подробнее напишу в следующих статьях. Но для особо любопытных, можете почитать вот здесь.
Далее чтобы увидеть работу этого кода и поиграть с ним, необходимо запустить командную строку или терминал. Например: Git Bash, встроенный терминал LiteIDE. Если пользуетесь этой IDE как я, терминал можно запустить сочетанием клавиш Ctrl+Shift+4. Итак, вводим заветную команду go run main.go и нажимаем Enter.
После консоль просит нас по очереди ввести имя и возраст. Когда программа получает эту информацию, выводится строка “Человеку по имени Авдей, 99 лет.” и программа завершает свою работу.
Условные выражения и условные конструкции
Условные выражения представляют операции отношения и логические операции. Они представляют условие и возвращают значение типа bool: true — если условие истинно и false — если условие ложно.
Операции отношения позволяют сравнивать два значения. В Go есть следующие операции отношения:
== Операция “равно”, возвращает true, если оба операнда равны или false если они не равны.
> Операция “больше чем”, возвращает true, если первый операнд больше второго, и false если первый операнд меньше второго, либо оба операнда равны.
< Операция “меньше чем”, возвращает true, если первый операнд меньше второго, и false если первый операнд больше второго, либо оба операнда равны.
>= Операция “больше или равно”, возвращает true, если первый операнд больше второго или равен второму, и false если первый операнд меньше второго.
<= Операция “меньше или равно”, возвращает true, если первый операнд меньше или равен второму, и false если первый операнд больше второго.
!= Операция “не равно”, возвращает true, если первый операнд не равен второму, и false если оба операнда равны.
Логические операции сравнивают два условия. Они применяются к отношениям и объединяют несколько операций отношения. К логическим операциям относятся:
! — операция отрицания (логическое НЕ). Инвертирует значение. Если операнд равен true, то возвращает false. И наоборот, если операнд равен false, вернет true.
&& — конъюнкция, логическое умножение (логическое И). Возвращает true, если оба операнда не равны false. Возвращает false, если хотя бы один операнд равен false.
|| — дизъюнкция, логическое сложение (логическое ИЛИ). Возвращает true, если хотя бы один операнд не равен false. Возвращает false, если оба операнда равны false.
Примеры использования операций отношения и логических операций можете посмотреть здесь.
Условные конструкции проверяют истинность условия и в зависимости от результата проверки направляют ход программы по одному из путей.
if else
Конструкция if принимает условие — выражение, которое возвращает значение типа bool. И если это условие истинно, то выполняется последующий блок инструкций:
В приведенном примере после запуска кода, консоль выведет “x меньше y”.
Если необходимо задать программе альтернативную логику, которая выполнится в случае если условия верно, то добавляется выражения else:
В этом примере после запуска кода, консоль выведет “x больше y” т.к. условие в блоке else будет верным.
Если необходимо проверить несколько альтернативных вариантов, то можно добавить выражение else if:
В этом случае выполнится код в блоке else, потому как условия описанные в блоках if и else if равны false.
Выражений else if может быть множество.
Switch
Конструкция switch проверяет значение выражения, с помощью операторов case определяются значения для сравнения. Если значение после оператора case совпадает со значением выражения switch, то выполняется код этого блока case.
Запустив этот код, мы увидим что выполнится case 7, потому что значение в этом кейсе совпадает со значением в switch.
Также в приведенном выше коде написан блок default. Этот блок не обязательный, но он выполнится если ни один из операторов case не содержит нужного значения.
Стоит отметить, что в Go код после case выполняется до следующего case, то есть нет необходимости заканчивать каждый блок case словом break. Это было добавлено в язык специально, чтобы уменьшить количество ошибок в блоках switch. Если в текущем блоке написать ключевое слово fallthrough, то следующий case выполнится вне зависимости от того, истинно ли его условие:
Выполнив этот код, мы увидим следующую картину в консоли:
В консоль будет выведено всё начиная с 4 кейса, т.к. значение лежащее в переменной x равно 4, а остальные case выполнятся из-за того, что внутри case написано ключевое слово fallthrough.
В switch допускается использование произвольных условий в каждом case:
Если запустить этот код и ввести допустим число 256, то получим в консоли:
Заключение
В заключении статьи хотелось бы поделиться полезными ссылками:
Книга — Golang для профи. Работа с сетью, многопоточность, структуры данных и машинное обучение с Go | Цукалос Михалис. (Для новичков будет не совсем понятна, хоть и позиционируется как для начинающих разработчиков, так и для тех, кто работает не один год.)
50 оттенков Go. Очень полезная статья, спасибо VK Team за перевод оригинала
Для тех кто любит проходить различные курсы:
Программирование на Golang (курс составлен неплохо, но полные новички возможно испытают некоторые сложности из-за того, что нельзя посмотреть какими тестами облагаются задания)
Разработка веб-сервисов на Go — основы языка. Курс от Mail.ru и МФТИ. Для полных новичков будет сложно, но по завершению выдаётся сертификат.
Ресурсы с заданиями для практики:
Exercism. Имеется множество заданий различной сложности. Можно быть как студентом, так и ментором.
Использование переменных и констант в Go
Переменные — это важная концепция программирования, которую необходимо освоить. Это символы, обозначающие определенные значения, используемые в программе.
В этом обучающем руководстве мы расскажем об основах работы с переменными и лучших практиках их использования в создаваемых вами программах Go.
Что такое переменные
С технической точки зрения переменная назначает место хранения значения, связанного с символическим именем или идентификатором. Имя переменной используется компьютерной программой, чтобы ссылаться на это сохраненное значение.
Переменную можно представить как ярлык с названием, прикрепляемый к значению.
Допустим, у нас есть число 1032049348 , и мы хотим сохранить его в переменной, а не вводить его каждый раз, когда оно потребуется. Для этого мы можем использовать запоминающееся имя, например переменную i . Для сохранения значения в переменной мы используем следующий синтаксис:
Эту переменную можно представить как ярлык, прикрепленный к значению.
На ярлыке указано название переменной i , и он прикреплен к значению переменной 1032049348 .
Фраза i := 1032049348 представляет собой оператор декларации и присвоения, состоящий из нескольких частей:
- имя переменной ( i )
- короткая декларация переменной ( := )
- значение, привязываемое к имени переменной ( 1032049348 )
- тип данных, подразумеваемый Go ( int )
В следующем разделе мы покажем, как явно задать тип.
Вместе эти компоненты составляют выражение, задающее переменную i как значение целого числа 1032049348 .
Когда мы задаем для переменной значение, мы инициализируем или создаем эту переменную. После этого мы можем сразу начать использовать переменную вместо значения.
Когда мы зададим для i значение 1032049348 , мы сможем использовать i вместо целого числа, так что давайте распечатаем эту переменную:
С помощью переменных мы сможем быстро и легко выполнять математические операции. С i := 1032049348 мы можем выполнить вычитание целочисленного значения 813 , используя следующий синтаксис:
В данном примере Go выполняет математические операции, вычитая 813 из переменной i для возврата суммы 1032048535 .
С математической точки зрения переменные можно задать равными результату математического уравнения. Также вы можете сложить два числа и сохранить значение суммы в форме переменной x :
Возможно вы заметили, что этот пример напоминает алгебру. Мы используем буквы и другие символы как представление чисел и количеств в формулах и уравнениях. Точно так же мы используем переменные как символические обозначения значений типа данных. Для использования правильного синтаксиса Go необходимо убедиться, что переменная находится с левой стороны любых уравнений.
Распечатаем значение x :
Go выводит значение 221 , поскольку переменная x была задана равной сумме чисел 76 и 145 .
Переменные могут представлять любой тип данных, а не только целые числа:
При печати любой из этих переменных Go возвращает эквивалент соответствующей переменной. Используем выражение присвоения для строкового типа данных slice :
Мы назначим значение []string <"one", "two", "three">переменной slice , а затем используем функцию fmt.Println для вывода этого значения посредством вызова slice .
Переменные выделяют небольшую область памяти компьютера, которая принимает заданные значения, ассоциируемые с этой областью.
Декларирование переменных
В Go имеется несколько способов декларирования переменных, а иногда может существовать несколько способов декларирования одних и тех же переменных и значений.
Мы можем декларировать переменную i типа данных int без инициализации. Это означает, что мы декларируем пространство для размещения значения, но не задаем начальное значение:
Так мы создали декларированную переменную i типа данных int .
Мы можем инициализировать значение с помощью оператора равенства ( =), как в предыдущем примере:
Обе эти формы декларирования называются в Go длинной декларацией переменной.
Также мы можем использовать короткую декларацию переменной:
В данном случае у нас имеются переменная i и тип данных int . Когда мы не указываем тип данных, Go подразумевает тип данных.
В связи с наличием трех способов декларирования переменных сообщество Go приняло следующие правила:
Использовать длинную форму var i int только если переменная не инициализируется.
Использовать короткую форму i := 1 при декларировании и инициализации.
Если вы не хотите, чтобы Go использовал подразумеваемый тип данных, но хотите использовать короткую декларацию переменной, вы можете заключить значение в желаемый тип, используя следующий синтаксис:
Использование длинной формы декларации переменной при инициализации значений не является общепринятым в Go:
Будет полезно следовать стандартной практике декларирования переменных, применяемой сообществом Go, чтобы другие пользователи могли легко читать ваши программы.
Нулевые значения
Все встроенные типы имеют нулевые значения. Любую выделенную переменную можно использовать, даже если ей никогда не назначалось значение. Мы видим нулевые значения следующих типов:
Мы использовали оператор %T в выражении fmt.Printf . Он предписывает функции вывести тип данных для переменной.
Поскольку в Go все значения имеют нулевое значение, у нас не может быть неопределенных значений, как в некоторых других языках. Например, в некоторых языках булево выражение может иметь значение undefined , true или false , то есть переменная может иметь три состояния. В Go булево выражение не может иметь более двух состояний.
Присвоение имен переменным: правила и стиль
Присвоение имен переменных отличается гибкостью, однако необходимо помнить некоторые правила:
- Имена переменных могут состоять только из одного слова (без пробелов).
- Имена переменных могут состоять только из букв, цифр и символов подчеркивания ( _ ).
- Имена переменных не могут начинаться с цифр.
Следуя этим правилам, рассмотрим допустимые и недопустимые имена переменных:
| Допустимо | Недопустимо | Причина недопустимости |
|---|---|---|
| userName | user-name | Дефисы не разрешены |
| name4 | 4name | Не могут начинаться с цифры |
| user | $user | Не могут содержать символы |
| userName | user name | Не могут состоять из нескольких слов |
Также при присвоении имен переменным следует помнить, что в этих именах учитывается регистр. Имена userName , USERNAME , UserName и uSERnAME представляют совершенно разные переменные. Лучше всего избегать использования сходных имен переменных в программе, чтобы и вы, и ваши нынешние и будущие коллеги по разработке, могли понимать систему переменных.
В переменных учитывается регистр, однако регистр первой буквы имени переменной в Go имеет особое значение. Если имя переменной начинается с заглавной буквы, это означает, что данная переменная доступна за пределами пакета, где она была декларирована ( экспортируемая переменная). Если имя переменной начинается со строчной буквы, она будет доступна только в том пакете, где она декларирована.
Email начинается с заглавной буквы и доступна в других пакетах, а password начинается со строчной буквы и доступна только в пакете, где она декларирована.
В Go часто используются очень короткие имена переменных. Если в качестве имени переменной можно использовать userName и user , согласно правилам будет правильно использовать вариант user .
Состав также имеет значение для краткости имени переменной. Как правило, чем меньше область существования переменной, тем короче имя переменной:
Мы используем переменную names в большей области, поэтому ей обычно присваивается более значимое имя, чтобы его было проще запомнить. Однако мы используем переменные i и n в следующей строчке кода, и не используем их после этого вообще. Это не помешает читать код и определять использование переменных или определять их значение.
Добавим несколько замечаний о стиле переменных. В состоящих из нескольких слов именах используется формат MixedCaps или mixedCaps , а не символы подчеркивания.
| Стандартный стиль | Нестандартный стиль | Почему нестандартный |
|---|---|---|
| userName | user_name | Символ подчеркивания нестандартный |
| i | index | i предпочтительнее index , поскольку он короче |
| serveHttp | serveHttp | Аббревиатуры следует писать с заглавной буквы |
Для стиля очень важна согласованность, а также использование единого стиля всеми членами команды.
Изменение назначения переменных
Как подразумевает слово «переменная», мы можем легко изменять переменные Go. Это означает, что мы можем связать другое значение с ранее назначенной переменной посредством переназначения. Возможность переназначения полезна, поскольку в ходе выполнения программы нам может понадобиться принимать генерируемые пользователем значения в уже инициализированных переменных. Также нам может потребоваться изменить назначение на что-то, что уже было определено ранее.
Знать о возможности переназначения переменных полезно при работе над большой программой, которую написал кто-то еще, и в которой неясно, какие переменные уже определены.
Присвоим значение 76 переменной i типа int , а затем назначим ей новое значение 42 :
В этом примере показано, что мы можем сначала назначить переменной i значение целого числа, а затем переназначить переменную i , назначив ей значение 42 .
Примечание: при декларировании и инициализации переменных можно использовать оператор := , однако если вы просто хотите изменить значение уже декларированной переменной, вам нужно использовать простой оператор равенства ( = ).
Поскольку язык Go предусматривает определение типов данных , мы не можем назначить один тип другому. Например, мы не можем назначить значение "Sammy" для переменной типа int:
Попытка назначения разных типов друг другу вызовет ошибку при компиляции:
Go не позволяет использовать имя переменной несколько раз:
Если мы попытаемся использовать краткое декларирование переменной несколько раз для одного и того же имени переменной, мы также получим ошибку компиляции. Это может произойти случайно, поэтому важно понять, что означает сообщение об ошибке:
Как и при декларировании переменных, присвоение переменным понятных имен повысит удобство чтения программы для вас и других разработчиков.
Назначение нескольких параметров
Go также позволяет присваивать несколько значений нескольким переменным в одной строке. Эти значения могут иметь разные типы данных:
В этом примере переменной j присвоено строковое значение "shark" , переменной k присвоено значение с плавающей точкой 2.05 , а переменной l присвоено целочисленное значение 15 .
Такой подход с назначением нескольким переменным нескольких значений в одной строке позволяет сократить количество строк в программном коде. При этом важно не нарушать читаемость при уменьшении количества строк кода.
Глобальные и локальные переменные
При использовании переменных в программе важно учитывать область действия переменной. Область действия переменной означает конкретные места, откуда она доступна в коде определенной программы. Не все переменные доступны из всех частей программы. Некоторые переменные глобальные, а некоторые — локальные.
Глобальные переменные существуют вне функций. Локальные переменные существуют внутри функций.
Давайте посмотрим на глобальные и локальные переменные в действии:
Здесь мы используем var g = "global" для создания глобальной переменной вне функции. Затем мы определяем функцию printLocal() . Внутри функции назначается и выводится локальная переменная l . Программа завершает работу вызовом printLocal() и выводом локальной переменной g .
Поскольку g — глобальная переменная, мы можем ссылаться на нее в printLocal() . Для этого изменим предыдущую программу:
Для начала мы декларируем глобальную переменную g , var g = "global" . В функции main мы вызываем функцию printLocal , которая декларирует локальную переменную l и выводит ее с помощью fmt.Println(l) . Затем printLocal выводит глобальную переменную g , fmt.Println(g) . Хотя переменная g не была определена внутри printLocal , она была доступна, поскольку декларировалась в глобальной области действия. В заключение функция main выводит g .
Теперь попробуем вызвать локальную переменную вне функции:
Локальную переменную нельзя использовать вне функции, в которой она назначена. Если мы попытаемся это сделать, при попытке компиляции будет выведено сообщение об ошибке undefined .
Давайте посмотрим на другой пример, где мы используем одинаковое имя для глобальной и локальной переменной:
В этой программе мы декларировали переменную num1 дважды. Во первых, мы декларировали num1 в глобальной области, var num1 = 5 , а затем в локальной области функции printNumbers , num1 := 10 . При выводе num1 из программы main мы получаем значение 5 . Это связано с тем, что программа main видит только определенные глобальные переменные. Однако, когда мы выводим num1 из функции printNumbers , она видит локальную декларацию и выводит значение 10 . Хотя printNumbers создает новую переменную с именем num1 и ей присваивается значение 10 , это не влияет на глобальный экземпляр num1 со значением 5 .
При работе с переменными также нужно учитывать, каким частям программы потребуется доступ к каждой переменной, и соответственно с этим использовать глобальные или локальные переменные. В программах Go вы видите, что локальные переменные встречаются чаще.
Константы
Константы похожи на переменные, однако они не могут быть изменены после декларирования. Константы полезны для определения значений, которые будут использоваться в программе многократно, но которые не должны быть изменяемыми.
Например, если мы хотим декларировать налоговую ставку для интернет-магазина, мы можем использовать константу и рассчитывать налог в разных частях нашей программы. Если в будущем ставка налога изменится, нам нужно будет изменить это значение только в одном месте в программе. Если бы мы использовали переменную, существовала бы вероятность случайного изменения значения в программе, что привело бы к неверному расчету.
Мы можем использовать следующий синтаксис для декларирования константы:
Если мы попытаемся изменить константу после декларирования, при компиляции возникнет ошибка:
Константы могут быть нетипированными . Это может быть полезно при работе с числами, например, с целочисленными данными. Если константа нетипированная , она явно конвертируется, а с типированными константами этого не происходит. Посмотрим, как мы можем использовать константы:
Если вы декларируете константу с типом, это будет точный тип. Здесь, если мы декларируем константу leapYear , мы определяем ее как тип данных int32 . Это типированная константа, то есть она может работать только с типами данных int32 . Декларируемая нами константа year не имеет типа, и поэтому считается нетипированной . Поэтому вы сможете использовать ее с любым типом целочисленных данных.
При определении hours подразумевался тип int , поскольку мы явно не присвоили тип, hours := 24 . При декларировании minutes мы явно определили тип int32 , minutes := int32(60) .
Теперь внимательно изучим каждый расчет и определим, почему он работает:
В данном случае hours имеет тип int , а years — нетипированная величина. При компиляции программы явно выполняется конвертация years в int , благодаря чему операция умножения успешно выполняется.
В данном случае minutes имеет тип int32 , а year — нетипированная величина. При компиляции программы явно выполняется конвертация years в int32 , благодаря чему операция умножения успешно выполняется.
В данном случае minutes имеет тип int32 , а leapYear — типированная константа int32 . Здесь компилятору не нужно ничего делать, поскольку обе переменные уже относятся к одному типу.
Если мы попытаемся выполнить умножение двух типированных типов , которые не совместимы друг с другом, компиляция не будет выполнена:
В данном случае hours подразумевается как int , а leapYear явно декларируется как int32 . Поскольку Go — типированный язык, int и int32 несовместимы в математических операциях. Для их умножения потребуется конвертировать один из них в тип int32 или int .
Заключение
В этом обучающем модуле мы рассмотрели несколько распространенных примеров использования переменных в Go. Переменные — важный элемент программирования. Это символы, заменяющие значения типа данных, используемого нами в программе.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
Variables in Go (Golang)
Now let’s check out the current tutorial. Below is the table of contents for the current tutorial.
Table of Contents
What is variable
A variable is the name of a memory location. That memory location may store a value of any type. So each variable has a type associated with it which determines the size and range of that variable and also the operations defined on that variable.
Naming Conventions
- A variable name can only start with a letter or an underscore.
- It can be followed by any number of letters, numbers or underscores after that
- Go is case sensitive so uppercase and lowercase letters are treated differently.
- The variable name cannot be any keyword name in Go
- There is no limit on the length of the variable name.
- But it is advisable to have the variable name of optimum length.
Declaring a variable
In GO variables are declared using the var keyword but there are other ways of declaring a variable too as we will see later in this tutorial. Let’s explore different ways of declaring a variable
Single variable declaration without initial value
Below is the format of a single variable declaration without initial value being assigned. First is the var keyword, second is the variable name and third is the variable type. Also note when the value is not provided , then the variable is initialised with the default value of that type which is also known as zero value of that type. In Go default value or zero value of int is zero
var <variable_name> <type>
See the below example, it declares a var named aaa of type int
Output: It will print the default value of int which is zero
Single variable declaration with initial value
Below is the format of a single variable declaration with initial value being assigned. Everything is same as above, only thing additional is that we assign value to the variable at the end
var <variable_name> <type> = <value>
See below example, it declares a var named aaa of type int and gives a value 8 to it
Output:
Multiple variable declaration without initial value
Below is the format of a multiple variable declaration without initial value being assigned. Please note only variables of same type can be declared together. The type comes at the end
var <name1>, <name2>,….<nameN> <type>
See below example
Output: It will print the default or zero value of int which is zero for both aaa and bbb
Multiple variable declaration with initial value
Below is the format of a multiple variable declaration with initial value being assigned. Please note only variables of same type can be declared together. The type comes at the end
var <name1>, <name2>, …. <nameN> <type> = <value1>, <value2>, …. <valueN>
See below code example. Variable aaa and bbb are given a value of 8 and 9 respectively in a single declaration
Output:
Declare variables of different types
Below is the format for declaring multiple variables with different types. Value can or cannot be assigned to the variable at that time. Variables for which value is not assigned will get default value of that type. In below example we see three declarations.
Output:
Variable Declaration with no type or Type Inference
Variables can also be declared without specifying the type.
The GO compiler based upon the value assigned to the variable will figure out the type. So if the variable has an initial value, then the type can be omitted. This is also called Type Inference. Below is the format for such declaration
var <varialbe_name> = <value>
Below is the type inference table for basic types int, float, complex numbers, string, boolean, characters. It basically means that if the value is an integer the type of the variable inferred will be int, if the value is a float then type of the variable inferred will be float64 and so on based upon below table.
| Integers | int |
| Floats | float64 |
| Complex Numbers | complex128 |
| Strings | string |
| Booleans | bool |
| Characters | int32 or rune |
For other types such as Array, Pointer, Structure, etc, type Inference will happen based on the value. Let’s see a working example of the above point. Notice that type of t is correctly inferred as int as the value assigned to it is 123 which is int. Similarly type of u is also correctly inferred as string as the value assigned to it is a string.
Also notice that the type of variable z is inferred correctly as a struct main.sample
Output:
Short variable declaration
Go provides another way of declaring variables which is using the := operator. When := operator is used both var keyword and type info can be omitted. Below is the format for such declaration
Type inference will happen as explained above. Let’s see a working example
Output
Some points to be noted about the := operator
- := operator is only available within a function. It is not allowed outside the function.
- A variable once declared using := cannot be redeclared using the := operator. So below statement will raise a compiler error “no new variables in the left side of :=” .
- := operator can also be used to declare multiple variables in a single line. See below example
- In case of multiple declaration, := can also be used again for a particular variable if atleast one of the variables on left hand side is new. See below example. Notice that b is again declared using := This is only possible if atleast one of the variable is new which is variable c here. In this case it acts as a assignment for variable b
Output:
Important Points
- A unused variable will be reported as a compiler error. GO compiler doesn’t allow any unused variable. This is an optimization in GO. Same is applicable for constant too as we will see later. For eg below program will raise a compiler error
- A variable declared within an inner scope having the same name as variable declared in the outer scope will shadow the variable in the outer scope.
Output:
- Variable Expression – While the declaration variable can also be assigned an expression or a function call. See the below example.
- Variable a is declared with expression 5 +3
- Variable b is declared with a function call math.Max(4, 5), whose result will be assigned to b at run time.
Output:
- A variable once intialized with a particular type, cannot be assigned a value of different type later. This is applicable for short hand declaration is well. See below example
Output:
Variable aaa has been assigned a type of int, hence compiler raises error on assigning a value of type string to it. For variable bbb, the type inferred is int, hence it also raises a compiler error on assigning a value of type string to it.
Scope of a Variable (Local and Global Variable)
A variable declaration can be done at the package level or a function level or a block level. Scope of a variable defines where that variable is accessible and also the life of the variable. Golang variables can be divided into two categories based on scope
- Local Variable
- Global Variable
Local Variable
- Local variables are variables which are defined within a block or a function level
- An example of the block is a for loop or a range loop etc.
- These variables are only be accessed from within their block or function
- These variables only live till the end of the block or a function in which they are declared. After that, they are Garbage Collected.
See below example
- i is not available after the for loop
- Similarly aaa is not available outside the function in which it is declared.
Hence below program will raise compiler error
Code:
Global Variable
- A variable will be global within a package if it is declared at the top of a file outside the scope of any function or block.
- If this variable name starts with a lowercase letter then it can be accessed from within the the package which contains this variable definition.
- If the variable name stats with a uppercase letter then it can be accessed from outside different package other than which it is declared.
- Global variable are available throughout the lifetime of a program
For example in below program variable aaa will be a global variable available throughout main package. It will be available in any function inside main package. Do note that variable name will not be available outside main package as its name starts with a lowercase letter.
Output:
Conclusion
This is all about variables in golang. Hope you have liked this article. Please share feedback or improvements or mistakes in comments.
Next Tutorial – All basic data types
Previous Tutorial – Packages and Modules – Part 2