Golang-Cheat-Sheet
Nützliche Go-Befehle und Konstruktionen
Hier ist die grundlegende Go-Programmstruktur, Muster für Fehlerbehandlung und ein Vergleich von Kanälen vs. Goroutines.
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:
- 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
}
- 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)
}
- 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)
}
-
Nutzen Sie
defer
für die Bereinigung: Verwenden Siedefer
, um sicherzustellen, dass Ressourcen ordnungsgemäß geschlossen oder bereinigt werden, auch wenn ein Fehler auftritt. -
Erstellen Sie benutzerdefinierte Fehlertypen: Implementieren Sie die
error
-Schnittstelle für benutzerdefinierte Fehlertypen, um detailliertere Fehlerinformationen bereitzustellen. -
Verwenden Sie das
errors
-Paket: Nutzen Sie Funktionen wieerrors.New()
, um einfache Fehlermeldungen zu erstellen, underrors.Is()
odererrors.As()
für die Fehlerprüfung und -umwandlung. -
Vermeiden Sie die Verwendung von
panic
: Reservieren Siepanic
für wirklich nicht wiederherstellbare Situationen. Die normale Fehlerbehandlung sollte Rückgabewerte verwenden. -
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
-
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.
-
Ordentliche Synchronisation: Verwenden Sie Synchronisationsmechanismen wie Kanäle oder Warteschlangen, um Goroutines effektiv zu verwalten und Ressourcenverschwendung zu verhindern.
-
Bewerten Sie die Aufgabenart: Prüfen Sie, ob eine Aufgabe wirklich von der parallelen Ausführung profitiert, bevor Sie Goroutines verwenden.
Effektive Kanalnutzung
-
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.
-
Pufferkapazität: Wenn Sie gepufferte Kanäle verwenden, legen Sie die Puffergröße sorgfältig fest, um Leistung und Ressourcennutzung auszugleichen.
-
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
-
Arbeiterpool-Muster: Implementieren Sie Arbeiterpools mit Goroutines und Kanälen für eine effiziente Aufgabenverteilung und Ergebnisammlung.
-
Producer-Consumer-Muster: Verwenden Sie Goroutines als Producer und Consumer, wobei Kanäle den Datenfluss zwischen ihnen erleichtern.
Fehlerbehandlung und Ressourcenmanagement
-
Verwenden Sie
defer
für die Bereinigung: Setzen Siedefer
-Anweisungen ein, um eine ordnungsgemäße Ressourcenbereinigung sicherzustellen, auch bei Fehlern. -
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
-
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.
-
Verwenden Sie
select
für mehrere Kanäle: Setzen Sie dieselect
-Anweisung ein, um mehrere Kanaloperationen gleichzeitig zu behandeln.
Leistungsüberlegungen
-
Begrenzen Sie parallele Operationen: Verwenden Sie Semaphore oder Arbeiterpools, um die Anzahl der parallelen Operationen zu begrenzen und Ressourcenerschöpfung zu verhindern.
-
Vermeiden Sie vorzeitige Optimierung: Profilieren Sie Ihren Code, um Engpässe zu identifizieren, bevor Sie Parallelitätsoptimierungen vornehmen.
Testen und Debuggen
-
Verwenden Sie den Race-Detector: Führen Sie Ihre Tests regelmäßig mit der
-race
-Option aus, um Datenrennen zu erkennen. -
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
- Gehen Sie zur Seite und laden Sie die neue Version herunter: https://go.dev/doc/install
- Entfernen Sie die alte Version:
sudo rm -rf /usr/local/go
- Installieren Sie die neue Version:
cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz
Nützliche Links
- https://go.dev/
- Generieren von PDFs in GO - Bibliotheken und Beispiele
- AWS Lambda-Leistung: JavaScript vs. Python vs. Golang
- Behebung des Golang GORM AutoMigrate postgresql-Fehlers
- Linux neu installieren
- Bash-Cheat-Sheet
- Markdown-Cheat-Sheet
- JWT-Token decodieren und ausgeben
- Beliebtheit von Programmiersprachen und Frameworks
- Golang Space
- Alternativen zu Beautiful Soup für Go