Программа go это что

Содержание

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

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

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

История развития Go

Язык Go элегантен и прагматичен, но некоторые его особенности имеют смысл только под определенным историческим контекстом. История Go начинается с Си. Во многих отношениях Си стал основой для создания JavaScript, Ruby, Python, C++, C# и Java. Компиляторы или интерпретаторы некоторых из этих языков даже написаны на Си. Влияние Си легко заметить во многих языках.

Установка языка программирования Go, среды разработки. Создание и компиляция первой программы

Он был разработан Денисом Ритчи для создания ядра Unix и потом использовался для создания ядра Linux.

Язык Go был создан легендами эпохи Unix и Си. Работая Google, Роберт Грисемер, Роб Пайк и Кен Томпсон были разочарованы в Си-языках из-за их проблем. Бъярн Страуструп, создать C++ говорил так: «Си позволяет легко выстрелить себе в ногу, в C++ это сложнее, но если вы все же выстрелите, то взорвете ногу целиком».

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

Язык Java выбирают многие крупные компании с большими командами разработчиков. Go перенимает и этот плюс у Java и пытается быть отличным языком для больших групп разработчиков. Язык Go не имеет таких недостатков объективно ориентированного программирования, как наследование. Все реализуется с помощью лаконичного синтаксиса интерфейсов.

Также можно найти определенное сходство с динамическими языками, Go перенимает стиль написания кода у Python, настраиваемость у Ruby и простой параллелизм, вшитый в ядро языка, как у Node.js. Все начиналось, как язык, решающий некоторые проблемы Си и выросло в прекрасный язык программирования общего назначения.

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

Перед тем как мы перейдем к примерам написания программ, хотелось бы немного поговорить про синтаксис языка.

1. Синтаксис языка Go

Самое главное о чем стоит сказать — это структура программы. Она чем-то похожа на Java и Python. Программа разделяется на так называемые пакеты Package, которые можно рассматривать как альтернативу include или модулей в Python. В дополнение package позволяют настраивать области видимости для переменных. Импортируется пакет в программу с помощью инструкции import:

Программа для кладоискателя Go Detect. Новая программа для кладоискателя от XP Detectors

import имя_пакета

Любая программа будет иметь переменные. Go — это язык со строгой типизацией, поэтому каждую переменную перед использованием нужно объявить и указать ее тип:

var имя_переменной тип

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

var имя_переменной := значение

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

var *имя_переменной тип

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

имя_пакета . имя_переменной
имя_пакета . имя_функции

Основные управляющие инструкции очень схожи по своему синтаксису с привычными в Си:

if условие
действия
>

Цикл for тут точно такой, как и в Си, только без круглых скобок, так выглядит даже проще:

for i := 0; i
действия
>

Функции golang объявляются с помощью директивы func, и в ней можно указать не только параметры, но и возвращаемые переменные:

func имя_функции (принимаемые переменные) (возвращаемые переменные)
действия
>

Важно заметить, что точка с запятой после строк не ставиться. Вместо ООП классов в Go используются структуры, которые могут иметь поля и методы, а также могут реализовать интерфейсы. Чтобы объявить структуру используется инструкция type:

type имя_структуры struct
имя_поля тип_поля
>

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

func ( имя_указателя *тип_структуры ) имя_метода()
действия
>

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

имя_объекта . имя_метода (параметры)

К полям мы тоже обращаемся через точку:

имя_объекта . имя_поля

Теперь вы знаете основы языка и пришло время перейти ближе к практике. Дальше будет программирование на Go и примеры Golang, минимум теории.

2. Создание Hello World

Напишем нашу первую программу, как принято, это будет программа, которая выводит на экран строчку «Привет мир!». Вы можете установить Go в свою систему или же воспользоваться онлайн сервисом play.golang.org, который позволяет выполнять программы прямо в браузере. Мы будем работать с онлайн сервисом.

При открытии сайта вы увидите уже готовый код первой программы:

Как видите, синтаксис почти соответствует тому, что мы рассматривали ранее. В первой строке мы указываем, что этот файл относиться к пакету main, во второй импортируем пакет fmt, отвечающий за стандартные функции ввода и вывода. Скобки здесь нужны чтобы за один раз импортировать несколько пакетов, можно просто добавить имена через запятую.

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

Внутри функции main мы вызываем функцию библиотеки fmt, которую импортировали ранее с помощью синтаксиса точки. Метод printLn выводит строчку на экран.

Для языка Go был принят определенный синтаксис. Даже если компилятор не будет выдавать ошибок из-за несоответствия, его лучше соблюдать. Для имен переменных принято использовать верблюжий синтаксис, то есть FooBar или Foobar вместо foo_bar. А также обратите внимание, что Go не терпит никаких символов перед открывающей скобкой. Даже если поставить перевод строки, вы получите ошибку:

Также в Go стандартизированы отступы, хотя здесь нет таких требований, как в Python.

3. Основы языка Go

Рассмотрим работу с переменными и структурами. Это будет полезно начинающим пользователям. Как я уже говорил, язык имеет статическую типизацию. В Python, Ruby или JavaScript нужно выполнять множество проверок на правильность. Go избавляет от этой проблемы. Например, усложним наш предыдущий пример:

В этом примере, за вывод отвечает новая функция — print. Здесь явно указано, что ей нужно передать строку (string). А в функции main мы создаем переменную типа string и передаем ее в print. Если передать что-то другое, получим ошибку. Если, например, вы поменяете тип переменной на int, то получите это:

cannot use «Привет мир!» (type string) as type int in assignment

Выводы

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

Источник: losst.pro

10 главных конструкций языка Go

Это краткое руководство по основным конструкциям языка Go для тех, кто только начинает разбираться в языке. Зачем? Чтобы был.

Точка с запятой после команд в Go не ставится.

Структура программы

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

// название программы (пакета) package main // подгружаем нужные пакеты, если команды из этих пакетов понадобятся в нашей программе import «fmt» // основная функция — main — означает, что её содержимое и будет выполняться после запуска программы // кроме неё в программе может быть сколько угодно других функций func main() < // содержимое функции fmt.Println(«Hello World») >

Переменные, константы и типы данных

Переменная (может менять значение в любой момент): var .

Константа (не может менять значение после объявления): const .

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

var x string // строковая переменная с заданным значением, которое можно менять // для этого сразу после объявления переменной можно написать её стартовое значение var x1 string = «Привет, это журнал Код» // целые числа var y int var y1 int32 = 42 // дробное число var z float32 = 22.2

Ввод и вывод

Что подключить: библиотеку fmt: import «fmt»

Вывод:

Print() ← выводим что-то и оставляем курсор на этой же строке
Println () ← выводим что-то и переводим курсор на новую строку
Printf() ← чтобы вставлять значения переменных в текст

func main() < // оставляем курсор на той же строке fmt.Print(«Привет,») // готовим переменную для вывода fmt.Println(» это журнал Код») var output int32 = 50 // Вставляем переменную в середину вывода fmt.Printf(«За 2010 год я проехал %v городов, «,

Ввод:

Scan(
Scanf(%формат, fmt.Print(«Введите число») // готовим переменную для ввода var input float64 // читаем данные с клавиатуры и ждём от пользователя ввода дробного числа fmt.Scanf(«%f», input2) >

Присваивание и сравнение

Присваивание обозначается одним знаком равно, а проверка на равенство — двумя.

// присваивание y = 10 var y1 int32 = 42 // сравнение fmt.Print(y1 == 10)

Условный оператор if

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

package main import «fmt» func main() < // если условие верное if «Apple» < // то выполняем то, что идёт в скобках fmt.Println(«Введите свой логин и пароль») // если условие не выполнилось, то можно сразу проверить ещё одно условие // так можно делать сколько угодно раз >else if < // выводим второй ответ fmt.Println(«Ваша операционная система не поддерживается») // выполняем то, что относится к последнему if >else < fmt.Println(«Ошибка ввода») >>

Оператор множественного выбора switch

После первого найденного варианта оператор выполняет нужные действия и прекращает работу.

// перебираем возможные варианты для переменной ID switch ID < // проверяем одно значение case «Apple»: fmt.Println(«Введите свой логин и пароль») // проверяем второе значение case «Google»: fmt.Println(«Ваша операционная система не поддерживается») // если ничего нужного не нашлось default: fmt.Println(«Ошибка ввода») >

Цикл с предусловием for

Самый простой цикл — можно объявить только условие, а остальное сделать внутри цикла:

package main import «fmt» func main() < // переменная для цикла var count = 10 // пока переменная больше 0 — цикл работает for count >0 < // выводим текущее значение переменной fmt.Println(count) // уменьшаем её на единицу count = count — 1 >>

Ещё есть варианты цикла for как в С или С++ — с переменной, условием и шагом цикла:

Получите ИТ-профессию

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

Источник: thecode.media

Почему язык Go? Важные преимущества

Правда ли, что на Go правильный, понятный и хорошо работающий код писать проще, чем на Java и Python?

28 мая 2019 8 минут 30874

Автор статьи
Мария Лисянская

Автор статьи
Мария Лисянская
https://gbcdn.mrgcdn.ru/uploads/post/1938/og_image/102340e448ea25201d9b4c0fc8c75f2d.jpg

Стефан Нильссон преподает информатику в Королевском технологическом институте Стокгольма и очень много пишет о языке Go. Предлагаем вам перевод его статьи Why Go? — Key advantages you may have overlooked, где он рассказывает о главных плюсах языка. Статья ориентирована на читателей, уже знакомых с основами программирования, в том числе на Java и/или Python.

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

Как профессор информатики и разработчик, много лет использующий Go и Java, я хочу поделиться мыслями и объяснить, почему я ставлю Go выше, чем Java или Python. И почему с ним мне гораздо проще писать хороший код.

Go — мой основной язык с 2012 года. До этого, с 1998 года, я использовал Джаву, а еще раньше — Си. Python нужен мне главным образом в преподавательской работе.

Заниматься программированием я начал в далеком 1978 году. Тогда я писал для калькулятора TI-57, с его программной памятью на 50 шагов и 8 регистрами.

Минимализм

Go — минималистичный язык, и это (по большей части) очень хорошо.

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

«Ядро» Go составляют простые ортогональные конструкции, которые можно сочетать сравнительно малым числом способов. Это упрощает изучение языка, чтение и написание кода.

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

Некоторые из ключевых особенностей Go:
- Полноценные встроенные фреймворки для тестирования и профилирования программ компактны и просты в изучении. Скорее всего, вам не понадобится ни один из многочисленных аддонов от сторонних разработчиков.
- Можно отлаживать и профилировать оптимизированный бинарник, который уже запущен в production на HTTP-сервере.
- Документация к языку Go генерируется автоматически и содержит примеры, которые можно запускать прямо на странице справки [для этого под каждым листингом есть кнопка Run — прим. пер.]. Опять же, интерфейсы минималистичны и не требуют долгого изучения.
- Go — язык с сильной статической типизацией и явным приведением типов, но его синтаксис на удивление необременителен. Все благодаря нетипизированным числовым константам и определению типа по присвоенному значению. Как результат, в работе с типами Go безопаснее, чем Java (где есть неявное приведение). При этом его код по легкости чтения ближе к Питону, где есть нетипизированные переменные.
- Программы на языке Go состоят из пакетов, что позволяет понятно делить код и легко управлять зависимостями. Механизм пакетов — пожалуй, в числе наиболее удачно реализованных в языке. И самых недооцененных.
- Структурно типизированные интерфейсы обеспечивают динамический полиморфизм за счет динамической диспетчеризации.
- Конкурентность — неотъемлемая часть Go, для нужд которой в языке есть горутины, каналы и оператор select. Чем конкурентность отличается от параллелизма, можно посмотреть здесь.
Небольшие примеры кода, описание базовых типов данных, методов и управляющих структур вы также найдете в статье «Go vs. Java: 15 главных отличий».

Задел на будущее

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

Вот универсальный ответ проектировщиков языка на вопрос «Почему в Go нет такой-то функции?».

Каждый язык предлагает новые возможности и не содержит чьих-то любимых. Go был создан с прицелом на удобство программирования, быструю компиляцию, возможность влиять на одну концепцию, не затрагивая другой, и необходимость поддерживать такие вещи, как параллелизм и сбор мусора. Ваша любимая «фишечка» могла сюда не вписаться, потому что увеличивает время компиляции или снижает ясность синтаксиса. Или потому, что она усложнила бы всю модель языка [принципы построения программ — прим. пер.].

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

Вот наиболее вероятные кандидаты на добавление в Go 2:
- Управление пакетами с помощью модулей, поддержка которых уже была частично реализована в Go 1.11.
- Обобщенное программирование — концептуальная схема, реализация которой в Go уже запланирована во второй версии языка. Пока вместо обобщенного кода (дженериков) можно использовать альтернативы и обходные пути, расписанные вот здесь.
- Новая система обработки ошибок — пока тоже на стадии проекта — может заменить нынешние упрощенные механизмы.
Сейчас на рассмотрении более мелкие усовершенствования, которые помогут организовать и опробовать разработку Go с упором на инициативу сообщества.

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

Сравнение с Java

Спецификация языка Java® сейчас насчитывает 750 страниц. Сложность изучения связана в первую очередь с перегруженностью «фишками» [явление известно как feature creep — прим.пер.].

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

Дженерики в Java, использующие стирание типов (type erasure), делают код яснее и позволяют выполнять дополнительные тесты во время исполнения программы. Но когда нужно выйти за рамки простейших примеров, работа с дженериками усложняется. Вы не можете создавать массивы дженериков, а шаблоны параметров (type wildcards) с нижней и верхней границей довольно сложны. Слово «дженерик» фигурирует в спецификации 280 раз. Лично я не уверен, стоила ли эта штука усилий, затраченных на ее реализацию.

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

Прозрачность кода

Блок обработки данных суперкомпьютера ILLIAC IV

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

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

Другой пример: Go не скомпилирует программу, если она требует каких-то пакетов (через import), но в реальности не использует их в коде. Такой подход повышает ясность кода, а в долгосрочной перспективе — его производительность.

Подозреваю, что создатели Go нарочно усложнили некоторые вещи. Например, надо очень постараться, чтобы поймать исключение (панику). Причем, чтобы переступить через типобезопасность, вам придется пометить свой код ключевым словом unsafe.

Сравнение с Python

В Python фрагмент кода del a[i] удаляет элементы с индексом i из списка a. Этот код, конечно, вполне читаем, но не прозрачен: легко упустить из вида, что временная сложность алгоритма представлена как O(n), где n — число элементов списка.

У Go нет такой полезной функции. Это не так удобно, зато более прозрачно. Если вы копируете элемент списка, вам нужно явно указать это в коде. Смотрите пример кода: 2 способа удалить элемент из среза в Go. Но можно и проще — с помощью аppend.

Сравнение с Java

Прозрачность кода — проблема не надуманная. Вот пара примеров того, как правила инициализации пакетов и порядка выполнения кода в Go упрощают поддержку и доработку проекта:
- Циклические зависимости могут вести к нежелательным последствиям. В отличие от кода на Java, Go-программа с зацикленной инициализацией не скомпилируется.
- Программа на Go завершает работу только из функции main. Java-приложение закрывается после завершения всех пользовательских потоков, не являющихся демонами.
Это значит, что для понимания особенностей в работе Java-приложения нужно изучить большие фрагменты его кода. Это может быть и вовсе невозможно, если вы используете сторонние библиотеки.

Совместимость

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

Для первой версии Go были кратко и сжато сформулированы гарантии совместимости для языкового «ядра» и стандартных библиотек: программы на Go, которые работают сегодня, должны работать и с будущими версиями Go 1. До сих пор обратная совместимость соблюдается безукоризненно.

Go — это проект с открытым кодом и BSD-подобной лицензией, которая разрешает коммерческое использование, внесение изменений, распространение и личное пользование.

Права интеллектуальной собственности принадлежат авторам Go и тем из нас, кто внес вклад в развитие проекта. Кроме того, Google предоставляет пользователям патент на интеллектуальную собственность, распространяемую корпорацией в рамках проекта Go.

Сравнение с Python

Если вы Python-разработчик, вам приходилось мучаться с различиями между Python 2.7.x and Python 3.x. И хотя есть веские основания выбирать Python 3, если вы используете библиотеки, доступные только для 2.7, у вас может не быть выбора.

Сравнение с Java

У языка Java очень хороший опыт обратной совместимости и подробное руководство по совместимости для JDK 8. Плюс, Java долгое время был в свободном доступе для разработчиков.

К сожалению, на горизонте сгущаются тучи. Причиной тому — судебное разбирательство между Oracle America и Google о сущности компьютерного кода, авторском праве и новой модели лицензирования Java от Oracle.

Производительность

Снаружи Go неброский, но под капотом у него — прекрасно отлаженный движок.

Бессмысленно обсуждать производительность вне контекста. Такие параметры программы, как время исполнения и потребление памяти, сильно зависят от алгоритмов, структур данных, входных данных, мастерства программиста, операционной системы и «железа».

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

Прежде всего, Go — компилируемый язык. Готовое к запуску Go-приложение обычно выглядит как один исполняемый файл без отдельных динамических библиотек или виртуальных машин, которые можно было бы напрямую разворачивать.

Объем и скорость генерации машинного кода зависят от целевой архитектуры. Генерация кода Go довольно хорошо проработана и поддерживает все основные ОС (Linux, macOS, Windows) и архитектуры (Intel x86/x86-64, ARM64, WebAssembly, ARM и др.). Поэтому от go-приложений можно ждать производительности на уровне C++ или Java. Выигрыш относительно интерпретируемого кода на Python может быть огромным.

В Go есть сборщик мусора, что предотвращает утечки памяти. Причем задержка в работе сборщика минимальна. На деле вы можете даже не замечать, что «поток-мусорщик» запущен.

Практически все стандартные библиотеки исполнены очень качественно: их код оптимизирован по эффективным алгоритмам. К примеру, регулярные выражения в Go работают настолько хорошо, что время исполнения напрямую зависит от объема ввода. К сожалению, с Java и Python все иначе.

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

Источник: gb.ru

Golang: основы для начинающих

Golang, или Go — язык программирования, начало которого было положено в 2007 году сотрудниками компании Google. В этом руководстве по Golang мы рассмотрим, как установить необходимое ПО и написать свою первую программу.

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

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

Devops-инженер МТС , Санкт-Петербург, Москва, можно удалённо , По итогам собеседования

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

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

Настройка окружения

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

UNIX / Linux / MacOS / FreeBSD

Извлекаем скачанный архив в папку /usr/local/go . Например:

tar -C /usr/local -xzf go1.16.linux-amd64.tar.gz

Добавляем папку /usr/local/go/bin в переменную окружения PATH :

export PATH=$PATH:/usr/local/go/bin

Windows

Используем MSI файл и следуем инструкциям. По умолчанию инструменты Go размещаются в папке С:Go . При установке папка C :Gobin автоматически добавится в системную переменную PATH .

Чтобы изменения вступили в силу, перезапустим все открытые окна эмуляторов терминала.

Проверяем корректность установки, создав и выполнив файл C:ProjectsGotest.go :

package main import «fmt» func main()

Выполним этот код и получим следующий результат:

Синтаксис

Пакеты

Каждая программа на языке Go состоит из пакетов (packages). Пакет main — главный, с него начинается выполнение программы. В приведённом выше примере импортируется пакет fmt .

Импорт

Импорт пакетов можно описать двумя способами.

import «fmt» import «math»
import( «fmt» «math» )

Функции

Общая форма определения функции выглядит следующим образом:

func function_name( [список параметров] ) [возвращаемые типы данных]

Количество и тип входных аргументов может быть любым. Для примера опишем функцию add с двумя входными параметрами формата int :

package main import «fmt» func add(a int, b int) int < return a + b >func main()

Выполним этот код и получим следующий результат:

Переменные

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

var [перечень переменных] [тип данных];

С помощью оператора var определяем перечень переменных, причём тип данных указываем в конце выражения.

Объявление возможно как на уровне пакета, так и на уровне функции. Рассмотрим пример:

package main import «fmt» var node, golang, angular bool func main()

Выполним этот код и получим следующий результат:

Оператор цикла

В языке Go один оператор цикла — это for , который повторяет список инструкций заданное количество раз. Цикл состоит из трёх выражений:
1. Инициализация. Выполняется перед первой итерацией.
2. Условие. Вычисляется перед каждой итерацией.
3. Инкремент. Выполняется после каждой итерации.
Общая форма цикла выглядит так:

for [условие | (инициализация; условие; инкремент) | диапазон]

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

Цикл останавливает свою работу, когда условие принимает значение false .

Примечание В отличие от таких языков, как C, Java и JavaScript, перечисленные выражения цикла не выделяются скобками. В данном случае обязательны лишь фигурные скобки, обрамляющие тело цикла.

Рассмотрим пример программы:

package main import «fmt» func main() < sum := 0 for i := 0; i < 8; i++ < sum += i >fmt.Println(«Сумма равна «, sum) >

Выполним этот код и получим следующий результат:

Условный оператор

Форма определения условного оператора в Go выглядит следующим образом:

if [условие]

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

Условие описывается значением, переменной или выражением. Например:

Рассмотрим пример программы:

package main import ( «fmt» ) func main() < if true < fmt.Println(«Это выражение выполнится всегда») >if false < fmt.Println(«Это выражение не выполнится никогда») >>

Выполним этот код и получим следующий результат:

Массивы

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

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

var наименование_переменной [размер] тип_переменной

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

var balance [10] float32

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

var balance = []float32

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

Рассмотрим пример программы:

package main import «fmt» func main() < var a [2]string a[0] = «Привет» a[1] = «Tproger» fmt.Println(a[0], a[1]) fmt.Println(a) primes := [6]intfmt.Println(primes) >

Выполним этот код и получим следующий результат:

Срезы

Срезы (Slices) в Go — абстракция над массивами. Хотя встроенных способов увеличить размер массива динамически или сделать вложенный массив в Go нет, срезы убирают это ограничение. Они предоставляют полезные функции и широко используются программистами.

Объявить срез можно как массив, но без указания размера или с помощью функции make :

var numbers []int /* срез неопределённого размера */ /* numbers = []int */ numbers = make([]int,5,5) /* срез длиной и ёмкостью равной 5 */

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

Тип []T — срез с элементами типа T .

a[0:5] — срез 5 элементов массива a .

Рассмотрим пример программы:

package main import «fmt» func main() < primes := [6]intfmt.Println(primes) var s []int = primes[1:4] fmt.Println(s) >

Выполним этот код и получим следующий результат:

Структуры

Структура (structure) — пользовательский тип данных, который кроме прочего комбинирует элементы разных типов. Чтобы объявить структуру, используем выражения type и struct .

Struct определяет тип данных, которому соответствует два и более элементов.

Type связывает заданное имя с описанием структуры.

Форма описания выглядит следующим образом:

type struct_variable_type struct

Как только структура типа определена, он может использоваться при объявлении новых переменных:

variable_name := structure_variable_type

Чтобы получить доступ к элементам структуры, используем оператор доступа к элементу. Рассмотрим на примере:

package main import «fmt» type Vertex struct < X int Y int >func main() < v := Vertexv.X = 4 fmt.Println(v.X) >

Выполним этот код и получим следующий результат:

Чем Golang хорош для начинающих?

Концепция языка Golang разработана на основе опыта решения повседневных задач и не преследует цель сделать прорыв в программировании. Кроме того, Go не реализует ряд функций, которые делают другие языки (C++, Java и Python) настолько мощными. Но есть три причины, чтобы задуматься об использовании этого языка.

Читабельность

Как только привык к синтаксису Go, прочесть чужой код — тривиальная задача.

У каждого человека собственный «правильный» способ делать вещи, поэтому Go навязывает свой стиль программирования. В результате вопросы вроде использования или неиспользования фигурных скобок отпадают, и остаётся только писать код по заданным правилам. Поэтому Golang подходит для начинающих.

Скорость

За короткий промежуток времени можно написать быструю программу.

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

Меньше ошибок

Большинство ошибок возникают в непроверенном или сложном коде.

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

Заключение

Если хотите погрузиться глубже в изучение, посмотрите нашу подборку бесплатных книг по знакомству с языком программирования Go, а главное — начните создавать маленькие программы, чтобы на практике понять тонкости языка. Удачи!

Источник: tproger.ru