Го (язык программирования)

Информацию о языке программирования на основе агентов 2003 см. в разделе Go! (язык программирования) .

Идти

Парадигма	Мультипарадигма : одновременный императив , функционал. объектно-ориентированный
Разработано	Роберт Гриземер Роб Пайк Кен Томпсон
Разработчик	Авторы Go
Впервые появился	10 ноября 2009 г ( 10.11.2009 )
Стабильная версия	1.22.4 / 4 июня 2024 г ( 4 июня 2024 г. )
Дисциплина набора текста	Предполагаемый , статичный , сильный , структурный , номинальный
Управление памятью	Сбор мусора
Язык реализации	Go, язык Ассемблера (gc); C++ (гофронтенд)
ТЫ	DragonFly BSD , FreeBSD , Linux , macOS , NetBSD , OpenBSD , План 9 , Солярис , Винда
Лицензия	3-пунктовый BSD + патента выдача
Расширения имен файлов	.идти
Веб-сайт	идти .dev
Основные реализации
GC, GoFrontend
Под влиянием
C , Оберон-2 , Лимбо , Активный Оберон , взаимодействие последовательных процессов , Паскаль , Оберон , Smalltalk , Newsqueak , Modula-2 , Alef , APL , BCPL , Modula , occam
Под влиянием
Кристалл , В.

Go — статически типизированный , компилируемый высокого уровня, язык программирования разработанный в Google. , Роберт Гриземер Роб Пайк и Кен Томпсон . он Синтаксически похож на C , но также имеет безопасность памяти , сборку мусора , структурную типизацию . и CSP в стиле параллелизм . Его часто называют Golang из-за его прежнего доменного имени: golang.org, но его собственное имя — Го.

Существует две основные реализации:

• Google Самостоятельный хостинг «gc» компилятора Набор инструментов , ориентированный на несколько операционных систем и WebAssembly .
• gofrontend — интерфейс для других компиляторов с библиотекой libgo . Для GCC используется комбинация gccgo; с LLVM комбинация — gollvm.

Сторонний компилятор исходного кода GopherJS, компилирует Перейти к JavaScript для веб-разработки внешнего интерфейса .

История

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

• Статическая типизация и эффективность выполнения (например, C )
• Читабельность и удобство использования (как Python )
• Высокопроизводительная сеть и многопроцессорная обработка

Его дизайнеры в первую очередь руководствовались общей неприязнью к C++ .

Go был публично анонсирован в ноябре 2009 года. а версия 1.0 была выпущена в марте 2012 года. Go широко используется в производстве в Google и во многих других организациях и проектах с открытым исходным кодом.

Брендинг и стиль

Талисман языка программирования Go — суслик , показанный выше.

Талисман Суслика был представлен в 2009 году для с открытым исходным кодом запуска языка . Дизайн Рене Френч позаимствован у ок. 2000 года Продвижение WFMU .

В ноябре 2016 года шрифты Go и Go Mono были выпущены шрифтовыми дизайнерами Чарльзом Бигелоу и Крисом Холмсом специально для использования в проекте Go. Go — гуманистический шрифт без засечек, напоминающий Lucida Grande , а Go Mono — моноширинный . Оба шрифта соответствуют набору символов WGL4 и были разработаны так, чтобы их можно было читать, благодаря большой высоте x и четким буквенным формам . И Go, и Go Mono соответствуют стандарту DIN 1450, поскольку имеют перечеркнутый ноль в нижнем регистре. l с хвостиком и заглавной буквой I с засечками.

В апреле 2018 года оригинальный логотип был обновлен дизайнером бренда Адамом Смитом. Новый логотип представляет собой современный стилизованный логотип GO, наклоненный вправо с обтекаемыми линиями. (Талисман Суслик остался прежним. )

Дженерики

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

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

В июне 2020 года новый эскизный проектный документ. был опубликован, который добавит в Go необходимый синтаксис для объявления общих функций и типов. Инструмент перевода кода, go2go был предоставлен, чтобы позволить пользователям опробовать новый синтаксис, а также версию онлайн-игры Go Playground с поддержкой дженериков.

Дженерики были наконец добавлены в Go в версии 1.18 15 марта 2022 года.

Управление версиями

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

Go не следует за SemVer ; скорее, каждая основная версия Go поддерживается до тех пор, пока не появятся две новые второстепенные версии. В отличие от большинства программ, Go называет второе число в версии основным, т. е. в 1.x x это основная версия. Это связано с тем, что Go планирует никогда не достичь версии 2.0, учитывая, что совместимость является одним из основных преимуществ языка.

Дизайн

Go находится под влиянием C (особенно Plan 9) . диалекта ), но с упором на большую простоту и безопасность. Он состоит из:

• Синтаксис и среда, использующие шаблоны, более распространенные в динамических языках :
  • Необязательное краткое объявление переменной и инициализация посредством вывода типа ( x := 0 вместо var x int = 0; или var x = 0;)
  • Быстрая компиляция
  • Удаленное управление пакетами ( go get) и онлайн-документация пакета
• Отличительные подходы к конкретным проблемам:
  • Встроенные примитивы параллелизма: легкие процессы (горутины), каналы и select заявление
  • Система интерфейсов вместо виртуального наследования и внедрение типов вместо невиртуального наследования.
  • Инструментальная цепочка, которая по умолчанию создает статически связанные собственные двоичные файлы без внешних зависимостей Go.
• Желание сохранить спецификацию языка достаточно простой, чтобы ее можно было держать в голове программиста, отчасти за счет исключения функций, общих для подобных языков .

Синтаксис

Синтаксис Go включает изменения по сравнению с C, направленные на то, чтобы сделать код кратким и читаемым. Был введен комбинированный оператор объявления/инициализации, который позволяет программисту писать i := 3 или s := "Hello, world!", без указания типов используемых переменных. Это контрастирует с C int i = 3; и const char *s = "Hello, world!";.

Точки с запятой по-прежнему завершают операторы; но они неявны, когда происходит конец строки.

Методы могут возвращать несколько значений и возвращать result, err Пара — это традиционный способ, которым метод сообщает об ошибке вызывающему объекту в Go. Go добавляет литеральный синтаксис для инициализации параметров структуры по имени, а также для инициализации карт и срезов . В качестве альтернативы трем операторам C for петля, Го range выражения позволяют выполнять краткую итерацию по массивам, срезам, строкам, картам и каналам.

Типы

Go имеет ряд встроенных типов, включая числовые ( байт , int64 , float32 и т. д.), логические значения и байтовые строки ( нить ). Строки неизменяемы; встроенные операторы и ключевые слова (а не функции) обеспечивают конкатенацию, сравнение и UTF-8 . кодирование/декодирование Типы записей можно определить с помощью Ключевое слово структуры .

Для каждого типа T и каждая неотрицательная целочисленная константа n существует тип массива , обозначаемый [ п ] Т ; Таким образом, массивы разной длины относятся к разным типам. Динамические массивы доступны в виде «срезов», обозначаемых [] T для некоторого типа Т. ​Они имеют длину и емкость , определяющие, когда необходимо выделить новую память для расширения массива. Несколько срезов могут совместно использовать свою базовую память.

Указатели доступны для всех типов, а указатель на Тип Т обозначается * Т. ​Прием адреса и косвенность используют & и * операторы, как в C, или происходят неявно через синтаксис вызова метода или доступа к атрибуту. Нет никакой арифметики указателей, кроме как через спец. unsafe.Тип указателя в стандартной библиотеке.

Для пары типов К , В , тип map[ K ] V — тип отображения типов. K клавиш для ввода- Значения V , хотя спецификация языка программирования Go не дает никаких гарантий производительности или требований к реализации для типов карт. Хэш-таблицы встроены в язык со специальным синтаксисом и встроенными функциями. chan T — канал , позволяющий отправлять значения типа T между параллельными процессами Go .

Помимо поддержки интерфейсов , система типов Go является номинальной : Ключевое слово type можно использовать для определения нового именованного типа , который отличается от других именованных типов, имеющих тот же макет (в случае struct , те же члены в том же порядке). Некоторые преобразования между типами (например, между различными целочисленными типами) предопределены, и добавление нового типа может определять дополнительные преобразования, но преобразования между именованными типами всегда должны вызываться явно. Например, Ключевое слово type можно использовать для определения типа адресов IPv4 на основе 32-битных целых чисел без знака следующим образом:

type ipv4addr uint32

При таком определении типа ipv4addr(x) интерпретирует uint32 значение x в качестве IP-адреса. Просто назначая x в переменную типа ipv4addr — это ошибка типа.

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

функций Типы обозначаются значком ключевое слово func ; они принимают ноль или более параметров и возвращают ноль или более значений, причем все они являются типизированными. Параметр и возвращаемые значения определяют тип функции; таким образом, func(string, int32) (int, error) — это тип функций, которые принимают строку и 32-битное целое число со знаком и вернуть целое число со знаком (ширины по умолчанию) и значение встроенного типа интерфейса. ошибка .

С любым именованным типом методов связан набор . Приведенный выше пример IP-адреса можно расширить с помощью метода проверки того, соответствует ли его значение известному стандарту:

// ZeroBroadcast reports whether addr is 255.255.255.255.
func (addr ipv4addr) ZeroBroadcast() bool {
    return addr == 0xFFFFFFFF
}

Из-за номинальной типизации это определение метода добавляет метод к ipv4addr , но не включен uint32 . Хотя методы имеют специальное определение и синтаксис вызова, отдельного типа метода не существует.

Система интерфейса

Go предоставляет две функции, которые заменяют наследование классов .

Первый — это встраивание , которое можно рассматривать как автоматизированную форму композиции .

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

В определении типа интерфейса перечислены необходимые методы по имени и типу. Любой объект типа T, для которого существуют функции, соответствующие всем необходимым методам типа интерфейса I, также является объектом типа I. Определение типа Т не обязательно (и не может) идентифицировать тип I. Например, если Форма , Квадрат и Круг определяются как

import "math"

type Shape interface {
    Area() float64
}

type Square struct { // Note: no "implements" declaration
    side float64
}

func (sq Square) Area() float64 { return sq.side * sq.side }

type Circle struct { // No "implements" declaration here either
    radius float64
}

func (c Circle) Area() float64 { return math.Pi * math.Pow(c.radius, 2) }

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

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

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

var shp Shape = Square{5}
square, ok := shp.(Square) // Asserts Square type on shp, should work
if ok {
	fmt.Printf("%#v\n", square)
} else {
	fmt.Println("Can't print shape as Square")
}

и переключатель типа , который проверяет несколько типов:

func (sq Square) Diagonal() float64 { return sq.side * math.Sqrt2 }
func (c Circle) Diameter() float64 { return 2 * c.radius }

func LongestContainedLine(shp Shape) float64 {
	switch v := shp.(type) {
	case Square:
		return v.Diagonal() // Or, with type assertion, shp.(Square).Diagonal()
	case Circle:
		return v.Diameter() // Or, with type assertion, shp.(Circle).Diameter()
	default:
		return 0 // In practice, this should be handled with errors
	}
}

интерфейс Пустой interface{} является важным базовым вариантом, поскольку он может относиться к элементу любого конкретного типа. Это похоже на Класс объекта в Java или C# , которому удовлетворяет любой тип, включая встроенные типы, такие как инт . Код, использующий пустой интерфейс, не может просто вызывать методы (или встроенные операторы) объекта, на который ссылается, но он может хранить interface{} значение, попробуйте преобразовать его в более полезный тип с помощью утверждения типа или переключения типа или проверьте его с помощью Go reflect упаковка. Потому что interface{} может ссылаться на любое значение, это ограниченный способ обойти ограничения статической типизации, например void* в C, но с дополнительными проверками типов во время выполнения.

The interface{} Тип можно использовать для моделирования структурированных данных любой произвольной схемы в Go, например данных JSON или YAML , представляя их в виде map[string]interface{} (сопоставление строки с пустым интерфейсом). Это рекурсивно описывает данные в виде словаря со строковыми ключами и значениями любого типа.

Значения интерфейса реализуются с использованием указателя на данные и второго указателя на информацию о типе времени выполнения. Как и некоторые другие типы, реализованные с использованием указателей в Go, значения интерфейса nil если не инициализирован.

Общий код с использованием параметризованных типов

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

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

Интерфейсы теперь могут определять набор типов (известный как набор типов), используя | (Объединение), а также набор методов. Эти изменения были внесены для поддержки ограничений типов в коде обобщений. Для универсальной функции или типа ограничение можно рассматривать как тип аргумента типа: метатип. Этот новый ~T синтаксис будет первым использованием ~ как токен в Go. ~T означает набор всех типов, базовым типом которых является T.

type Number interface {
	~int | ~float64 | ~float32 | ~int32 | ~int64
}

func Add[T Number](nums ...T) T {
	var sum T
	for _, v := range nums {
		sum += v
	}
	return sum
}

func main() {
	add := Add[int]             // Type instantiation
	println(add(1, 2, 3, 4, 5)) // 15

	res := Add(1.1, 2.2, 3.3, 4.4, 5.5) // Type Inference
	println(res)                        // +1.650000e+001
}

Перечислимые типы

Этот раздел представляет собой отрывок из Enumerated type § Go . [ редактировать ]

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

type ByteSize float64

const (
    _           = iota // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
)

Система пакетов

В системе пакетов Go каждый пакет имеет путь (например, "compress/bzip2" или "golang.org/x/net/html") и имя (например, bzip2 или html). Ссылки на определения других пакетов всегда должны начинаться с имени другого пакета, и написанные с заглавной буквы : доступны только имена из других пакетов, io.Reader является общедоступным, но bzip2.reader нет. go get команда может извлекать пакеты, хранящиеся в удаленном репозитории разработчикам рекомендуется разрабатывать пакеты внутри базового пути, соответствующего репозиторию исходного кода (например, example.com/имя_пользователя/имя_пакета), чтобы уменьшить вероятность конфликта имен с будущими дополнениями к стандартной библиотеке или другим внешним библиотекам.

Параллелизм: горутины и каналы

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

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

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

Каналы типизированы, поэтому канал типа chan T можно использовать только для передачи сообщений типа Т. ​Для работы с ними используется специальный синтаксис; <-ch — это выражение, которое заставляет выполняющуюся горутину блокироваться до тех пор, пока значение не поступит по каналу. ч , в то время как ch <- x отправляет значение x (возможно, блокировка до тех пор, пока другая горутина не получит значение). Встроенный переключатель - как оператор выбора может использоваться для реализации неблокирующей связи по нескольким каналам; см. ниже пример . В Go есть модель памяти, описывающая, как горутины должны использовать каналы или другие операции для безопасного обмена данными.

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

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

Структурные соглашения Go, связанные с параллелизмом ( каналы и альтернативные входные каналы), взяты из Тони Хоара последовательных процессов связи модели . В отличие от предыдущих языков параллельного программирования, таких как Occam или Limbo (язык, над которым работал соразработчик Go Роб Пайк), Go не предоставляет никакого встроенного понятия безопасного или проверяемого параллелизма. Хотя в Go предпочтительна модель взаимодействующих процессов, она не единственная: все горутины в программе используют одно адресное пространство. Это означает, что изменяемые объекты и указатели могут использоваться совместно горутинами; см. § Отсутствие безопасности при гонке данных ниже.

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

Хотя возможности параллелизма Go не нацелены в первую очередь на параллельную обработку , их можно использовать для программирования машин с общей памятью многопроцессорных . Были проведены различные исследования эффективности этого подхода. В одном из этих исследований сравнивались размер (в строках кода ) и скорость программ, написанных опытным программистом, не знакомым с языком, и исправления этих программ, внесенные экспертом Go (из команды разработчиков Google), сделав то же самое для Chapel , Cilk. и Intel TBB . Исследование показало, что неспециалисты склонны писать алгоритмы «разделяй и властвуй» с одним go для каждой рекурсии, в то время как эксперт писал программы распределения-работы-синхронизации, используя одну горутину на каждое ядро ​​процессора. Программы экспертов обычно были быстрее, но и дольше.

Отсутствие безопасности гонок данных

Подход Go к параллелизму можно резюмировать так: «не общайтесь, разделяя память; делитесь памятью, общаясь». Нет никаких ограничений на то, как горутины получают доступ к общим данным, что делает возможным гонку данных . В частности, если программа явно не синхронизируется через каналы или другие средства, записи из одной горутины могут быть частично, полностью или вообще не видны другой, часто без каких-либо гарантий относительно порядка записи. Go Более того, внутренние структуры данных , такие как значения интерфейса, заголовки срезов, хеш-таблицы и заголовки строк, не защищены от гонок данных, поэтому безопасность типов и памяти может быть нарушена в многопоточных программах, которые изменяют общие экземпляры этих типов без синхронизации. Таким образом, вместо языковой поддержки безопасное параллельное программирование опирается на соглашения; например, Чисналл рекомендует идиому под названием «псевдонимы xor mutable», означающую, что передача изменяемого значения (или указателя) по каналу сигнализирует о передаче права собственности на значение его получателю. Инструментальная цепочка gc имеет дополнительный детектор гонки данных, который может проверять наличие несинхронизированного доступа к общей памяти во время выполнения, начиная с версии 1.1. кроме того, по умолчанию включен детектор гонок с максимальным усилием, начиная с версии 1.6 среды выполнения gc, для доступа к map тип данных.

Бинарные файлы

Компоновщик в цепочке инструментов gc по умолчанию создает статически связанные двоичные файлы; поэтому все двоичные файлы Go включают среду выполнения Go.

Упущения

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

Что касается пропущенных функций языка, дизайнеры явно выступают против утверждений и арифметики указателей, защищая при этом отказ от наследования типов как более полезный язык, поощряя вместо этого использование интерфейсов для достижения динамической диспетчеризации. и композиция для повторного использования кода. Состав и делегирование фактически в значительной степени автоматизированы структуры встраивание ; по мнению исследователей Шмагера и др. , эта функция «имеет множество недостатков наследования: она влияет на общедоступный интерфейс объектов, она не является детальной (т. е. отсутствует контроль над внедрением на уровне метода), методы встроенных объектов не могут быть скрыты и она статична. ", что делает "неочевидным", будут ли программисты злоупотреблять им до такой степени, как программисты на других языках, как известно, злоупотребляют наследованием.

Обработка исключений изначально была опущена в Go из-за отсутствия «дизайна, который дает ценность, пропорциональную сложности». Исключение, похожее на паника / механизм восстановления , который позволяет избежать обычного try-catch была предложена структура контроля и выпущен на снимке от 30 марта 2010 г. Авторы Go советуют использовать его для неисправимых ошибок, например тех, которые должны остановить всю программу или запрос к серверу, или в качестве ярлыка для распространения ошибок вверх по стеку внутри пакета. За пределами пакета Go включает канонический тип ошибки, и возвраты с несколькими значениями, использующие этот тип, являются стандартной идиомой.

Стиль

Авторы Go приложили значительные усилия, чтобы повлиять на стиль программ Go:

• Отступы, интервалы и другие детали кода на поверхностном уровне автоматически стандартизируются gofmt инструмент. В нем используются табуляции для отступов и пробелы для выравнивания. Выравнивание предполагает, что редактор использует шрифт фиксированной ширины. golint автоматически выполняет дополнительные проверки стиля, но он устарел и заархивирован сопровождающими Go.
• Инструменты и библиотеки, распространяемые вместе с Go, предлагают стандартные подходы к таким вещам, как документация API ( godoc), тестирование ( go test), здание ( go build), управление пакетами ( go get), и так далее.
• Go применяет правила, которые являются рекомендациями на других языках, например, запрещает циклические зависимости, неиспользуемые переменные. или импорт, и неявные преобразования типов.
• Отсутствие как определенных функций (например, ярлыков функционального программирования, таких map и в стиле Java try/ finally блоки) имеет тенденцию поощрять определенный явный, конкретный и императивный стиль программирования.
• В первый день команда Го опубликовала сборник идиом Го. а позже также собрал комментарии по проверке кода, переговоры, и официальные сообщения в блоге преподавать стиль Go и философию кодирования.

Инструменты

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

• go build, который собирает двоичные файлы Go, используя только информацию из самих исходных файлов, без отдельных make-файлов.
• go test, для модульного тестирования и микробенчмарков, а также фаззинга
• go fmt, для форматирования кода
• go install, для получения и установки удаленных пакетов
• go vet, статический анализатор, ищущий потенциальные ошибки в коде
• go run, ярлык для создания и выполнения кода
• godoc, для отображения документации или ее обслуживания через HTTP
• gorename, для переименования переменных, функций и т. д. типобезопасным способом.
• go generate, стандартный способ вызова генераторов кода
• go mod, для создания нового модуля, добавления зависимостей, обновления зависимостей и т. д.

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

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

К стандартному дистрибутиву добавляется экосистема сторонних инструментов, таких как gocode, который обеспечивает автодополнение кода во многих текстовых редакторах, goimports, который автоматически добавляет/удаляет импорт пакетов по мере необходимости и errcheck, который обнаруживает код, который может непреднамеренно игнорировать ошибки.

Примеры

Привет, мир

package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

где «fmt» — это пакет для форматированного ввода-вывода , аналогичный входу/выводу файла C в C.

Параллелизм

Следующая простая программа демонстрирует возможности параллелизма Go для реализации асинхронной программы. Он запускает два легких потока («го-рутины»): один ждет, пока пользователь наберет текст, а другой реализует тайм-аут. Оператор select ожидает, пока любая из этих горутин отправит сообщение основной подпрограмме, и действует в соответствии с первым поступившим сообщением (пример, адаптированный из книги Дэвида Чисналла).

package main

import (
    "fmt"
    "time"
)

func readword(ch chan string) {
    fmt.Println("Type a word, then hit Enter.")
    var word string
    fmt.Scanf("%s", &word)
    ch <- word
}

func timeout(t chan bool) {
    time.Sleep(5 * time.Second)
    t <- false
}

func main() {
    t := make(chan bool)
    go timeout(t)

    ch := make(chan string)
    go readword(ch)

    select {
    case word := <-ch:
        fmt.Println("Received", word)
    case <-t:
        fmt.Println("Timeout.")
    }
}

Тестирование

Пакет тестирования обеспечивает поддержку автоматического тестирования пакетов go. Пример целевой функции:

func ExtractUsername(email string) string {
	at := strings.Index(email, "@")
	return email[:at]
}

Код теста (обратите внимание, что ключевое слово Assert отсутствует в Go; тесты находятся в <filename>_test.go в том же пакете):

import (
    "testing"
)

func TestExtractUsername(t *testing.T) {
	t.Run("withoutDot", func(t *testing.T) {
		username := ExtractUsername("[email protected]")
		if username != "r" {
			t.Fatalf("Got: %v\n", username)
		}
	})

	t.Run("withDot", func(t *testing.T) {
		username := ExtractUsername("[email protected]")
		if username != "jonh.smith" {
			t.Fatalf("Got: %v\n", username)
		}
	})
}

Возможно параллельное выполнение тестов.

Веб-приложение

Пакет net/http обеспечивает поддержку создания веб-приложений.

В этом примере будет показано «Привет, мир!» при посещении localhost:8080.

package main

import (
    "fmt"
    "log"
    "net/http"
)

func helloFunc(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello world!")
}

func main() {
    http.HandleFunc("/", helloFunc)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Приложения

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

Среди популярных приложений: Caddy — веб-сервер, автоматизирующий процесс настройки HTTPS, Docker , предоставляющий платформу для контейнеризации, призванную упростить разработку и развертывание программного обеспечения. Kubernetes , который автоматизирует развертывание, масштабирование и управление контейнерными приложениями. CockroachDB — распределенная база данных SQL, разработанная для обеспечения масштабируемости и строгой согласованности. и Hugo — генератор статических сайтов, в котором приоритет отдается скорости и гибкости, что позволяет разработчикам эффективно создавать веб-сайты.

Прием

Система интерфейса и намеренное отсутствие наследования были высоко оценены Микеле Симионато, который сравнил эти характеристики с характеристиками Standard ML , назвав это «позором, что ни один популярный язык не пошел по [этому] конкретному пути».

Дэйв Астелс из Engine Yard писал в 2009 году:

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

Go был назван языком программирования года по версии Индекса сообщества программистов TIOBE в первый, 2009 год, за более значительный рост популярности за 12 месяцев (всего за 2 месяца после его появления в ноябре), чем у любого другого языка в этом году. и к январю 2010 года достиг 13-го места, превосходя признанные языки, такие как Паскаль . К июню 2015 года его рейтинг упал ниже 50-го места в индексе, что поставило его ниже, чем COBOL и Fortran . Но по состоянию на январь 2017 года его рейтинг поднялся до 13-го места, что указывает на значительный рост популярности и принятия. Go снова был удостоен награды TIOBE «Язык программирования года» в 2016 году.

Брюс Экель заявил:

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

Оценка языка и его gc по сравнению с C++ ( GCC ), Java и Scala инженером Google обнаружил:

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

— Р. Хундт

Оценка получила опровержение со стороны команды разработчиков Go. Ян Лэнс Тейлор, который улучшил код Go для статьи Хундта, не знал о намерении опубликовать свой код и говорит, что его версия «никогда не предназначалась для того, чтобы быть примером идиоматического или эффективного Go»; Затем Расс Кокс оптимизировал код Go, а также код C++, и добился того, что код Go работал почти так же быстро, как версия C++, и более чем на порядок быстрее, чем код в статье.

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

Спор об имени

10 ноября 2009 г., в день общего релиза языка, Фрэнсис Маккейб, разработчик Go ! язык программирования (обратите внимание на восклицательный знак), попросил Google изменить название языка, чтобы избежать путаницы с его языком, на разработку которого он потратил 10 лет. Маккейб выразил обеспокоенность тем, что «большой парень» в конечном итоге нападет на него, и эта обеспокоенность нашла отклик у более чем 120 разработчиков, которые прокомментировали официальную ветку проблем Google, заявив, что им следует сменить имя, причем некоторые даже если сказать, что эта проблема противоречит девизу Google: « Не будь злым» .

12 октября 2010 г. поданная заявка на публичную проблему была закрыта разработчиком Google Рассом Коксом (@rsc) с настраиваемым статусом «Неудачно», сопровождаемым следующим комментарием:

«Существует множество компьютерных продуктов и сервисов под названием Go. За 11 месяцев, прошедших с момента нашего выпуска, в двух языках произошла минимальная путаница».

См. также

• Жирный указатель
• Сравнение языков программирования

Ссылки

В эту статью включены материалы из официального руководства по Go , которое распространяется по лицензии Creative Commons Attribution 3.0.

Дальнейшее чтение

• Донован, Алан; Керниган, Брайан (октябрь 2015 г.). Язык программирования Go (1-е изд.). Аддисон-Уэсли Профессионал . п. 400. ИСБН  978-0-13-419044-0 .
• Боднер, Джон (март 2021 г.). Изучение го (1-е изд.). О'Рейли . п. 352. ИСБН  9781492077213 .

Внешние ссылки

• Официальный сайт