Что такое Golang? Язык Go простыми словами, с примерами

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

Вот полная программа на Go. Нажмите Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Любая программа на Go начинается в package main с функции func main(). := объявляет переменную и выводит её тип (здесь []string, слайс строк). range проходит по слайсу и отдаёт индекс и значение. fmt и strings входят в стандартную библиотеку, и она настолько большая, что многим программам больше ничего импортировать не нужно.

Go или Golang: откуда два названия

Язык называется Go. «Golang» это прозвище из адреса первого сайта проекта, golang.org (сейчас сайт живёт на go.dev). Название прижилось, потому что поиск по слову «go» выдаёт что угодно, кроме языка. В официальной документации пишут «Go», но в поисковую строку почти все вводят «golang», и оба слова означают одно и то же. Отдельного продукта или диалекта «Golang» не существует.

Кто создал Go и зачем

Роберт Гриземер, Роб Пайк и Кен Томпсон начали проектировать Go в Google в 2007 году. В ноябре 2009 года язык стал open source, а в марте 2012 года вышел Go 1.0.

Мотивация была практической. Большие кодовые базы Google на C++ и Java долго собирались, графами зависимостей было трудно управлять, а многоядерные машины и сетевые сервисы стали нормой, при этом писать конкурентный код было легко с ошибками. Дизайн Go отвечает на эти проблемы напрямую:

• Быстрая сборка. Импорты явные, неиспользуемый импорт считается ошибкой компиляции, а компилятор не разбирает заголовочные файлы заново, поэтому большие программы собираются за секунды.
• Простой язык. Мало ключевых слов, один цикл (for), нет наследования, нет исключений. Код разных людей обычно выглядит похоже, и в большой команде это упрощает ревью.
• Конкурентность как часть языка. Чтобы запустить конкурентную задачу, достаточно одного ключевого слова, go, а каналы позволяют задачам обмениваться данными.
• Простой деплой. На выходе один бинарник, который вы копируете на сервер. Обычно он слинкован статически; при включённом cgo пакеты вроде net могут линковаться с системной библиотекой C, и CGO_ENABLED=0 это отключает.

Вместе с Go 1.0 появилось обещание совместимости Go 1: программы, написанные под Go 1.0, продолжают компилироваться и работать на последующих версиях 1.x. На практике обновление тулчейна редко ломает код, и это одна из главных причин, почему команды доверяют Go долгоживущие сервисы.

Для чего используется Golang

Go сильнее всего там, где программа работает с сетью, живёт долго и её нужно просто доставлять на серверы:

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

Ключевые возможности на примерах

Статическая типизация с выводом типов

У каждой переменной тип фиксирован на этапе компиляции, но писать его приходится редко. := выводит тип сам:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go никогда не преобразует числовые типы молча. count * price не скомпилируется, потому что один операнд int, а другой float64; float64(count) вы пишете сами. Это исключает незаметное усечение и ошибки точности.

Ошибки это значения

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

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

Шаблон if err != nil это самая узнаваемая строка в коде на Go. Он многословен, и в этом весь смысл: каждое место, где программа может упасть, видно там, где это происходит. Как оборачивать и разбирать ошибки, смотрите в разделе обработка ошибок.

Горутины и каналы

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

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

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

Интерфейсы без «implements»

Тип удовлетворяет интерфейсу просто потому, что у него есть нужные методы. Ключевого слова implements нет:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect и Circle нигде не упоминают Shape, но оба можно положить в []Shape. Благодаря этому интерфейс можно объявить в пакете, который его использует, спустя долгое время после того, как конкретные типы были написаны.

Один тулчейн

Команда go делает всё: go run компилирует и запускает, go build собирает бинарник, go test запускает тесты, go fmt форматирует код, go vet находит подозрительные конструкции, а go mod управляет зависимостями. Стиль форматирования один, официальный, и его обеспечивает gofmt, поэтому в Go-проектах не спорят о скобках и отступах.

Чего в Go нет намеренно

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

• Нет классов и наследования. Вместо них структуры, методы, интерфейсы и встраивание.
• Нет исключений. Ошибки возвращаются как значения. panic существует, но он для багов, а не для обычных сбоев.
• Нет тернарного оператора. Пишите if/else.
• Нет ключевого слова while. for покрывает все виды циклов.
• Нет перегрузки функций и аргументов по умолчанию.
• Дженерики появились только в Go 1.18, и они намеренно ограничены по сравнению с шаблонами C++ или дженериками Java.

Честные компромиссы

Многословность. Явные проверки ошибок и отсутствие сокращений вроде тернарного оператора делают код на Go длиннее аналогичного на Python или Kotlin. Читать его легко, но строк получается больше.

Сборка мусора. Сборщик мусора в Go даёт короткие паузы, но это всё равно сборщик мусора. Для систем жёсткого реального времени или кода, где важна каждая аллокация, C, C++ или Rust дают больше контроля.

Значения nil. В Go бывают nil-указатели, мапы, слайсы и интерфейсы. Разыменование nil-указателя приводит к панике во время выполнения, и компилятор не защищает от этого так, как система типов Rust.

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

Пробелы в экосистеме. Библиотеки для веб-сервисов, баз данных и облачных API отличные. Для GUI, научных вычислений и машинного обучения у Python, C++ или Julia выбор гораздо шире.

Go в сравнении с другими языками

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

Стоит ли учить Go?

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

Чтобы писать на Go у себя на компьютере, установите Go, а затем пройдите страницу hello world: там разобрана каждая строка первой программы.