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 syntaxis

Pakketverklaring

package main

Pakketten importeren

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

Hoofdfunctie

func main() {
    // Uw code hier
}

Variabelen en typen

Variabeleverklaring

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

Basis typen

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

Beheersstructuren

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 syntaxis, beheersstructuren, functies, datastructuren, methoden, interfaces, concurrency-primitieven en foutafhandeling. Onthoud dat Go eenvoud en leesbaarheid benadrukt, dus deze constructies 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 foutafhandeling in Go:

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

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("leeg naam")
    }
    message := fmt.Sprintf("Hi, %v. Welkom!", 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 aanroepstack, 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 mislukt: %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 retourwaarden gebruiken.
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 overmatig aanmaken van Goroutines: Start Goroutines met mate van overleg, overwegend met de aard van de taak en of het voordelen heeft van parallelle uitvoering.
Propere synchronisatie: Gebruik synchronisatiemiddelen zoals kanalen of waitgroups om Goroutines effectief te beheren en om hulpbronverbruik te voorkomen.
Overweeg de aard van de taak: Beoordeel of een taak echt voordelen heeft van concurrente uitvoering voordat u Goroutines gebruikt.

Effectief gebruik van Kanalen

Kies het juiste kanaaltype: Gebruik ongebufferde kanalen voor synchronisatie en gebufferde kanalen wanneer u sending en receiving operaties moet decoppelen.
Buffercapaciteit: Wanneer u gebufferde kanalen gebruikt, overweeg zorgvuldig de buffergrootte om prestaties en hulpbronverbruik te balanceren.
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 workerpools met Goroutines en kanalen voor efficiënte taakverdeling en resultaatverzameling.
Producer-consumer patroon: Gebruik Goroutines als producers en consumers, met kanalen die datastromen tussen hen faciliteren.

Foutafhandeling en hulpbronbeheer

Gebruik defer voor opschonen: Gebruik defer-instructies om correcte hulpbronopschoning te waarborgen, zelfs bij het optreden van fouten.
Fouten afhandelen: Implementeer recover() in lange lopende Goroutines om te voorkomen dat het hele programma crasht vanwege een panic in een enkele Goroutine.

Communicatie en synchronisatie

Voorkeur voor kanalen boven gedeelde geheugen: Gebruik kanalen voor communicatie tussen Goroutines om racevoorwaarden te vermijden en synchronisatie te vereenvoudigen.
Gebruik select voor meerdere kanalen: Gebruik de select-instructie om meerdere kanaaloperaties tegelijkertijd af te handelen.

Prestatiesoverwegingen

Beperk concurrente operaties: Gebruik semafores of workerpools om het aantal concurrente operaties te beperken en om hulpbronuitputting te voorkomen.
Vermijd vroege optimalisatie: Profiliseer uw code om bottlenecks te identificeren voordat u concurrentieoptimalisaties 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 concurrencymodel effectief benutten, waardoor uw programma’s efficiënter, onderhoudbaarder en minder gevoelig zijn voor veelvoorkomende concurrencyproblemen.

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