Cheat sheet Golang

Przydatne polecenia i konstrukcje w golangu

Page content

Oto podstawowa struktura programu w Go, wzorce obsługi błędów oraz porównanie kanałów z gorutynami.

kotki wokół znaku golang

Cheatsheet języka Go

Podstawowy składnia

Deklaracja pakietu

package main

Importowanie pakietów

import "fmt"
import (
    "fmt"
    "math"
)

Funkcja main

func main() {
    // Twój kod tutaj
}

Zmienne i typy

Deklaracja zmiennej

var name string
var age int = 25
x := 10 // Krótsza deklaracja

Podstawowe typy

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128

Struktury kontrolne

Instrukcja if

if x > 0 {
    // kod
} else if x < 0 {
    // kod
} else {
    // kod
}

Pętla for

for i := 0; i < 10; i++ {
    // kod
}

Pętla range

for index, value := range collection {
    // kod
}

Instrukcja switch

switch variable {
case value1:
    // kod
case value2:
    // kod
default:
    // kod
}

Funkcje

Deklaracja funkcji

func functionName(param1 type1, param2 type2) returnType {
    // kod
    return value
}

Wielokrotne zwracanie wartości

func divideAndRemainder(x, y int) (int, int) {
    return x / y, x % y
}

Struktury danych

Tablice

var numbers int
numbers := int{1, 2, 3, 4, 5}

Slices

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

Mapy

m := make(map[string]int)
m["key"] = value

Struktury

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

Metody

Deklaracja metody

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

Interfejsy

Deklaracja interfejsu

type Shape interface {
    Area() float64
}

Konkurencja

Gorutyny

go functionName()

Kanały

ch := make(chan int)
ch <- value  // Wysyłanie
value := <-ch  // Odbieranie

Obsługa błędów

Sprawdzanie błędów

if err != nil {
    // Obsługa błędu
}

Defer

defer file.Close()

Testowanie

Funkcja testowa

func TestFunction(t *testing.T) {
    // Kod testowy
}

Ten cheatsheet obejmuje najważniejsze konstrukcje i polecenia języka Go. Zawiera podstawową składnię, struktury kontrolne, funkcje, struktury danych, metody, interfejsy, elementy konkurujące oraz obsługę błędów. Pamiętaj, że Go podkreśla prostotę i czytelność, więc te konstrukcje stanowią podstawę do pisania wydajnego i przejrzystego kodu w Go.

Obsługa błędów w Go

Obsługa błędów w Go jest prosta i jawna, podkreślając przejrzystość i odporność. Oto kluczowe techniki obsługi błędów w Go:

Zwracanie błędów jako wartości: Funkcje, które mogą zakończyć się niepowodzeniem, powinny zwracać błąd jako ostatnią wartość zwracaną. Na przykład:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("puste imię")
    }
    message := fmt.Sprintf("Cześć, %v. Witaj!", name)
    return message, nil
}

Zawsze sprawdzaj błędy: Po wywołaniu funkcji zwracającej błąd, natychmiast sprawdź, czy wartość błędu nie jest nil. Na przykład:

result, err := SomeFunction()
if err != nil {
    // Obsługa błędu
    log.Fatal(err)
}

Używaj opakowywania błędów: Gdy przekazujesz błędy w górę stosu wywołań, opakuj je, aby dodać kontekst, używając fmt.Errorf() z formatem %w. Na przykład:

f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("otwarcie nie powiodło się: %w", err)
}

Używaj defer do czyszczenia: Używaj defer, aby upewnić się, że zasoby są poprawnie zamknięte lub wyczyszczone, nawet jeśli wystąpi błąd.
Twórz własne typy błędów: Implementuj interfejs error dla własnych typów błędów, aby dostarczyć bardziej szczegółowych informacji o błędzie.
Używaj pakietu errors: Wykorzystuj funkcje takie jak errors.New() do tworzenia prostych komunikatów o błędach, oraz errors.Is() lub errors.As() do sprawdzania i konwersji typów błędów.
Unikaj używania panic: Rezerwuj panic dla naprawdę nieodzyskiwalnych sytuacji. Normalna obsługa błędów powinna korzystać z wartości zwracanych.
Dostarcz jasne informacje o błędach: Utwórz jasne i informacyjne komunikaty o błędach, aby pomóc w debugowaniu i rozwiązywaniu problemów.

Korzystając z tych praktyk, możesz tworzyć odporną na błędy aplikację w Go, która skutecznie obsługuje błędy i utrzymuje przejrzystość kodu.

Najlepsze praktyki dotyczące gorutyn i kanałów w Go

Efektywne korzystanie z gorutyn

Unikaj nadmiernej liczby gorutyn: Twórz gorutyny ostrożnie, biorąc pod uwagę naturę zadania i czy rzeczywiście korzysta z równoległego wykonywania.
Poprawna synchronizacja: Używaj mechanizmów synchronizacji, takich jak kanały lub grupy oczekiwania, aby skutecznie zarządzać gorutynami i unikać marnotrawstwa zasobów.
Ocena natury zadania: Przed użyciem gorutyn oceniaj, czy zadanie rzeczywiście korzysta z wykonywania w trybie współbieżnym.

Efektywne korzystanie z kanałów

Wybierz odpowiedni typ kanału: Używaj niezbuforowanych kanałów do synchronizacji i zbuforowanych kanałów, gdy potrzebujesz odłączenia operacji wysyłania i odbierania.
Pojemność bufora: Gdy korzystasz z zbuforowanych kanałów, dokładnie rozważ rozmiar bufora, aby zrównoważyć wydajność i wykorzystanie zasobów.
Poprawne zamknięcie kanałów: Upewnij się, że kanały są zamknięte, gdy nie będzie już wysyłane żadne dane, aby uniknąć zakłóceń i wycieków zasobów.

Wzorce współbieżności

Wzorzec puli pracownika: Implementuj puli pracowników za pomocą gorutyn i kanałów do efektywnego rozdzielania zadań i zbierania wyników.
Wzorzec producenta-konsumenta: Używaj gorutyn jako producentów i konsumentów, a kanały do przesyłania danych między nimi.

Obsługa błędów i zarządzanie zasobami

Używaj defer do czyszczenia: Używaj instrukcji defer, aby upewnić się, że zasoby są poprawnie wyczyszczone, nawet jeśli wystąpi błąd.
Obsługa panik: Implementuj recover() w długotrwałych gorutynach, aby zapobiec całkowitemu zawieszeniu programu z powodu paniki w pojedynczej gorucie.

Komunikacja i synchronizacja

Preferuj kanały nad pamięcią współdzieloną: Używaj kanałów do komunikacji między gorutynami, aby uniknąć warunków wyścigu i uprościć synchronizację.
Używaj select do wielu kanałów: Wykorzystuj instrukcję select, aby zarządzać wieloma operacjami kanałów współbieżnie.

Rozważenia dotyczące wydajności

Ogranicz operacje współbieżne: Używaj semaforów lub puli pracowników, aby ograniczyć liczbę operacji współbieżnych i zapobiec wyczerpywaniu zasobów.
Unikaj przedwczesnej optymalizacji: Profiluj swój kod, aby zidentyfikować wąskie gardła, zanim zastosujesz optymalizacje związane z współbieżnością.

Testowanie i debugowanie

Używaj detektora wyścigów: Regularnie uruchamiaj swoje testy z flagą -race, aby wykryć wyścigi danych.
Pisz testy współbieżne: Twórz testy, które specjalnie sprawdzają swoje ścieżki współbieżne, aby zapewnić niezawodność.

Korzystając z tych najlepszych praktyk, możesz skutecznie wykorzystać model współbieżności w Go, tworząc programy bardziej wydajne, utrzyjmalne i mniej podatne na typowe problemy związane z współbieżnością.

Zobacz inne artykuły techniczne.

Aktualizacja golang na linux

przejdź i pobierz nową wersję: https://go.dev/doc/install
usuń stary:

sudo rm -rf /usr/local/go

zainstaluj nową:

cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz