Golang-Cheat-Sheet

Nützliche Go-Befehle und Konstruktionen

Inhaltsverzeichnis

Hier ist die grundlegende Go-Programmstruktur, Muster für Fehlerbehandlung und ein Vergleich von Kanälen vs. Goroutines.

Kaninchen um das Golang-Schild

Go-Sprach-Cheat-Sheet

Grundlegende Syntax

Paketdeklaration

package main

Import-Pakete

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

Hauptfunktion

func main() {
    // Ihr 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

Funktionsdeklaration

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

Mehrere 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

Strukturen

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

Methoden

Methodendeklaration

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

Schnittstellen

Schnittstellendeklaration

type Shape interface {
    Area() float64
}

Parallelität

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
}

Dieser Cheat-Sheet deckt die wichtigsten Go-Sprachkonstrukte und Befehle ab. Er enthält grundlegende Syntax, Steuerstrukturen, Funktionen, Datenstrukturen, Methoden, Schnittstellen, Parallelitätsprimitive und Fehlerbehandlung. Denken Sie daran, dass Go Einfachheit und Lesbarkeit betont, sodass diese Konstrukte die Grundlage für das Schreiben effizienten und klaren Go-Codes bilden.

Fehlerbehandlung in Go

Die Fehlerbehandlung in Go ist einfach und explizit und betont Klarheit und Robustheit. Hier sind die wichtigsten Techniken zur Fehlerbehandlung in Go:

  1. Fehler als Werte zurückgeben: Funktionen, die fehlschlagen können, sollten einen Fehler als letzten Rückgabewert zurückgeben. Zum Beispiel:
func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("leerer Name")
    }
    message := fmt.Sprintf("Hallo, %v. Willkommen!", name)
    return message, nil
}
  1. Immer auf Fehler prüfen: Nach dem Aufruf einer Funktion, die einen Fehler zurückgibt, prüfen Sie sofort, ob der Fehler nicht nil ist. Zum Beispiel:
result, err := SomeFunction()
if err != nil {
    // Fehler behandeln
    log.Fatal(err)
}
  1. Fehler einbetten: Wenn Fehler durch den Aufrufstapel propagiert werden, betten Sie sie ein, um Kontext hinzuzufügen, indem Sie fmt.Errorf() mit dem %w-Verb verwenden. Zum Beispiel:
f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("Öffnen fehlgeschlagen: %w", err)
}
  1. Nutzen Sie defer für die Bereinigung: Verwenden Sie defer, um sicherzustellen, dass Ressourcen ordnungsgemäß geschlossen oder bereinigt werden, auch wenn ein Fehler auftritt.

  2. Erstellen Sie benutzerdefinierte Fehlertypen: Implementieren Sie die error-Schnittstelle für benutzerdefinierte Fehlertypen, um detailliertere Fehlerinformationen bereitzustellen.

  3. Verwenden Sie das errors-Paket: Nutzen Sie Funktionen wie errors.New(), um einfache Fehlermeldungen zu erstellen, und errors.Is() oder errors.As() für die Fehlerprüfung und -umwandlung.

  4. Vermeiden Sie die Verwendung von panic: Reservieren Sie panic für wirklich nicht wiederherstellbare Situationen. Die normale Fehlerbehandlung sollte Rückgabewerte verwenden.

  5. Bieten Sie explizite Fehlerinformationen an: Machen Sie Fehlermeldungen klar und informativ, um das Debugging und die Fehlerbehebung zu erleichtern.

Durch die Einhaltung dieser Praktiken können Sie robuste Go-Programme erstellen, die Fehler effektiv behandeln und die Code-Klarheit erhalten.

Beste Praktiken für Goroutines und Kanäle in Go

Effiziente Nutzung von Goroutines

  1. Vermeiden Sie übermäßige Erstellung von Goroutines: Erstellen Sie Goroutines mit Bedacht, wobei die Art der Aufgabe und ob sie von paralleler Ausführung profitiert, berücksichtigt wird.

  2. Ordentliche Synchronisation: Verwenden Sie Synchronisationsmechanismen wie Kanäle oder Warteschlangen, um Goroutines effektiv zu verwalten und Ressourcenverschwendung zu verhindern.

  3. Bewerten Sie die Aufgabenart: Prüfen Sie, ob eine Aufgabe wirklich von der parallelen Ausführung profitiert, bevor Sie Goroutines verwenden.

Effektive Kanalnutzung

  1. Wählen Sie den geeigneten Kanaltyp: Verwenden Sie ungepufferte Kanäle zur Synchronisation und gepufferte Kanäle, wenn Sie Sende- und Empfangsoperationen entkoppeln müssen.

  2. Pufferkapazität: Wenn Sie gepufferte Kanäle verwenden, legen Sie die Puffergröße sorgfältig fest, um Leistung und Ressourcennutzung auszugleichen.

  3. Kanäle ordnungsgemäß schließen: Stellen Sie sicher, dass Kanäle geschlossen werden, wenn keine Daten mehr gesendet werden, um Totschleifen und Ressourcenlecks zu verhindern.

Parallelitätsmuster

  1. Arbeiterpool-Muster: Implementieren Sie Arbeiterpools mit Goroutines und Kanälen für eine effiziente Aufgabenverteilung und Ergebnisammlung.

  2. Producer-Consumer-Muster: Verwenden Sie Goroutines als Producer und Consumer, wobei Kanäle den Datenfluss zwischen ihnen erleichtern.

Fehlerbehandlung und Ressourcenmanagement

  1. Verwenden Sie defer für die Bereinigung: Setzen Sie defer-Anweisungen ein, um eine ordnungsgemäße Ressourcenbereinigung sicherzustellen, auch bei Fehlern.

  2. Behandeln Sie Panics: Implementieren Sie recover() in langlaufenden Goroutines, um zu verhindern, dass das gesamte Programm aufgrund eines Panics in einer einzelnen Goroutine abstürzt.

Kommunikation und Synchronisation

  1. Bevorzugen Sie Kanäle gegenüber gemeinsamem Speicher: Verwenden Sie Kanäle zur Kommunikation zwischen Goroutines, um Wettlaufbedingungen zu vermeiden und die Synchronisation zu vereinfachen.

  2. Verwenden Sie select für mehrere Kanäle: Setzen Sie die select-Anweisung ein, um mehrere Kanaloperationen gleichzeitig zu behandeln.

Leistungsüberlegungen

  1. Begrenzen Sie parallele Operationen: Verwenden Sie Semaphore oder Arbeiterpools, um die Anzahl der parallelen Operationen zu begrenzen und Ressourcenerschöpfung zu verhindern.

  2. Vermeiden Sie vorzeitige Optimierung: Profilieren Sie Ihren Code, um Engpässe zu identifizieren, bevor Sie Parallelitätsoptimierungen vornehmen.

Testen und Debuggen

  1. Verwenden Sie den Race-Detector: Führen Sie Ihre Tests regelmäßig mit der -race-Option aus, um Datenrennen zu erkennen.

  2. Schreiben Sie parallele Tests: Erstellen Sie Tests, die speziell Ihre parallelen Codepfade testen, um die Zuverlässigkeit sicherzustellen.

Durch die Einhaltung dieser Best Practices können Sie das Parallelitätsmodell von Go effektiv nutzen und Ihre Programme effizienter, wartbarer und weniger anfällig für häufige parallelitätsbedingte Probleme machen.

Sehen Sie sich andere Technische Blog-Artikel an.

Upgraden von golang auf Linux

  1. Gehen Sie zur Seite und laden Sie die neue Version herunter: https://go.dev/doc/install
  2. Entfernen Sie die alte Version:
sudo rm -rf /usr/local/go
  1. Installieren Sie die neue Version:
cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz