Golang-Kurzreferenz

Verwendung von Collections

Verwendung von Slices

// Eigenschaften: veränderlich, Übergabe per Referenz, Heap-Allokation
a := []int{1,2,3,4,5} // Kurzschreibweise und Initialisierung
// Index als Platzhalter angeben ist ebenfalls möglich
a := []int{0:1,4:3}
// Hinzufügen
a = append(a, 6)
// Löschen
// Index des zu löschenden Elements
index := 2
// Element löschen
slice = append(slice[:index], slice[index+1:]...)  // Das ist auch Array-Zusammenführung
// Ändern und Lesen wie bei Arrays

Länge und Kapazität von Slices

// Length (Länge) ist die Anzahl der aktuell enthaltenen Elemente im Slice.
// Capacity (Kapazität) ist die Größe des zugrunde liegenden Arrays, also die Obergrenze der aufnehmbaren Elemente.
a := make([]byte, 5, 10) // Slice a kann bis zu 10 byte-Elemente aufnehmen, hat aber derzeit nur 5.
// Kapazität kann weggelassen werden
a := make([]byte, 5)
 
// Syntaxerklärung a[b:c] => 
// b ist der aktuelle Index, leer bedeutet Index 0
// c ist der aktuelle Index, leer bedeutet Index len(a)
s := x[:] // Slice s zeigt auf den Speicher von Array x; Änderungen an s betreffen auch x

Slices iterieren

for k,v := range a {} 
for _,v := range a {} // Index nicht nötig
for k := range a {} // nur Index nötig
for range time.Tick(time.Second) {} // keines von beiden

Verwendung von Arrays

// Eigenschaften: feste Größe, Übergabe per Wert, Stack-Allokation
a := [5]int{1,2,3,4,5}
// Hinzufügen oder Löschen nicht möglich
// Ändern
a[3] = 6
// Lesen
a[3]

Verwendung von switch

switch a {
case "a":
	// todo
case "b", "c":  // trifft b oder c
	// todo
default:
	// todo
}
 
// Man kann auch eine Anweisung voranstellen
switch a:=1; a { ... }

Verwendung von for-Schleifen

for {}  // entspricht while true
for a < 19 {} // entspricht while a < 19
for a := 10; a<99; a++ {} // normale Nutzung
 
// Unterstützt auch break und continue mit äußeren Labels
here:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if i == 0 {
                continue here
            }
            fmt.Println(j)
            if j == 2 {
                break
            }
        }
    }
 
there:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if j == 1 {
                continue
            }
            fmt.Println(j)
            if j == 2 {
                break there
            }
        }
    }

Verwendung der if-Struktur

if a > 0 {}
 
// Zusätzliche Anweisung möglich, mit Semikolon abschließen
if a := b+c; a > 0 {}

Zu Package und Standardbeschränkungen

Setzen Sie die package-Deklaration ganz an den Anfang jeder Go-Quelldatei (ohne Kommentare). Ausführbare Dateien liegen im Package main. Konvention: Package-Name == letzter Name des Importpfads (Importpfad math/rand => Package-Name rand). Mit Großbuchstaben beginnende Bezeichner: exportierte Bezeichner, für andere Packages sichtbar. Mit Kleinbuchstaben beginnende Bezeichner: private Bezeichner, für andere Packages unsichtbar.

Funktionen deklarieren

func a() {}
func a(b int){}
func a(b, c int){} // mehrere desselben Typs
func a() string {}
// Rückgabewert
func a() (int,string){
  return 1, "1"
}
// Rückgabebezeichner, einfach return
func a() (b int, c string){
	b = 1
	c = "1"
	return
}

Funktionsübergabe und Closures

// Als Parameter verwendet
add := func(a,b)int{
	return a+b
}
 
// Als Rückgabewert verwendet
func wrapAdd() (add func() int) {
	c := 1
	add = func() int { return c }
	return
}

Variadische Funktionen

func a(args ...int) int {
	return 1
}

Variablen deklarieren

var a int = 1
a := 1
const a = "1"

iota-Tricks

• Automatisch inkrementierte Enum-Werte

  const (
  	Red   = iota // 0
  	Green        // 1
  	Blue         // 2
  )

• Bitoperationen für Flag-Konstanten

  const (
  	FlagNone = 0      // 0
  	FlagA    = 1 << iota // 1
  	FlagB    = 1 << iota // 2
  	FlagC    = 1 << iota // 4
  )

• Unnötige Werte überspringen

  const (
  	_  = iota             // ersten Enum-Wert überspringen
  	January = 1 + iota    // 1
  	February              // 2
  	March                 // 3
  )

Wege, andere Dateien zu importieren

1. Relativer Pfadimport: andere Dateien über relative Pfade importieren. Geeignet, um Dateien im selben Projekt zu referenzieren. Zum Beispiel importiert import "./utils" die Datei utils im aktuellen Projekt.
2. Absoluter Pfadimport: andere Dateien über absolute Pfade importieren. Geeignet für Dateien in anderen Projekten oder Bibliotheken. Zum Beispiel importiert import "github.com/example/package" Dateien aus dem Package github.com/example/package.
3. Standardbibliothek importieren: Go stellt viele Standardbibliotheken bereit, die direkt genutzt werden können. Zum Beispiel importiert import "fmt" das Package fmt aus der Standardbibliothek.
4. Alias-Import: Sie können Aliasse für importierte Packages oder Dateien setzen, um kürzere Namen zu verwenden. Zum Beispiel setzt import utils "github.com/example/package" den Alias utils für github.com/example/package; anschließend greifen Sie über utils auf den Inhalt zu.
5. Import mit Blank Identifier: manchmal soll nur die init-Funktion einer Datei ausgeführt werden, ohne den restlichen Inhalt zu nutzen. Dann importieren Sie mit dem Blank Identifier _. Zum Beispiel führt import _ "github.com/example/package" die init-Funktion des Packages github.com/example/package aus, ohne den übrigen Inhalt im Code zu verwenden.
6. Import mit dem Punktoperator kann Code knapper machen, aber auch die Lesbarkeit verringern.

Häufige CLI-Befehle

• go build: kompiliert Go-Code und erzeugt ausführbare Dateien. Zum Beispiel kompiliert go build main.go die Datei main.go und erzeugt eine ausführbare Datei.
• go run: kompiliert und führt Go-Code aus. Zum Beispiel kompiliert go run main.go main.go und führt sie direkt aus.
• go test: führt Go-Unit-Tests aus. Mit go test können Testdateien im Projekt automatisch ausgeführt und Ergebnisse ausgegeben werden.
• go get: holt und installiert Drittanbieter-Abhängigkeiten. Zum Beispiel holt und installiert go get github.com/example/package die Abhängigkeit github.com/example/package.
• go mod init: initialisiert die Modulverwaltung des Go-Projekts. Mit go mod init erstellen Sie eine neue go.mod zur Verwaltung der Abhängigkeiten.
• go mod tidy: räumt ungenutzte Abhängigkeiten automatisch auf. go mod tidy prüft Projektabhängigkeiten und entfernt nicht mehr benötigte.
• go mod vendor: kopiert Projektabhängigkeiten ins Verzeichnis vendor. Mit go mod vendor kopieren Sie alle Abhängigkeiten ins Projekt für Offline-Build und Deployment.
• go doc: zeigt Go-Codedokumentation. Zum Beispiel zeigt go doc fmt.Println die Dokumentation der Funktion Println im Package fmt.