Golang-Kurzreferenz

Nützliche Go-Befehle und Konstrukte

Inhaltsverzeichnis

Hier ist die grundlegende Go-Programmstruktur, Fehlerbehandlungsmuster und Vergleich von Kanälen vs. Goroutines.

Bunny um Golang-Schild

Go-Sprach-Checkliste

Grundlegende Syntax

Paketdeklaration

package main

Pakete importieren

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

Hauptfunktion

func main() {
    // Dein Code hier
}

Variablen und Typen

Variablendeklaration

var name string
var age int = 25
x := 10 // Kurze Deklaration

Grundlegende Typen

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

Steuerstrukturen

If-Anweisung

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

For-Schleife

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

Range-Schleife

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

Switch-Anweisung

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

Funktionen

Funktionserklärung

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

Mehrfache Rückgabewerte

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

Datenstrukturen

Arrays

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

Slices

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

Maps

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

Structs

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

Methoden

Methoden Deklaration

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

Schnittstellen

Schnittstellen Deklaration

type Shape interface {
    Area() float64
}

Konkurrenz

Goroutines

go functionName()

Kanäle

ch := make(chan int)
ch <- value  // Senden
value := <-ch  // Empfangen

Fehlerbehandlung

Fehlerprüfung

if err != nil {
    // Fehler behandeln
}

Defer

defer file.Close()

Tests

Testfunktion

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

Diese Checkliste umfasst die wichtigsten Go-Sprachkonstrukte und Befehle. Sie enthält grundlegende Syntax, Steuerstrukturen, Funktionen, Datenstrukturen, Methoden, Schnittstellen, Konkurrenzprimitive und Fehlerbehandlung. Denken Sie daran, dass Go Einfachheit und Lesbarkeit betont, sodass diese Konstrukte die Grundlage für das Schreiben effizienter und klarer Go-Code bilden.

Fehlerbehandlung in Go

Die Fehlerbehandlung in Go ist direkt und explizit, mit dem Fokus auf Klarheit und Robustheit. Hier sind die wichtigsten Techniken zur Fehlerbehandlung in Go:

Fehler als Werte zurückgeben: Funktionen, die fehlschlagen können, sollten einen Fehler als letzten Rückgabewert zurückgeben. Beispiel:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("leerer Name")
    }
    message := fmt.Sprintf("Hallo, %v. Willkommen!", name)
    return message, nil
}

Fehler immer prüfen: Nachdem eine Funktion aufgerufen wurde, die einen Fehler zurückgibt, prüfen Sie sofort, ob der Fehler nicht nil ist. Beispiel:

result, err := SomeFunction()
if err != nil {
    // Fehler behandeln
    log.Fatal(err)
}

Fehler umschließen: Wenn Fehler in der Aufrufstapel übergeben werden, umwickeln Sie sie, um mit fmt.Errorf() und dem %w-Verb Kontext hinzuzufügen. Beispiel:

f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("öffnen fehlgeschlagen: %w", err)
}

defer für Aufräumen verwenden: Nutzen Sie defer, um sicherzustellen, dass Ressourcen ordnungsgemäß geschlossen oder aufgeräumt werden, auch wenn ein Fehler auftritt.
Benutzerdefinierte Fehlerarten erstellen: Implementieren Sie die error-Schnittstelle für benutzerdefinierte Fehlerarten, um detaillierte Fehlerinformationen bereitzustellen.
Das errors-Paket nutzen: Nutzen Sie Funktionen wie errors.New(), um einfache Fehlermeldungen zu erstellen, und errors.Is() oder errors.As() für Fehlerartenprüfung und -konvertierung.
panic nicht verwenden: Reservieren Sie panic für wirklich unüberwindbare Situationen. Normale Fehlerbehandlung sollte Rückgabewerte verwenden.
Explizite Fehlerinformationen bereitstellen: Machen Sie Fehlermeldungen klar und informativ, um bei der Debugging und Problembehandlung zu helfen.

Durch die Einhaltung dieser Praktiken können Sie robuste Go-Programme erstellen, die Fehler effektiv behandeln und Codeklarität gewährleisten.

Best Practices für Goroutines und Kanäle in Go

Effiziente Verwendung von Goroutines

Übermäßige Erstellung von Goroutines vermeiden: Erstellen Sie Goroutines mit Bedacht, berücksichtigen Sie die Art der Aufgabe und ob sie von paralleler Ausführung profitiert.
Proper Synchronisation: Nutzen Sie Synchronisationsmechanismen wie Kanäle oder Wait-Groups, um Goroutines effektiv zu verwalten und Ressourcenverschwendung zu vermeiden.
Art der Aufgabe prüfen: Beurteilen Sie, ob eine Aufgabe wirklich von paralleler Ausführung profitiert, bevor Sie Goroutines verwenden.

Effektive Kanalverwendung

Passender Kanaltyp wählen: Verwenden Sie ungebufferte Kanäle für Synchronisation und gebufferte Kanäle, wenn Sie das Senden und Empfangen von Operationen entkoppeln möchten.
Bufferkapazität: Wenn Sie gebufferte Kanäle verwenden, prüfen Sie sorgfältig die Puffergröße, um Leistung und Ressourennutzung auszugleichen.
Kanäle ordnungsgemäß schließen: Stellen Sie sicher, dass Kanäle geschlossen werden, wenn keine weiteren Daten mehr gesendet werden, um Deadlocks und Ressourcenlecks zu vermeiden.

Konkurrenzmuster

Worker-Pool-Muster: Implementieren Sie Worker-Pools mithilfe von Goroutines und Kanälen für effiziente Aufgabenverteilung und Ergebnisverarbeitung.
Producer-Consumer-Muster: Verwenden Sie Goroutines als Producer und Consumer, wobei Kanäle den Datenfluss zwischen ihnen ermöglichen.

Fehlerbehandlung und Ressourcenverwaltung

defer für Aufräumen verwenden: Nutzen Sie defer-Anweisungen, um eine ordnungsgemäße Ressourcenaufräumung sicherzustellen, auch bei Vorhandensein von Fehlern.
Panic behandeln: Implementieren Sie recover() in lang laufenden Goroutines, um zu verhindern, dass das gesamte Programm aufgrund eines Panics in einer einzelnen Goroutine abstürzt.

Kommunikation und Synchronisation

Kanäle statt geteiltem Speicher bevorzugen: Nutzen Sie Kanäle zur Kommunikation zwischen Goroutines, um Race Conditions zu vermeiden und Synchronisation zu vereinfachen.
select für mehrere Kanäle verwenden: Nutzen Sie die select-Anweisung, um mehrere Kanaloperationen gleichzeitig zu verarbeiten.

Leistungsaspekte

Konkurrenzbetrieb begrenzen: Nutzen Sie Semaphoren oder Worker-Pools, um die Anzahl der parallellen Operationen zu begrenzen und Ressourcenerschöpfung zu vermeiden.
Frühe Optimierung vermeiden: Profilieren Sie Ihren Code, um Engpässe zu identifizieren, bevor Sie Konkurrenzoptimierungen anwenden.

Testen und Debuggen

Race-Detektor verwenden: Führen Sie Ihre Tests regelmäßig mit dem -race-Flag durch, um Datenraces zu erkennen.
Konkurrenztests schreiben: Erstellen Sie Tests, die speziell Ihre konkurrierenden Codepfade üben, um Zuverlässigkeit zu gewährleisten.

Durch die Einhaltung dieser Best Practices können Sie effektiv Go’s Konkurrenzmodell nutzen, wodurch Ihre Programme effizienter, wartbarer und weniger anfällig für häufige konkurrierende Probleme werden.

Siehe andere Tech-Blog-Artikel.

Upgrade von golang unter Linux

Gehe zu und lade die neue Version herunter: https://go.dev/doc/install
Entferne die alte:

sudo rm -rf /usr/local/go

Installiere die neue:

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