Golang cheat sheet

Handige golang-opdrachten en constructies

Inhoud

Hier is de basis Go programma structuur, foutafhandelingspatronen en vergelijking tussen kanalen en goroutines.

bunnies around golang sign

Go Taal Cheat Sheet

Basis Syntax

Pakketverklaring

package main

Pakketten importeren

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

Hoofdfunctie

func main() {
    // Uw code hier
}

Variabelen en Types

Variabeleverklaring

var name string
var age int = 25
x := 10 // Korte verklaring

Basis Types

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

Controlestructuren

If-statement

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

For-lus

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

Range-lus

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

Switch-statement

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

Functies

Functieverklaring

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

Meerdere retourwaarden

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

Datastructuren

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

Methodeverklaring

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

Interfaces

Interfaceverklaring

type Shape interface {
    Area() float64
}

Concurrency

Goroutines

go functionName()

Kanalen

ch := make(chan int)
ch <- value  // Sturen
value := <-ch  // Ontvangen

Foutafhandeling

Foutcontrole

if err != nil {
    // Fout afhandelen
}

Defer

defer file.Close()

Testen

Testfunctie

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

Deze cheat sheet dekt de meest essentiële Go taalconstructen en opdrachten. Het bevat basis syntax, controlestructuren, functies, datastructuren, methoden, interfaces, concurrency primitives en foutafhandeling. Onthoud dat Go eenvoud en leesbaarheid benadrukt, dus deze constructen vormen de basis voor het schrijven van efficiënte en duidelijke Go code.

Foutafhandeling in Go

Foutafhandeling in Go is eenvoudig en expliciet, met nadruk op duidelijkheid en robuustheid. Hier zijn de belangrijkste technieken voor het afhandelen van fouten in Go:

Fouten retourneren als waarden: Functies die kunnen falen moeten een fout retourneren als laatste retourwaarde. Bijvoorbeeld:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("empty name")
    }
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}

Controleer altijd op fouten: Na het aanroepen van een functie die een fout retourneert, controleer direct of de fout niet nil is. Bijvoorbeeld:

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

Gebruik foutomslag: Bij het doorgeven van fouten in de call stack, omsluit ze om context toe te voegen met fmt.Errorf() en het %w-woord. Bijvoorbeeld:

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

Gebruik defer voor opschonen: Gebruik defer om te zorgen dat resources correct worden gesloten of opgeschoond, zelfs als een fout optreedt.
Maak aangepaste fouttypen: Implementeer het error-interface voor aangepaste fouttypen om gedetailleerde foutinformatie te bieden.
Gebruik het errors-pakket: Maak gebruik van functies zoals errors.New() om eenvoudige foutberichten te maken, en errors.Is() of errors.As() voor fouttypecontrole en conversie.
Vermijd het gebruik van panic: Reserveer panic voor echt onherstelbare situaties. Normale foutafhandeling moet gebruikmaken van retourwaarden.
Geef expliciete foutinformatie: Zorg dat foutberichten duidelijk en informatief zijn om te helpen bij het debuggen en oplossen van problemen.

Door deze praktijken te volgen, kunt u robuuste Go programma’s maken die fouten effectief afhandelen en code duidelijk houden.

Beste praktijken voor Goroutines en Kanalen in Go

Efficiënt gebruik van Goroutines

Vermijd het aanmaken van te veel goroutines: Start goroutines met mate, overwegen de aard van de taak en of het voordelen heeft van parallelle uitvoering.
Propere synchronisatie: Gebruik synchronisatiemechanismen zoals kanalen of wait groups om goroutines effectief te beheren en om hulpbronverbruik te voorkomen.
Overweeg de aard van de taak: Evalueer of een taak echt voordelen heeft van concurrente uitvoering voordat u goroutines gebruikt.

Effectief gebruik van kanalen

Kies de juiste kanalentype: Gebruik ongebufferde kanalen voor synchronisatie en gebufferde kanalen wanneer u sending en receiving operaties moet ontkoppelen.
Buffercapaciteit: Wanneer u gebufferde kanalen gebruikt, overweeg zorgvuldig de buffergrootte om prestaties en hulpbronverbruik in evenwicht te brengen.
Sluit kanalen correct: Zorg dat kanalen worden gesloten wanneer er geen meer data naar wordt gestuurd om deadlocks en hulpbronlekkage te voorkomen.

Concurrency patronen

Worker pool patroon: Implementeer worker pools met behulp van goroutines en kanalen voor efficiënte taakverdeling en resultaatverzameling.
Producer-consumer patroon: Gebruik goroutines als producers en consumers, met kanalen die de datastroom tussen hen faciliteren.

Foutafhandeling en hulpbronbeheer

Gebruik defer voor opschonen: Gebruik defer-staten om correcte hulpbronopschoning te waarborgen, zelfs bij het optreden van fouten.
Afhandeling van panics: Implementeer recover() in lange lopende goroutines om te voorkomen dat het hele programma crasht vanwege een panic in één goroutine.

Communicatie en synchronisatie

Voorkeur voor kanalen boven gedeelde geheugen: Gebruik kanalen voor communicatie tussen goroutines om race conditions te vermijden en synchronisatie te vereenvoudigen.
Gebruik select voor meerdere kanalen: Gebruik de select-statement om meerdere kanalenocties gelijktijdig af te handelen.

Prestatieoverwegingen

Beperk concurrente operaties: Gebruik semafores of worker pools om het aantal concurrente operaties te beperken en om hulpbronuitputting te voorkomen.
Vermijd vroege optimalisatie: Profiliseer uw code om bottlenecks te identificeren voordat u concurrency optimalisaties toepast.

Testen en debuggen

Gebruik race detector: Voer regelmatig uw tests uit met de -race vlag om data races te detecteren.
Schrijf concurrente tests: Maak tests die specifiek uw concurrente codepaden testen om betrouwbaarheid te waarborgen.

Door deze beste praktijken te volgen, kunt u Go’s concurrency model effectief gebruiken, waardoor uw programma’s efficiënter, onderhoudelijker en minder gevoelig zijn voor veelvoorkomende concurrency-gerelateerde problemen.

Zie andere tech blog artikelen.

Upgraden van golang op linux

ga naar en download de nieuwe versie: https://go.dev/doc/install
verwijder de oude:

sudo rm -rf /usr/local/go

installeer de nieuwe:

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