Go Cheat Sheet: ściąga z Golanga
Ostatnia aktualizacja
Hello World i struktura programu
Każdy program w Go należy do pakietu; punktem wejścia jest func main w pakiecie main.
| Operacja | Składnia |
|---|---|
| Deklaracja pakietu | package main |
| Import pakietu | import "fmt" |
| Import wielu pakietów | import (\n "fmt"\n "os"\n) |
| Punkt wejścia | func main() { ... } |
| Wypisanie linii | fmt.Println("Hello, World!") |
| Wypisanie z formatowaniem | fmt.Printf("%d items\n", n) |
| Uruchomienie pliku | go run main.go |
| Zbudowanie pliku wykonywalnego | go build |
Zmienne i typy
Go jest typowany statycznie, ale z := sam wnioskuje typy.
| Operacja | Składnia |
|---|---|
| Deklaracja z typem | var age int = 30 |
| Deklaracja z wnioskowaniem | var name = "Ada" |
| Krótka deklaracja | count := 0 |
| Kilka naraz | x, y := 1, 2 |
| Stała | const Pi = 3.14 |
| Wartości zerowe | 0, "", false, nil |
| Podstawowe typy | int, float64, string, bool, byte, rune |
| Konwersja typów | f := float64(i) |
Sterowanie przepływem
Go ma tylko jedno słowo kluczowe pętli, for, i nie używa nawiasów wokół warunków.
| Operacja | Składnia |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If z instrukcją inicjalizującą | if v, ok := m[k]; ok { ... } |
| Pętla for (w stylu C) | for i := 0; i < 10; i++ { ... } |
| Pętla w stylu while | for x < 100 { ... } |
| Pętla nieskończona | for { ... } |
| Range po slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch bez wyrażenia | switch { case x > 0: ... } |
| Break / continue | break, continue |
Funkcje
Funkcje są wartościami pierwszej klasy i mogą zwracać wiele wyników.
| Operacja | Składnia |
|---|---|
| Podstawowa funkcja | func add(a int, b int) int { return a + b } |
| Wspólny typ parametrów | func add(a, b int) int { ... } |
| Wiele wartości zwracanych | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Nazwane wartości zwracane | func split(sum int) (x, y int) { x = sum / 2; return } |
| Funkcja o zmiennej liczbie argumentów | func sum(nums ...int) int { ... } |
| Funkcja anonimowa | f := func() { ... } |
| Domknięcie | func counter() func() int { ... } |
| Defer (wykonuje się przy powrocie) | defer file.Close() |
Slice'y i tablice
Tablice mają stały rozmiar; slice'y to dynamiczne widoki na tablice.
| Operacja | Składnia |
|---|---|
| Tablica o stałym rozmiarze | var a [3]int |
| Literał slice'a | nums := []int{1, 2, 3} |
| Utworzenie slice'a | s := make([]int, 0, 10) |
| Dołączenie | s = append(s, 4) |
| Długość / pojemność | len(s), cap(s) |
| Wycinek slice'a | s[1:3] |
| Kopiowanie | copy(dst, src) |
| Iteracja | for i, v := range s { ... } |
Mapy
Mapy to wbudowane w Go tablice mieszające.
| Operacja | Składnia |
|---|---|
| Utworzenie mapy | m := make(map[string]int) |
| Literał mapy | m := map[string]int{"a": 1, "b": 2} |
| Ustawienie wartości | m["c"] = 3 |
| Pobranie wartości | v := m["a"] |
| Sprawdzenie istnienia | v, ok := m["x"] |
| Usunięcie klucza | delete(m, "a") |
| Długość | len(m) |
| Iteracja | for k, v := range m { ... } |
Struktury i metody
Struktury grupują pola; metody dodają zachowanie przez odbiorcę (receiver).
| Operacja | Składnia |
|---|---|
| Definicja struktury | type Point struct { X, Y int } |
| Utworzenie instancji | p := Point{X: 1, Y: 2} |
| Dostęp do pola | p.X |
| Wskaźnik na strukturę | p := &Point{1, 2} |
| Metoda z odbiorcą wartościowym | func (p Point) Dist() float64 { ... } |
| Metoda z odbiorcą wskaźnikowym | func (p *Point) Move(dx int) { p.X += dx } |
| Struktura osadzona | type Circle struct { Point; R int } |
| Tagi struktur | Name string z tagiem json:"name" w odwrotnych apostrofach |
Interfejsy
Interfejsy są spełniane niejawnie: kwalifikuje się każdy typ z odpowiednimi metodami.
| Operacja | Składnia |
|---|---|
| Definicja interfejsu | type Shape interface { Area() float64 } |
| Implementacja (niejawna) | func (c Circle) Area() float64 { ... } |
| Pusty interfejs (any) | var x interface{} lub var x any |
| Asercja typu | s, ok := x.(string) |
| Switch po typie | switch v := x.(type) { case int: ... } |
| Interfejs Stringer | func (p Point) String() string { ... } |
Gorutyny i kanały
Gorutyny to lekkie wątki; kanały przekazują między nimi wartości.
| Operacja | Składnia |
|---|---|
| Uruchomienie gorutyny | go doWork() |
| Utworzenie kanału | ch := make(chan int) |
| Kanał buforowany | ch := make(chan int, 5) |
| Wysłanie do kanału | ch <- 42 |
| Odbiór z kanału | v := <-ch |
| Zamknięcie kanału | close(ch) |
| Range po kanale | for v := range ch { ... } |
| Select na kanałach | select { case v := <-ch: ...; default: ... } |
| WaitGroup | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Obsługa błędów
Go zwraca błędy jako wartości: nie ma wyjątków.
| Operacja | Składnia |
|---|---|
| Zwrócenie błędu | func read() (string, error) { return "", err } |
| Sprawdzenie błędu | if err != nil { return err } |
| Utworzenie błędu | errors.New("not found") |
| Błąd z formatowaniem | fmt.Errorf("bad id %d", id) |
| Opakowanie błędu | fmt.Errorf("load: %w", err) |
| Rozpakowanie / dopasowanie | errors.Is(err, os.ErrNotExist) |
| Dopasowanie po typie | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
Najczęściej używana składnia Go na jednej stronie. Ten Go cheat sheet to szybka ściąga z podstaw języka: zmienne i typy, slice'y i mapy, struktury i interfejsy, a do tego gorutyny i kanały, dzięki którym Golang błyszczy we współbieżności.
Wszystko tutaj to standardowy Go, który kompiluje się oficjalnym zestawem narzędzi. Skopiuj to, czego potrzebujesz, albo uruchom każdy fragment w edytorze online Go, bez instalacji. Uczysz się Go? Darmowy interaktywny kurs Go w Coddy krok po kroku omawia slice'y, struktury, interfejsy i gorutyny.
Go cheat sheet: najczęstsze pytania
Czy ten Go cheat sheet jest darmowy?
Tak. Ta ściąga z Go jest całkowicie darmowa i nie wymaga rejestracji. Dodaj ją do zakładek i wracaj, gdy potrzebujesz sprawdzić operację na slice'ach, wzorzec z kanałami albo metodę struktury.
Czym różni się := od var w Go?
var x = 0 deklaruje zmienną i działa wszędzie, także na poziomie pakietu. x := 0 to krótka deklaracja zmiennej: jednocześnie deklaruje i przypisuje, wnioskuje typ i można jej używać tylko wewnątrz funkcji. Używaj var, gdy potrzebujesz jawnego typu albo zmiennej na poziomie pakietu, a := do zwięzłych deklaracji lokalnych.Czym są gorutyny i kanały?
Gorutyna to lekki wątek zarządzany przez środowisko uruchomieniowe Go: uruchamiasz ją, pisząc
go someFunc(). Kanały to typowane łącza, dzięki którym gorutyny bezpiecznie się komunikują: jedna gorutyna wysyła przez ch <- v, a druga odbiera przez <-ch. Razem tworzą podstawowy model współbieżności Go, streszczony w powiedzeniu "dziel się pamięcią, komunikując się".Czy mogę ćwiczyć Go online?
Tak. Otwórz edytor online Go, aby uruchomić dowolny fragment z tej ściągi w przeglądarce, bez instalowania narzędzi Go. Gdy chcesz uczyć się bardziej systematycznie, darmowy interaktywny kurs Go w Coddy prowadzi krok po kroku od zmiennych i slice'ów do gorutyn i kanałów.
Czy ta ściąga nadaje się dla początkujących?
Tak. Jest ułożona od najczęstszych tematów (zmienne, sterowanie przepływem, funkcje) do bardziej zaawansowanych (gorutyny, kanały, obsługa błędów), więc górnych sekcji możesz używać od pierwszego dnia, a resztę poznawać z czasem.
Powiązane materiały
Więcej ściąg
