Содержание

Приступая к работе — Введение в программирование на Go

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

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

Процесс разработки приложений на Go (и на большинстве других языков программирования) довольно прост:

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

Процесс этот итеративный (то есть повторяющийся много раз), и шаги, как правило, совпадают.

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

Файлы и директории

Файл представляет собой набор данных, хранящийся в блоке с определенным именем. Современные операционные системы (такие как Windows или Mac OS X) состоят из миллионов файлов, содержащих большой объем различной информации — начиная от текстовых документов и заканчивая программами и мультимедиа-файлами.

Файлы определенным образом хранятся в компьютере: все они имеют имя, определенный размер (измеряемый в байтах) и соответствующий тип. Обычно тип файла определяется по его расширению — части имени, которая стоит после последней .. Например, файл, названный hello.txt, имеет расширение

txt, а значит содержит текстовую информацию.

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

Терминал

Большая часть взаимодействия с компьютером сейчас осуществляется с помощью графического пользовательского интерфейса (GUI). Мы используем клавиатуру, мышь, сенсорные экраны для взаимодействия с визуальными кнопками и другими отображаемыми элементами.

Но так было не всегда. Перед GUI в ходу был терминал — простой текстовый интерфейс к компьютеру, где вместо работы с кнопками на экране мы вводили команды и получали ответы.

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

Windows

Чтобы вызвать терминал (командную строку) в Windows, нужно нажать комбинацию клавиш Win+R (удерживая клавишу с логотипом Windows нажмите R), ввести в появившееся окно cmd.exe и нажать Enter. Вы должны увидеть черное окно, похожее на то, что ниже:

По умолчанию командная строка запускается из вашей домашней директории (в моём случае это C:\Users\caleb). Вы отдаёте команды компьютеру, набирая их в этом окне и нажимая Enter. Попробуйте ввести команду dir, которая выводит содержимое текущего каталога на экран. Вы должны увидеть что-то вроде этого:

C:\Users\caleb>dir
Volume in drive C has no label.
Volume Serial Number is B2F5-F125

Вы можете изменить текущий каталог с помощью команды cd. Например, там наверняка есть директория под названием Desktop

. Вы можете посмотреть её содержимое, набрав cd Desktop, а затем dir. Чтобы вернуться в домашнюю директорию, используйте специальное имя .. (две точки): cd ... Одна точка обозначает текущий каталог (известен как рабочая директория), так что cd . ничего не сделает. Конечно, существует намного больше команд, которые можно использовать, но этих будет вполне достаточно для начала.

OSX

В OSX терминал можно найти, перейдя в Finder → Applications → Utilities → Terminal. Вы увидите такое окно:

По умолчанию, командная строка запускается из вашей домашней директории (в моём случае это /Users/caleb). Вы отдаёте команды компьютеру, набирая их в этом окне и нажимая Enter. Попробуйте ввести команду ls, которая выводит содержимое текущего каталога на экран. Вы должны увидеть что-то вроде этого:

caleb-min:~ caleb$ ls
Desktop      Downloads      Movies     Pictures
Documents    Library        Music      Public

Вы можете изменить текущий каталог с помощью команды cd. Например, там наверняка есть директория под названием Desktop. Вы можете посмотреть её содержимое набрав cd Desktop, а затем ls. Чтобы вернуться в домашнюю директорию, используйте специальное имя

.. (две точки): cd ... Одна точка обозначает текущий каталог (известен как рабочая директория), так что cd . ничего не сделает. Конечно, существует намного больше команд, которые можно использовать, но этих будет вполне достаточно для начала.

Текстовый редактор

Основным инструментом программиста при разработке программного обеспечения является текстовый редактор. Текстовые редакторы в целом похожи на программы обработки текста (такие как Microsoft Word или OpenOffice), но в отличие от последних, там отсутствует какое-либо форматирование (полужирный, курсив и т.п.), что делает их ориентированными только на работу с простым текстом. Как в OSX, так и в Windows, по умолчанию уже присутствует встроенные текстовые редакторы. Но они очень ограничены в возможностях, поэтому я бы порекомендовал что-нибудь получше.

Дабы упростить установку, на сайте книги golang-book.com доступен специальный инсталлятор. Он установит Go, необходимые инструменты, текстовый редактор и настроит переменные окружения.

Windows

Для Windows инсталлятор установит текстовый редактор SciTe. Вы сможете найти его в меню Пуск → Все программы → Go → SciTe. После запуска вы должны увидеть такое окно:

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

Вы можете открыть файл, выбрав его в диалоге, находящимся в меню File → Open. Файлы могут быть сохранены с помощью меню File → Save или File → Save As.

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

  • Ctrl + S — сохранить текущий файл

  • Ctrl + X — вырезать выделенный текст (удалить его, предварительно сохранив в буфере обмена, для возможной вставки позже)

  • Ctrl + C — скопировать выделенный фрагмент текста в буфер обмена

  • Ctrl + V — вставить текст на место текущего положения курсора из буфера обмена

  • Используйте клавиши со стрелками для навигации по файлу, Home для перехода в начало строки, а End

    для перехода в конец

  • Удерживайте Shift при использовании клавиш навигации, чтобы выделить фрагмент текста без использования мыши

  • Ctrl + F — открыть диалоговое окно поиска по содержимому файла

OSX

Для OSX установщик поставит редактор Text Wrangler:

Как и Scite на Windows, окно Text Wrangler содержит большую белую область, где вводится текст. Файлы могут быть открыты при помощи File → Open, а сохранены с помощью File → Save или File → Save As. Вот некоторые полезные сочетания клавиш:

  • ⌘

    + S — сохранить текущий файл

  • ⌘ + X — вырезать выделенный текст (удалить его, предварительно сохранив в буфере обмена, для возможной вставки позже)

  • ⌘ + C — скопировать выделенный фрагмент текста в буфер обмена

  • ⌘ + V — вставить текст на место текущего положения курсора из буфера обмена

  • Используйте клавиши со стрелками для навигации по файлу

  • ⌘ + F — открыть диалоговое окно поиска по содержимому файла

Инструментарий Go

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

Инсталлятор установит Go автоматически. Мы будем использовать первую версию языка. (Больше информации можно найти на http://golang.org/)

Давайте убедимся, что всё работает. Откроем терминал и введём там:

go version

В ответ вы должны увидеть что-то вроде:

go version go1.0.2

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

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

go help

О том, как их использовать, мы узнаем в следующих главах.

Типы — Введение в программирование на Go

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

Предположим, у вас есть собака по имени Шарик. Тут «Шарик» — это «Собака», этот тип описывает какой-то набор свойств, присущий всем собакам. Наши рассуждения должны быть примерно следующие: у собак 4 лапы, Шарик — собака, значит, у Шарика 4 лапы. Типы данных в языках программирования работают похожим образом: у всех строк есть длина; x — строка, а значит у x есть длина.

В математике мы часто говорим о множествах. Например, ℝ (множество всех вещественных чисел) или ℕ (множество всех натуральных чисел). Каждый элемент этих множеств имеет такие же свойства, как и все прочие элементы этого множества. Например, все натуральные числа ассоциативны — «для всех натуральных чисел a, b и c выполняется: a + (b + c) = (a + b) + c и a × (b × c) = (a × b) × c»; в этом смысле множества схожи с типами данных в языках программирования тем, что все значения одного типа имеют общие свойства.

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

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

Числа

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

Целые числа

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

Наша система строится на 10 различных цифрах. Когда мы исчерпываем доступные нам цифры, мы представляем большое число, используя новую цифру 2 (а затем 3, 4, 5, …) числа следуют одно за другим. Например, число, следующее за 9, это 10, число, следующее за 99, это 100 и так далее. Компьютеры делают то же самое, но они имеют только 2 цифры вместо 10. Поэтому, подсчет выглядит так: 0, 1, 10, 11, 100, 101, 110, 111 и так далее. Другое отличие между той системой счисления, что используем мы, и той, что использует компьютер — все типы чисел имеют строго определенный размер. У них есть ограниченное количество цифр. Поэтому четырехразрядное число может выглядеть так: 0000, 0001, 0010, 0011, 0100. В конце концов мы можем выйти за лимит, и большинство компьютеров просто вернутся к самому началу (что может стать причиной очень странного поведения программы).

В Go существуют следующие типы целых чисел: uint8, uint16, uint32, uint64, int8, int16, int32 и int64. 8, 16, 32 и 64 говорит нам, сколько бит использует каждый тип. uint означает «unsigned integer» (беззнаковое целое), в то время как int означает «signed integer» (знаковое целое). Беззнаковое целое может принимать только положительные значения (или ноль). В дополнение к этому существуют два типа-псевдонима: byte (то же самое, что uint8) и rune (то же самое, что int32). Байты — очень распространенная единица измерения в компьютерах (1 байт = 8 бит, 1024 байта = 1 килобайт, 1024 килобайта = 1 мегабайт, …), и именно поэтому тип byte в Go часто используется для определения других типов. Также существует 3 машинно-зависимых целочисленных типа: uint, int и uintptr. Они машинно-зависимы, потому что их размер зависит от архитектуры используемого компьютера.

В общем, если вы работаете с целыми числами — просто используйте тип int.

Числа с плавающей точкой

Числа с плавающей точкой — это числа, которые содержат вещественную часть (вещественные числа) (1.234, 123.4, 0.00001234, 12340000). Их представление в компьютере довольно сложно и не особо необходимо для их использования. Так что мы просто должны помнить:

  • Числа с плавающей точкой неточны. Бывают случаи, когда число вообще нельзя представить. Например, результатом вычисления 1.01 - 0.99 будет 0.020000000000000018 — число очень близкое к ожидаемому, но не то же самое.

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

  • В дополнение к числам существуют несколько других значений, таких как: «not a number» (не число) (NaN, для вещей наподобие 0/0), а также положительная и отрицательная бесконечность (+∞ и −∞).

В Go есть два вещественных типа: float32 и float64 (соответственно, часто называемые вещественными числами с одинарной и двойной точностью). А также два дополнительных типа для представления комплексных чисел (чисел с мнимой частью): complex64 и complex128. Как правило, мы должны придерживаться типа float64, когда работаем с числами с плавающей точкой.

Пример

Давайте напишем программу-пример, использующую числа. Во-первых, создайте папку «chapter3» с файлом main.go внутри со следующим содержимым:

package main
import "fmt"
func main() {
    fmt.Println("1 + 1 = ", 1 + 1)
}

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

$ go run main.go
1 + 1 = 2

Заметим, что эта программа очень схожа с программой, которую мы написали в главе 2. Она содержит ту же строку с указанием пакета, ту же строку с импортом, то же определение функции и использует ту же функцию Println. В этот раз вместо печати строки Hello World мы печатаем строку 1 + 1 = с последующим результатом выражения 1 + 1. Это выражение состоит из трех частей: числового литерала 1 (который является типом int), оператора + (который представляет сложение) и другого числового литерала 1. Давайте попробуем сделать то же самое, используя числа с плавающей точкой:

fmt.Println("1 + 1 =", 1.0 + 1.0)

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

В дополнение к сложению, в Go имеется несколько других операций:

ЛитералПояснение
+сложение
—вычитание
*умножение
/деление
%остаток от деления

Строки

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

Строковые литералы могут быть созданы с помощью двойных кавычек "Hello World" или с помощью апострофов `Hello World`. Различие между ними в том, что строки в двойных кавычках не могут содержать новые строки и они позволяют использовать особые управляющие последовательности символов. Например, \n будет заменена символом новой строки, а \t — символом табуляции.

Распространенные операции над строками включают в себя нахождение длины строки len("Hello World"), доступ к отдельному символу в строке "Hello World"[1], и конкатенацию двух строк "Hello " + "World". Давайте модифицируем созданную ранее программу, чтобы проверить всё это:

package main
import "fmt"
func main() {
    fmt.Println(len("Hello World"))
    fmt.Println("Hello World"[1])
    fmt.Println("Hello " + "World")
}

На заметку:

  • Пробел тоже считается символом, поэтому длина строки 11 символов, а не 10 и третья строка содержит "Hello " вместо "Hello".

  • Строки “индексируются” начиная с 0, а не с 1. [1] даст вам второй элемент, а не первый. Также заметьте, что вы видите 101 вместо e, когда выполняете программу. Это происходит из-за того, что символ представляется байтом (помните, байт — это целое число).

    Можно думать об индексации так: "Hello World" 1. Читайте это так: «строка Hello World позиция 1», «на 1 позиции строки Hello World» или «второй символ строки Hello World».

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

Логические типы

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

ЛитералПояснение
&&И
||ИЛИ
!НЕ

Вот пример программы, показывающей их использование:

func main() {
    fmt. Println(true && true)
    fmt.Println(true && false)
    fmt.Println(true || true)
    fmt.Println(true || false)
    fmt.Println(!true)
}

Запуск этой программы должен вывести:

$ go run main.go
true
false
true
true
false

Используем таблицы истинности, чтобы определить, как эти операторы работают:

ВыражениеЗначение
true && truetrue
true && falsefalse
false && truefalse
false && falsefalse
ВыражениеЗначение
true || truetrue
true || falsetrue
false || truetrue
false || falsefalse
ВыражениеЗначение
!truefalse
!falsetrue

Всё это — простейшие типы, включенные в Go и являющиеся основой, с помощью которой строятся все остальные типы.

Задачи

  • Как хранятся числа в компьютере?

  • Мы знаем, что в десятичной системе самое большое число из одной цифры — это 9, а из двух — 99. В бинарной системе самое большое число из двух цифр это 11 (3), самое большое число из трех цифр это 111 (7) и самое большое число из 4 цифр это 1111 (15). Вопрос: каково самое большое число из 8 цифр? (Подсказка: 101-1=9 и 102-1=99)

  • В зависимости от задачи вы можете использовать Go как калькулятор. Напишите программу, которая вычисляет 32132 × 42452 и печатает это в терминал (используйте оператор * для умножения).

  • Что такое строка? Как найти её длину?

  • Какое значение примет выражение (true && false) || (false && true) || !(false && false)?

Для чего действительно хорош язык программирования Go (Golang)?

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

старший писатель, Информационный мир |

Павел Червинский (СС0)

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

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

Язык Go небольшой и простой

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

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

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

В языке Go каждый найдет что-то для себя

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

Go упрощает жизнь разработчика несколькими способами.

Go удобен

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

Go работает быстро

Двоичные файлы Go работают медленнее, чем их аналоги C, но разница в скорости для большинства приложений незначительна. Производительность Go не уступает C для подавляющего большинства задач и, как правило, намного выше, чем у других языков, известных своей скоростью разработки (например, JavaScript, Python и Ruby).

Go является переносимым

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

Go совместим

Go обеспечивает все вышеперечисленное без ущерба для доступа к базовой системе. Программы Go могут взаимодействовать с внешними библиотеками C или выполнять собственные системные вызовы. В Docker, например, Go взаимодействует с низкоуровневыми функциями Linux, контрольными группами и пространствами имен, чтобы работать с контейнерами.

Go широко поддерживается

Цепочка инструментов Go находится в свободном доступе в виде бинарного файла для Linux, MacOS или Windows или в виде контейнера Docker. Go включен по умолчанию во многие популярные дистрибутивы Linux, такие как Red Hat Enterprise Linux и Fedora, что несколько упрощает развертывание исходного кода Go на этих платформах. Поддержка Go также сильна во многих сторонних средах разработки, от Microsoft Visual Studio Code до ActiveState Komodo IDE.

Где язык Go работает лучше всего

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

Go лучше всего подходит для разработки следующих типов приложений.

Облачная разработка

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

Услуги распределенной сети

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

Утилиты и автономные инструменты

Программы Go компилируются в двоичные файлы с минимальными внешними зависимостями. Это делает их идеально подходящими для создания утилит и других инструментов, поскольку они быстро запускаются и могут быть легко упакованы для дальнейшего распространения. Одним из примеров является сервер доступа под названием Teleport (среди прочего, для SSH). Teleport можно быстро и легко развернуть на серверах, скомпилировав его из исходного кода или загрузив готовый двоичный файл.

Языковые ограничения Go

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

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

Другим потенциальным недостатком Go является размер генерируемых двоичных файлов. Бинарные файлы Go по умолчанию компилируются статически, а это означает, что все, что нужно во время выполнения, включено в бинарный образ. Этот подход упрощает процесс сборки и развертывания, но за счет простого «Привет, мир!» весит около 1,5 МБ в 64-битной Windows. Команда Go работала над уменьшением размера этих двоичных файлов с каждым последующим выпуском. Также можно уменьшить двоичные файлы Go с помощью сжатия или путем удаления отладочной информации Go. Этот последний вариант может работать лучше для автономных распределенных приложений, чем для облачных или сетевых служб, где информация об отладке полезна в случае сбоя службы на месте.

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

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

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

Большинство приложений Go являются инструментами командной строки или сетевыми службами. Тем не менее, различные проекты работают над созданием богатых графических интерфейсов для приложений Go. Существуют привязки для фреймворков GTK и GTK3. Другой проект предназначен для предоставления платформенных пользовательских интерфейсов, хотя они основаны на привязках C и не написаны на чистом Go. А пользователи Windows могут попробовать ходить. Но в этой области не появилось явного победителя или безопасной долгосрочной ставки, а некоторые проекты, такие как попытка Google создать кроссплатформенную библиотеку графического интерфейса, ушли на второй план. Кроме того, поскольку Go по своей конструкции не зависит от платформы, маловероятно, что какой-либо из них станет частью стандартного набора пакетов.

Хотя Go может взаимодействовать с собственными системными функциями, он не предназначен для создания низкоуровневых системных компонентов, таких как ядра, драйверы устройств или встроенные системы. В конце концов, среда выполнения Go и сборщик мусора для приложений Go зависят от базовой ОС. (Разработчики, заинтересованные в передовом языке для такой работы, могут обратить внимание на язык Rust.)

Будущее языка Go

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

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

Большинство языков тяготеют к основному набору вариантов использования. За десять лет существования Go его нишей стали сетевые сервисы, где он, вероятно, продолжит расширять свое присутствие. По большому счету, основным вариантом использования языка было создание API или RPC-сервисов (49).%), за которыми следуют обработка данных (10%), веб-сервисы (10%) и приложения CLI (8%).

Еще одним признаком растущей привлекательности языка Go является то, сколько разработчиков выбирают его после оценки. 75% опрошенных, которые рассматривали возможность использования Go для проекта, выбрали этот язык. Из тех, кто не выбрал Go, лучшими альтернативами были Rust (25%), Python (17%) и Java (12%). Каждый из этих языков нашел или находит другие ниши: Rust для безопасного и быстрого системного программирования; Python для прототипирования, автоматизации и склеивания кода; и Java для давних корпоративных приложений.

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

Связанный:

  • Google Go
  • Языки программирования
  • Средства разработки
  • Разработка программного обеспечения

Сердар Егулалп — старший писатель InfoWorld, специализирующийся на машинном обучении, контейнеризации, devops, экосистеме Python и периодических обзорах.

Copyright © 2022 IDG Communications, Inc.

Как выбрать платформу разработки с низким кодом

Язык программирования Go (Введение) Он был разработан в

2007 Робертом Гриземером, Робом Пайком и Кеном Томпсоном из Google, но запущен в 2009 как язык программирования с открытым исходным кодом. Программы собираются с использованием пакетов для эффективного управления зависимостями. Этот язык также поддерживает среду, принимающую шаблоны, аналогичные динамическим языкам. Например, вывод типа (y := 0 является допустимым объявлением переменной y типа float).

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

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

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

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

Вот простое «Hello, World!» программа в Go:

Go

package main

 

import "fmt"

 

func main() {

     fmt. Println( «Привет, Мир!» )

}

Результат:

Привет, Мир!
 

  Начиная с Программирование Go

Существуют различные онлайн-среды разработки, такие как The Go Playground, repl.it и т. д., которые можно использовать для запуска программ Go без установки.
Для установки Go на собственный ПК или ноутбук нам потребуются следующие два программного обеспечения: Текстовый редактор и компилятор
Текстовый редактор: Текстовый редактор предоставляет вам платформу , на которой вы пишете исходный код. Ниже приведен список текстовых редакторов:  

  • Блокнот Windows
  • Команда редактирования ОС
  • Краткий обзор
  • Epsilon
  • vm или vi
  • Emacs
  • VS Code

Поиск компилятора Go: Дистрибутив Go поставляется в виде двоичного файла, который можно установить для FreeBSD (версия 8 и выше), OS Mac XSnow XSnow 901 Linux 901 и выше. Leopard и выше) и операционные системы Windows с 32-разрядными (386) и 64-разрядными (amd64) архитектурами процессоров x86 .
Дополнительные инструкции по установке. Пожалуйста, посетите Для установки дистрибутива GO  

 Note: Extension of source code file of go language must be   .go

Writing first program in Go:   

Go

package main 

   

Импорт "FMT"

Func Main () {

.0145 «Hello, geeksforgeeks» )

}

Output:   

 Hello, geeksforgeeks

Explanation of the syntax of Go program:  

  • Line 1: Он содержит основной пакет программы, который имеет общее содержание программы. Это начальная точка для запуска программы, поэтому ее необходимо написать.
  • Строка 2: Содержит import «fmt» , это команда препроцессора, которая сообщает компилятору включить файлы, лежащие в пакете.
  • Строка 3: основная функция , это начало выполнения программы.
  • Строка 4: fmt.Println() — это стандартная библиотечная функция для вывода чего-либо на экран. В этом пакете fmt передан метод Println, который используется для отображения вывода.
  • Комментарий: Комментарии используются для объяснения кода и используются так же, как в Java, C или C++. Компиляторы игнорируют записи комментариев и не выполняют их. Комментарии могут быть однострочными или многострочными.

Комментарий с одной строкой:

Синтаксис: 

 // Комментарий одной строки

Multi-Line Comment:

Синтаксис: 

 /100011111111111111111111111111111111111111111111111111111111111111111111111111111111117 / * 20011111111111111111111111111111111111111111111111111111111117 / *.  another example:     
  
 Go 
  
    
    
   package    main   
  
   import    "fmt"   
  
   
  
   func    main() {   
  
          fmt.Println(    "1 + 1 ="    ,     1    +     1    )   
  
   }   
  		  
    
  
  Вывод:  
 
 1 + 1 = 2 
  Объяснение приведенной выше программы:  
 В приведенной выше программе та же строка пакета, та же строка импорта, то же объявление функции и используется та же функция Println, что и у нас. используется в  1-я программа GO  . На этот раз вместо строки  «Hello, geeksforgeeks»  мы печатаем строку 1 + 1 =, за которой следует результат выражения 1 + 1. Это выражение состоит из трех частей: числовой литерал 1 (который состоит из введите int), оператор + (представляющий сложение) и еще один числовой литерал 1. 
  Почему этот «язык Go»? 
 Потому что язык Go — это попытка объединить простоту программирования интерпретируемого языка с динамической типизацией с эффективностью и безопасностью компилируемого языка со статической типизацией. Он также стремится быть современным с поддержкой сетевых и многоядерных вычислений.
  Что исключая в Go то, что присутствует в других языках?   
  •  Go пытается сократить объем ввода в обоих смыслах этого слова. На протяжении всего дизайна разработчики старались уменьшить беспорядок и сложность.
  •  Нет опережающих объявлений и заголовочных файлов; все объявляется ровно один раз.
  •  Заикание уменьшено простым наследованием типа с использованием конструкции  :=  объявления-и-инициализации.
  •  Нет иерархии типов: всего 9 типов0123 — это , им не нужно объявлять о своих отношениях.
  Аппаратные ограничения 
 Мы заметили, что за десятилетие конфигурация аппаратного обеспечения и обработки меняется очень медленно. В 2004 году у P4 была тактовая частота 3,0 ГГц, а теперь, в 2018 году, у Macbook pro тактовая частота составляет приблизительно (2,3 ГГц против 2,66 ГГц). Чтобы ускорить функциональность, мы используем больше процессоров, но при использовании большего количества процессоров стоимость также увеличивается. И из-за этого мы используем ограниченные процессоры, а при использовании ограниченного процессора у нас есть тяжелый язык программирования, многопоточность которого занимает больше памяти и снижает производительность нашей системы. Следовательно, чтобы преодолеть эту проблему, Golang был разработан таким образом, что вместо использования потоков он использует Goroutine, который похож на потоки, но потребляет очень меньше памяти. 
 Like threading потребляет 1 МБ, тогда как горутина потребляет 2 КБ памяти, следовательно, в то же время мы можем запускать миллионы горутин. 
 Таким образом, обсуждаемый выше момент делает golang сильным языком, который поддерживает параллелизм, как C++ и Java.
  Преимущества и недостатки языка Go 
  Преимущества:    
  1.  Гибкость. Он краткий, простой и легко читаемый.
  2.  Параллелизм. Позволяет нескольким процессам работать одновременно и эффективно.
  3.  Быстрый результат. Время компиляции очень быстрое.
  4.  Библиотека. Предоставляет богатую стандартную библиотеку.
  5.  Сборка мусора — ключевая особенность Go. Go превосходен в предоставлении большого контроля над распределением памяти и значительно сократил задержку в самых последних версиях сборщика мусора.
  6.  Проверяет встраивание интерфейса и типа.
  7.  Параллелизм: Go обеспечивает отличную поддержку параллелизма, упрощая написание кода, который может выполнять несколько задач одновременно. Это достигается с помощью горутин и каналов, которые позволяют вам писать код, который может выполнять несколько операций одновременно.
  8.  Производительность: Go разработан, чтобы быть быстрым и эффективным, с упором на производительность и низкое использование памяти. Это делает его подходящим для создания высокопроизводительных сетевых сервисов, а также для решения сложных вычислительных задач.
  9.  Простота: Go имеет простой синтаксис и простую систему типов, что упрощает изучение и использование даже для людей, не имеющих опыта программирования.
  10.  Сборка мусора: в Go есть встроенная сборка мусора, которая автоматически управляет памятью. Это устраняет необходимость в ручном управлении памятью, снижая вероятность утечек памяти и других ошибок, которые могут возникнуть при ручном управлении памятью.
  11.  Статическая типизация: Go является статически типизированным языком, что означает, что типы определяются во время компиляции. Это обеспечивает более надежную безопасность типов и упрощает обнаружение ошибок, связанных с типами, до их возникновения.
  Недостатки:    
  1.  Он не поддерживает дженерики, хотя об этом много дискуссий.
  2.  Пакеты, распространяемые с этим языком программирования, весьма полезны, но Go не настолько объектно-ориентирован в обычном смысле.
  3.  Отсутствуют некоторые библиотеки, особенно набор инструментов пользовательского интерфейса.
  4.  Ограниченные объектно-ориентированные функции: Go не имеет полноценных объектно-ориентированных функций, таких как наследование и полиморфизм. Это может затруднить написание сложных программ, особенно для разработчиков, привыкших к традиционным объектно-ориентированным языкам.
  5.  Нет универсальных шаблонов: в Go нет встроенной поддержки универсальных шаблонов, что затрудняет написание повторно используемого кода.
  6.  Незрелая стандартная библиотека. Стандартная библиотека Go является относительно новой и все еще развивается, что может затруднить поиск инструментов, необходимых для конкретной задачи.
  Некоторые популярные приложения, разработанные на языке Go 
  •  Docker: набор инструментов для развертывания контейнеров Linux
  •   Openshift:  платформа облачных вычислений как услуга от Red Hat.
  •   Kubernetes:  Будущее автоматизированных процессов развертывания
  •   Dropbox:  перенес некоторые из своих критически важных компонентов с Python на Go.
  •   Netflix:  для двух частей их серверной архитектуры.
  •   InfluxDB:  — это база данных временных рядов с открытым исходным кодом, разработанная InfluxData.
  •   Golang:  Сам язык был написан на Go.
 Страновые компании, которые в настоящее время используют Go Language.
  Особенности языка go   
  •   Дизайн языка:  Разработчики языка сознательно стремились сделать язык простым и понятным. Вся детализация умещается на нескольких страницах, а некоторые интересные дизайнерские решения принимались за  Объектно-ориентированная  поддержка языка. В связи с этим язык самоуверен и рекомендует  идиоматический  способ достижения целей. Он предпочитает композицию наследованию. В Go Language  «Делай больше с меньшими затратами»  — это мантра.
  •   Управление пакетами:  Go объединяет современный рабочий процесс разработчиков с  проектами с открытым исходным кодом  и включает их в способ управления внешними пакетами. Поддержка предоставляется непосредственно в инструментах для получения внешних пакетов и публикации собственных пакетов с помощью набора простых команд.
  •   Мощная стандартная библиотека:  Go имеет мощную стандартную библиотеку, которая распространяется в виде пакетов.
  •   Статическая типизация:  Go — язык со статической типизацией. Таким образом, в этом компиляторе не только успешно компилируется код, но и обеспечивается преобразование типов и совместимость. Благодаря этой особенности Go позволяет избежать всех тех проблем, с которыми мы сталкиваемся в языках с динамической типизацией.
  •   Поддержка тестирования:  Go сам по себе предоставляет нам функции модульного тестирования, то есть простой механизм для написания вашего модульного теста параллельно с вашим кодом, благодаря этому вы можете понять покрытие кода своими собственными тестами. И это можно легко использовать при создании документации по коду в качестве примера.
  •   Независимость от платформы:  Язык Go похож на язык Java, поскольку поддерживает независимость от платформы. Из-за своей модульной конструкции и модульности, т. Е. Код компилируется и преобразуется в двоичную форму, которая является как можно меньше и, следовательно, не требует зависимости. Его код может быть скомпилирован на любой платформе или любом сервере и в любом приложении, с которым вы работаете.
 Справочники: 
 Язык программирования Go Алана А.
No related posts.