Język Go: czym jest Golang, do czego służy i przykłady

Go to statycznie typowany, kompilowany język programowania stworzony w Google. Tworzy pojedynczą natywną binarkę, kompiluje się w kilka sekund, ma garbage collector, a współbieżność jest wbudowana w język dzięki goroutine i kanałom. Jego główne zastosowanie to oprogramowanie po stronie serwera: API, usługi sieciowe oraz narzędzia wiersza poleceń i chmury, które je obsługują.

Oto kompletny program w Go. Naciśnij 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"))
}

Każdy program w Go zaczyna się w package main od func main(). := deklaruje zmienną i wnioskuje jej typ (tutaj []string, slice stringów). range przechodzi po slice'ie i daje indeks oraz wartość. fmt i strings pochodzą z biblioteki standardowej, która jest na tyle duża, że wiele programów nie importuje niczego innego.

Go a Golang: nazwa

Język nazywa się Go. „Golang” to przydomek od pierwszej strony projektu, golang.org (strona jest teraz pod adresem go.dev). Ludzie dalej go używali, bo wyszukiwanie w sieci słowa „go” zwraca wszystko poza tym językiem. Oficjalna dokumentacja mówi „Go”, ale „golang” to termin, który prawie każdy wpisuje w wyszukiwarkę, i oba znaczą to samo. Nie istnieje osobny produkt ani dialekt „Golang”.

Kto stworzył Go i po co

Robert Griesemer, Rob Pike i Ken Thompson zaczęli projektować Go w Google w 2007 roku. Kod udostępniono jako open source w listopadzie 2009, a Go 1.0 ukazało się w marcu 2012.

Motywacja była praktyczna. Duże bazy kodu w C++ i Javie w Google długo się budowały, grafami zależności trudno było zarządzać, a maszyny wielordzeniowe i usługi sieciowe były normą, choć pisanie kodu współbieżnego łatwo prowadziło do błędów. Projekt Go odpowiada bezpośrednio na te problemy:

• Szybkie budowanie. Importy są jawne, nieużywane importy to błąd kompilacji, a kompilator nie parsuje ponownie nagłówków, więc duże programy budują się w kilka sekund.
• Prosty język. Mało słów kluczowych, jedna pętla (for), brak dziedziczenia, brak wyjątków. Kod pisany przez różne osoby zwykle wygląda podobnie, co pomaga w code review w dużym zespole.
• Współbieżność jako funkcja języka. Uruchomienie współbieżnego zadania to jedno słowo kluczowe, go, a kanały pozwalają zadaniom się komunikować.
• Łatwe wdrażanie. Wynikiem jest jedna binarka, którą kopiujesz na serwer. Zwykle jest linkowana statycznie; z włączonym cgo pakiety takie jak net mogą linkować się z systemową biblioteką C, a CGO_ENABLED=0 to wyłącza.

Razem z Go 1.0 pojawiła się obietnica zgodności Go 1: programy napisane dla Go 1.0 nadal kompilują się i działają z późniejszymi wydaniami 1.x. W praktyce aktualizacja zestawu narzędzi rzadko psuje kod, i to ważny powód, dla którego zespoły ufają Go w długo działających usługach.

Do czego służy Golang

Go jest najmocniejszy tam, gdzie program komunikuje się przez sieć, działa długo i musi być łatwy do wdrożenia:

Gorzej sprawdza się w desktopowych aplikacjach z GUI, aplikacjach mobilnych, frontendach w przeglądarce oraz obliczeniach numerycznych i uczeniu maszynowym, gdzie inne ekosystemy mają dużo lepsze biblioteki.

Najważniejsze cechy w kodzie

Typy statyczne z wnioskowaniem

Każda zmienna ma typ ustalony podczas kompilacji, ale rzadko go wypisujesz. := go wnioskuje:

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 nigdy nie konwertuje po cichu między typami liczbowymi. count * price się nie kompiluje, bo jedno to int, a drugie float64; float64(count) trzeba napisać jawnie. To eliminuje błędy cichego obcinania i utraty precyzji.

Błędy to wartości

Go nie ma wyjątków. Funkcja, która może się nie powieść, zwraca error jako ostatni wynik, a wywołujący go sprawdza:

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)
	}
}

Wzorzec if err != nil to najbardziej rozpoznawalna linia w kodzie Go. Jest rozwlekły i właśnie o to chodzi: każde miejsce, w którym program może zawieść, jest widoczne tam, gdzie to się dzieje. Opakowywanie i sprawdzanie błędów opisuje strona o obsłudze błędów.

Goroutine i kanały

Goroutine to funkcja działająca współbieżnie z resztą programu. Kosztuje kilka kilobajtów stosu, więc uruchamianie tysięcy goroutine to normalna rzecz. Kanały bezpiecznie przekazują wartości między goroutine:

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)
	}
}

Trzy goroutine działają współbieżnie, więc trzy linie mogą wypisać się w dowolnej kolejności. Uruchom program kilka razy, a możesz zobaczyć różne kolejności. main odbiera dokładnie trzy wartości, więc czeka na wszystkie przed zakończeniem.

Interfejsy bez „implements”

Typ spełnia interfejs po prostu dlatego, że ma odpowiednie metody. Nie ma słowa kluczowego 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 i Circle nigdzie nie wspominają o Shape, a mimo to oba można przechowywać w []Shape. Dzięki temu możesz zdefiniować interfejs w pakiecie, który go używa, długo po napisaniu konkretnych typów.

Jeden zestaw narzędzi

Polecenie go robi wszystko: go run kompiluje i uruchamia, go build tworzy binarkę, go test uruchamia testy, go fmt formatuje kod, go vet wyłapuje podejrzane konstrukcje, a go mod zarządza zależnościami. Istnieje jeden oficjalny styl formatowania, wymuszany przez gofmt, więc w projektach Go nikt nie kłóci się o nawiasy klamrowe czy wcięcia.

Czego Go celowo nie ma

Niektórych funkcji popularnych w innych językach celowo brakuje:

• Brak klas i dziedziczenia. Używasz struktur, metod, interfejsów i osadzania.
• Brak wyjątków. Błędy to zwracane wartości. panic istnieje, ale służy do błędów programistycznych, a nie zwykłych niepowodzeń.
• Brak operatora trójargumentowego. Piszesz if/else.
• Brak słowa kluczowego while. for obsługuje każdą pętlę.
• Brak przeciążania funkcji i domyślnych argumentów.
• Generyki dopiero od Go 1.18, i celowo ograniczone w porównaniu z szablonami C++ czy generykami Javy.

Uczciwe kompromisy

Rozwlekłość. Jawne sprawdzanie błędów i brak skrótów, takich jak operator trójargumentowy, sprawiają, że kod w Go jest dłuższy niż odpowiednik w Pythonie czy Kotlinie. Czyta się go łatwo; pisanie wymaga więcej linii.

Garbage collection. Garbage collector w Go ma krótkie pauzy, ale nadal jest garbage collectorem. W systemach twardego czasu rzeczywistego albo w kodzie, w którym liczy się każda alokacja, C, C++ lub Rust dają więcej kontroli.

Wartości nil. Go ma wskaźniki, mapy, slice'y i interfejsy o wartości nil. Dereferencja wskaźnika nil to panic w czasie działania, a kompilator nie zapobiega jej tak, jak robi to system typów Rusta.

Mały system typów. Brak typów sumy, brak enumów (buduje się je ze stałych i iota) oraz generyki, które pokrywają typowe przypadki, ale nie zaawansowane programowanie na poziomie typów.

Luki w ekosystemie. Biblioteki do usług webowych, baz danych i API chmurowych są doskonałe. Do GUI, obliczeń naukowych i uczenia maszynowego Python, C++ czy Julia mają znacznie więcej.

Go w porównaniu z innymi językami

Wybierz Go, gdy chcesz wydajności języka kompilowanego i prostego wdrażania bez stromej krzywej nauki Rusta czy ceremonii Javy.

Czy warto uczyć się Go?

Jeśli piszesz usługi backendowe, narzędzia wiersza poleceń albo cokolwiek z obszaru infrastruktury chmurowej, tak. W Go napisana jest duża część tego ekosystemu, a czytanie jego kodu źródłowego to część pracy. Język jest mały, więc nakład jest skromny: podstawowa składnia zajmuje kilka dni, a idiomatyczna współbieżność i obsługa błędów kilka tygodni praktyki.

Aby zacząć pisać w Go lokalnie, zainstaluj Go, a potem przejdź przez stronę hello world, która wyjaśnia każdą linię pierwszego programu.