Язык go примеры программ

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

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

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

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

Первая программа на языке программирования Go — как начать программировать на 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. Фёдор Короткий

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, одна из них — это структуры. Давайте еще больше усложним нашу программу, создадим структуру site, с полями name и url, которая будет описывать какой-либо сайт:

В структуры будет метод print, который выводит строку «Добро пожаловать. «. В методе main мы инициализировали структуру и присвоили ее полям значения, а затем вызвали метод print.

Язык программирования Go имеет еще множество интересных особенностей и возможностей. И до большинства из них мы даже не приблизились. Если вы хотите научиться плавать, вам надо прыгать в воду. Только благодаря практике вы сможете свободно применять этот язык.

Выводы

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

Обнаружили ошибку в тексте? Сообщите мне об этом. Выделите текст с ошибкой и нажмите Ctrl+Enter.

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

Golang: Основной синтаксис

В настоящее время существует так много популярных языков программирования, которые используются для создания сервисов и систем, таких как Node.js, PHP и Python. И все они имеют свои преимущества и недостатки, и от этого сильно зависит то, для чего программист будет использовать тот или иной язык программирования. Если вам нужно написать программу с очень эффективным параллелизмом, но все еще читаемую, я познакомлю вас с этим языком, Go (он же Голанг).

Цель этой статьи — показать вам, как написать программу на Go. Я расскажу вам о часто используемом синтаксисе и покажу некоторые советы и приемы, о которых вы могли не знать в Go. В любом случае, вы также можете найти официальный учебник по Go на https://tour.golang.org/ для получения более подробной информации, но если вы хотите быстро изучить и понять Go и получить некоторые хитрости, эта статья — то, что вам нужно.

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

Прежде всего, если в вашей системе нет компилятора Go, перейдите по адресу https://golang.org/dl/, чтобы загрузить подходящий для вас установщик с вашей системой и установить в его, после чего вы сможете создать и запустить код Go.

Синтаксис

Основной код Go

package main import «fmt» func main()

Как выполнить программу Go

$ go run bye_asteroid.go // build and run Bye, asteroid! $ go build -o bin test.go // build $ ./bin // and run Bye, asteroid!

Go — это компилируемый язык, как C / C ++, поэтому он работает быстрее, чем некоторые интерпретируемые языки, такие как Node.JS и Python. Приведенный сценарий показывает, как выполнить код без создания двоичного файла (Golang создает двоичный файл для команды запуска, но двоичный файл скрыт), а также показывает, как создать и запустить его двоичный файл.

Приведенный выше код является очень простой программой для отображения текста «Bye, asteroid!» (Поскольку астероид только что прошел нашу землю 10 августа). Golang имеет концепцию пакетов, которая позволяет программистам создавать свои пакеты и позволяет импортировать пакеты других разработчиков. Вы можете увидеть в приведенном выше коде ключевое словом package, это основной пакет, который является корневым для каждой программы Go. А внутри основного пакета есть main функция, которая также является (второй) первой функцией, запускаемой после выполнения программы Go.

Почему я сказал «второй»? Потому что есть функция «init»,которая является фактически первой функцией, которая должна быть выполнена перед выполнением функции «main».

package main import «fmt» func init() < fmt.Println(«Hello, world!») >func main() < fmt.Println(«Bye, asteroid!») >/* >>> RESULT

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

Пакеты

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

Одно важное правило для создания пакета: «в одной папке должен быть только один пакет»

Не беспокойтесь! Возможно, вы не поймете код в примере, но я объясню вам об этом в следующих разделах.

Переменные

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

Объявление переменной

package main import «fmt» const globalConstant = 2.72 const ExportedGlobalConstant = 3.14 func main()

Есть три способа объявления переменной. Из приведенного выше примера первый — это объявление с указанием типа переменной вручную. Второй это объявление переменной без явного указания типа, тип присваивается автоматически. И третий также получает тип не явно, но без объявления переменной. Для третьего, он обязательно добавлять двоеточие (:) для объявления переменной.

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

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

Как получить доступ к глобальной переменной другого пакета.

// ./main.go package main import ( «fmt» «./data» ) func main() < fmt.Println(data.Message) >// ./data/data.go package data Message := «This is message from data package»

Типы переменных

package main import «fmt» func main() < a := 1 // var a int b := 3.14 // var b float c := «hi» // var c string d := true // var d bool fmt.Println(a, b, c, d) e := []int// slice e = append(e, 4) fmt.Println(e, len(e), e[0], e[1:3], e[1:], e[:2]) f := make(map[string]int) // map f[«one»] = 1 f[«two»] = 2 fmt.Println(f, len(f), f[«one»], f[«three»]) > /* >>> OUTPUT

В Go есть много типов переменных, но я показал вам только часто используемые в приведенном выше коде. Как и другие языки, Go имеет int, float, string и boolean в качестве примитивных типов.

В Go есть слайс, похожий на вектор в C ++ или список в Python, в который вы можете добавить элемент. Go на самом деле имеет массив, который очень похож на слайс, но имеет фиксированную длину.

И последний тип переменной в примере кода это map (похож на map в C ++ или dict в Python). Map используется для сопоставления ключа и значения.

package main import «fmt» type Person struct < Name string `json:»name»` Age int `json:»age»` isAdmin bool >func main() < p := Person< Name: «Mike», Age: 16, isAdmin: false, >fmt.Println(p, p.Name, p.Age, p.isAdmin) > /* >>> OUTPUT Mike 16 false */

Следующий тип — «структура». Он позволяет программистам определять новый тип данных, который содержит в себе другие типы данных (называемые полями).

Каждое поле может быть экспортировано по тому же правилу, что и глобальная переменная с первой заглавной буквой. Это означает, что поля «Name» и «Age» могут быть доступны другим пакетам, а isAdmin — нет. Поле может быть присвоен «tag» (например `json: «name»` ) в качестве метаданных для некоторых библиотек, таких как библиотека JSON, которая использует «tag» для сопоставления полей структуры Go и полей JSON.

Преобразование типов

package main import ( «fmt» «strconv» «reflect» ) func main() < a := 3.14 b := int(a) fmt.Println(b, reflect.TypeOf(b)) c := «12.34» d, _ := strconv.ParseFloat(c, 64) fmt.Println(d, reflect.TypeOf(d)) e := false f := fmt.Sprint(e) fmt.Println(f, reflect.TypeOf(f)) >/* >>> OUTPUT

Некоторые пары типов могут быть преобразованы путем непосредственного приведения (int(1.23), float(3), uint32(5)), но для некоторых требуется дополнительная библиотека для преобразования, такая как string-int, int-string, bool-string и string-bool.

Нулевые значения

package main import «fmt» func main() < var a int var b float64 var c bool var d string fmt.Println(a, b, c, d) var e []int var f map[string]float64 fmt.Println(e, f) type person struct< name string age int >var g person var h *person fmt.Println(g, h) > /* >>> OUTPUT */

Если вы объявляете переменную без присвоения ей какого-либо значения, значение переменной будет установлено равным нулевому значению ее типа. (Вам может быть любопытно, что такое *person и nil. Это указатель и его нулевое значение, для которого я создам отдельную статью, думаю, она будет следующей ).

Операции управления потоком

Условия

package main import «fmt» func main() < // if, else a := 5 if a >3 < a = a — 3 >else if a == 3 < a = 0 >else < a = a + 3 >fmt.Println(a) // switch, case b := «NO» switch b < case «YES»: b = «Y» case «NO»: b = «N» default: b = «X» >fmt.Println(b) > /* >>> OUTPUT

В Go есть операторы управления потоком, как и в других языках: if, else, switch, case , но в Go есть только один оператор цикла, который называется for. Потому что вы можете заменить выражение while на выражение for, как в примере ниже.

Цикл

package main import «fmt» func main() < // for c := 3 for i := 0; i < c; i++ < fmt.Print(i, » «) >fmt.Println() // replace while with for for c > 0 < fmt.Print(c, » «) c— >fmt.Println() // for with range d := []int for _, i := range d < fmt.Print(i, » «) >fmt.Println() > /* >>> OUTPUT

Как вы можете видеть в примере, вы можете использовать «for» для той же цели, что и «while» в других языках. Более того, вы можете перебирать некоторые итерируемые переменные, такие как array, slice и map, используя «range», он возвращает два значения: индекс / ключ и значение.

Defer

package main import «fmt» func main() < f() >func f() (int, error) < defer fmt.Println(«DEFER 1») defer fmt.Println(«DEFER 2») defer fmt.Println(«DEFER 3») fmt.Println(«BODY») return fmt.Println(«RETURN») >/* >>> OUTPUT

«Отложенное» утверждение — это специальное утверждение в Go. Вы можете вызывать любые функции после оператора defer . Функции будут храниться в стеке и будут вызываться после возврата функции вызывающей стороны. Как видно из примера, существует обратный порядок вызовов функций.

Функции

Функциональные компоненты

Функция Go состоит из 4 частей.

1. Имя: должно быть названо в camelCase / CamelCase.
2. Аргументы: функция может принимать ноль или более аргументов. Для двух или более последовательных аргументов одного и того же типа вы можете определить тип в конце последнего аргумента (например, «string» в примере).
3. Типы возврата: функция может возвращать ноль или более значений. Если возвращает более одного значения, вам необходимо заключить их в скобки.
4. Тело: это логика функции.

Возвращаемые значения

package main import «fmt» func main() < fmt.Println(threeTimes(«Thank You»)) >func threeTimes(msg string) (tMsg string) < tMsg = msg + «, » + msg + «, » + msg return >/* >>> OUTPUT

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

Экспортируемые / неэкспортируемые функции

package main import «fmt» func main() < s := Sum(10) f := factorial(10) fmt.Println(s, f) >func Sum(n int) int < // exported function sum := 0 for i := 1; i return sum > func factorial(n int) int < // unexported function fac := 1 for i := 1; i return fac > /* >>> OUTPUT

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

Анонимные функции

package main import «fmt» func main() < a := 1 b := 1 c := func(x int) int < b *= 2 return x * 2 >(a) fmt.Println(a, b, c) > /* >>> OUTPUT

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

package main import «fmt» func main() < myFunc := func(x int) int < return x * x >fmt.Println(myFunc(2), myFunc(3)) > /* >>> OUTPUT

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

Пустые идентификаторы

package main import «fmt» func main() < x, _ := evenOnly(10) fmt.Println(x) >func evenOnly(n int) (int, error) < if n%2 == 0 < return n / 2, nil >return 0, fmt.Errorf(«not even») > /* >>> OUTPUT

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

Следующие темы

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

• Указатель, метод и интерфейс
• Go Routine

Перевод статьи: Learn Golang Basic Syntax in 10 Minutes
Источник: medium.com

Источник: dev-gang.ru

Программирование на Go для начинающих

Многие из нас привыкли считать, что действительно универсальных языков не бывает. Если нам нужна эффективность, мы используем «Си» и одновременно с этим миримся с его ограничениями.

Когда нам требуется повышенная скорость разработки, мы «дружим» с таким языком, как «Питон», ожидая получить медленный код. Erlang даёт нам возможность делать высокораспараллеленные распределённые приложения, однако его иногда бывает трудно вписать в существующие проекты.

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

Язык Go — это «Си» на стероидах?

Когда 10 лет тому назад Кена Томпсона, который активно участвовал в создании языка «Си», спросили, а каковым бы он сделал данный язык на тот момент, разработчик ответил, что он стал бы похож на Limbo. После этого прошло достаточно много времени, и Томпсон вместе с Робом Пайком (другой автора языка C) приняли участие в создании Go, ставшего в каком-то смысле переосмыслением и результатом развития Limbo. Таким образом, как только Go представили миру, он сразу стал бестселлером. И произошло это 10 ноября 2009 года.

Во многом успеху способствовали имена авторов, известных в качестве создателей операционной системы UNIX, кодировки UTF-8, языка «Си». Сыграло свою роль и покровительство Google, так как именно в лабораториях этой корпорации родился на свет Go.

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

«Си» сегодняшнего дня

Разработчики Go позиционируют его как системный язык, который сочетает в себе скорость исполнения и эффективность кода, написанного на C, с простотой разработки, присущей более высокоуровневым скриптовым языкам, включая языки, имеющие встроенные средства параллельного программирования. При этом если говорить о внешних признаках, то здесь Go напоминает нам некую странную солянку, состоящую из синтаксисов C, Pascal и ADA. В совокупности с приведенным выше описанием создаётся сильное ощущение некого подвоха (так бывает, если видишь новость о супер-мега-разработке группы студентов из Урюпинска). Но скепсис достаточно быстро исчезает, когда ты начинаешь изучать Go и понимаешь, почему он стал именно такой, какой есть сейчас.

В основе Go находятся 3 фундаментальных принципа: 1. Гарантируется высокая скорость как компиляции, так и производительности приложений. 2. Обеспечивается простота разработки и технической поддержки приложений на уровне, присущем высокоуровневым скриптовым языкам. 3. Встроены средства параллельной разработки, которые позволяют использовать все ядра современных процессоров, которые имеются в железе.

Хотите знать, что всё это значит в реальности? Что же, давайте разберёмся по каждому пункту в отдельности.

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

Даже простейшая референсная реализация компилятора с языка Go может всего за доли секунды сгенерировать удивительно быстрый код, причём скорость его исполнения будет сопоставима со скоростью работы кода, написанного на «Си» или C++. Однако здесь следует добавить, что в отличие от своих именитых предков компилятор Go обеспечивает проверку типов, а результирующий код получает собственный механизм распараллеливания и встроенный сборщик мусора.

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

В итоге язык получился достаточно прямолинейным, то есть не допускающим спорных мест и неочевидностей, которые могут затруднить работу компилятора (яркий пример неочевидного синтаксиса и сложной общей механики — тот же C++, который порой заставляет компилятор в буквальном смысле буксовать на месте, а головы разработчиков трещать от перенапряжения).

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

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

Простота в разработке и сопровождении

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

Однако основное, что даёт Go разработчику, есть та самая очевидность синтаксиса и прямолинейность, о которой мы уже упоминали. В этом смысле Go напоминает такие языки, как Modula, Pascal и Oberon. И почти любой синтаксический элемент языка соответствует общей логике, поэтому может явно и безошибочно интерпретироваться вне зависимости от положения в коде. Например, вы просто не сможете сделать известную ошибку объявления переменных, которая описана во всех гайдах по стилю оформления кода на «Си»:

int* a, b; // В Си и C++ переменная «a» будет указателем, но «b» — нет var a, b *int; // В Go обе переменные будут указателями

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

И главная идея языка заключается в том, чтобы быть инструментом, позволяющим писать программы, а не постоянно думать о том, а будут ли они вообще работать (эта черта, как известно, присуща для таких языков, как «Си» и С++).

Средства параллельного программирования

Это одна из самых сильных черт Go. Пожалуй, среди языков общего назначения «голангу» просто нет равных (кроме, разве что, Limbo, однако он привязан к операционной системе Inferno).

Выигрыш тут состоит не только в том, что средства встроены. Намного большее значение имеет факт, что эти средства реализуют простую и эффективную модель, которая полностью соответствует CSP — теории взаимодействующих последовательных процессов. Те, кто знаком с Occam и Limbo, хорошо понимают все плюсы CSP, а кто не знаком, сейчас поясним. Смотрите, вместо того, чтобы нагромождать потоки, мьютексы, блокировки и прочие системы синхронизации, делающие параллельное программирование настоящей мукой и приводящие и переизданию многостраничных томов о том, как правильно писать многопоточные приложения, у нас существует CSP. Его автор, Тони Хоар, предлагает элегантное и довольно простое решение: позволить приложению в любое время создать новую нить, которая будет иметь возможность общаться с родителями и прочими нитями посредством отправки синхронных сообщений.

Если говорить о Go, то в данном случае эта идея выглядит следующим образом: 1. Создаётся переменная-канал. 2. Определяется функция, принимающая переменную-канал в виде аргумента и в своём теле содержащая код, который выполняется в отдельной нити. В конце эта функция отправляет результат выполнения в канал, что делается благодаря специальному оператору. 3. Функция запускается в отдельном потоке посредством ключевого слова «go». 4. Выполняется чтение из канала.

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

Пример

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

package main import «time» import «fmt» func timer(ch chan string, ns, count int) < for j := 1; j else < fmt.Printf(«[timer] Отправляю. n») ch fmt.Printf(«[timer] Отправил!n») > > func main() < var str string ch := make(chan string) go timer(ch, 1000000000, 10) for < fmt.Printf(«[main] Принимаю. n») str = else < fmt.Printf(«[main] Принято!n») >> >

Если бы мы выбрали простейшую реализацию данной программы, то она заняла бы и вовсе 15 строк. Но наш код намеренно усложнён путём добавления условных выражений и вывода на терминал. Они необходимы для понимания общего синтаксиса языка Go, а также механизма работы планировщика потоков.

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