Golang snabbguide

Nyttiga golang-kommandon och konstruktioner

Sidinnehåll

Här är grundläggande Go programstruktur, felhanteringsmönster och jämförelse mellan kanaler och goroutines.

kaniner runt golang-skylt

Go-språkets snabbguide

Grundläggande syntax

Paketdeklaration

package main

Importera paket

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

Huvudfunktion

func main() {
    // Din kod här
}

Variabler och typer

Variabeldeklaration

var name string
var age int = 25
x := 10 // Kort deklaration

Grundläggande typer

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

Styrstrukturer

If-sats

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

For-loop

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

Range-loop

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

Switch-sats

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

Funktioner

Funktionsdeklaration

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

Flera returvärden

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

Datastrukturer

Arrayer

var numbers int
numbers := int{1, 2, 3, 4, 5}

Slices

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

Kartor

m := make(map[string]int)
m["key"] = value

Strukturer

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

Metoder

Metoddeklaration

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

Gränssnitt

Gränssnittsdeklaration

type Shape interface {
    Area() float64
}

Samtidighet

Goroutines

go functionName()

Kanaler

ch := make(chan int)
ch <- value  // Skicka
value := <-ch  // Ta emot

Felhantering

Felkontroll

if err != nil {
    // Hantera fel
}

Defer

defer file.Close()

Testning

Testfunktion

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

Den här snabbguiden täcker de mest grundläggande Go-språkskonstruktionerna och kommandona. Den inkluderar grundläggande syntax, styrstrukturer, funktioner, datastrukturer, metoder, gränssnitt, samtidighetsprimitiver och felhantering. Kom ihåg att Go betonar enkelhet och läsbarhet, så dessa konstruktioner bildar grunden för att skriva effektiv och klar Go-kod.

Felhantering i Go

Felhantering i Go är rak och explicit, med betoning på klarhet och robusthet. Här är de viktigaste teknikerna för att hantera fel i Go:

Returnera fel som värden: Funktioner som kan misslyckas bör returnera ett fel som sitt sista returvärde. Till exempel:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("tomt namn")
    }
    message := fmt.Sprintf("Hej, %v. Välkommen!", name)
    return message, nil
}

Kontrollera alltid för fel: Efter att ha anropat en funktion som returnerar ett fel, kontrollera omedelbart om felet inte är nil. Till exempel:

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

Använd felinvolvering: När fel propageras upp i anropsstacken, involvera dem för att lägga till kontext med fmt.Errorf() med %w-verb. Till exempel:

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

Använd defer för rensning: Använd defer för att säkerställa att resurser stängs eller rensas ordentligt, även om ett fel inträffar.
Skapa anpassade feltyper: Implementera error-gränssnittet för anpassade feltyper för att ge mer detaljerad felinformation.
Använd errors-paketet: Utnyttja funktioner som errors.New() för att skapa enkla felmeddelanden, och errors.Is() eller errors.As() för feltypskontroll och konvertering.
Undvik att använda panic: Reservera panic för verkligen oåterkalleliga situationer. Normal felhantering bör använda returvärden.
Ge explicit felinformation: Gör felmeddelanden klara och informativa för att underlätta felsökning och felsökningsarbete.

Genom att följa dessa praxis kan du skapa robusta Go-program som hanterar fel effektivt och bibehåller kodklarhet.

Bäst praxis för goroutines och kanaler i Go

Effektiv användning av goroutines

Undvik överdriven skapande av goroutines: Skapa goroutines med omsorg, med tanke på uppgiftens natur och om den verkligen gagnas av parallell exekvering.
Rätt synkronisering: Använd synkroniseringsmekanismer som kanaler eller väntgrupper för att effektivt hantera goroutines och förebygga resursslöseri.
Bedöm uppgiftens natur: Utvärdera om en uppgift verkligen gagnas av samtidig exekvering innan du använder goroutines.

Effektiv användning av kanaler

Välj lämplig kanaltyp: Använd obuffrade kanaler för synkronisering och buffrade kanaler när du behöver koppla ifrån skickande och mottagande operationer.
Bufferkapacitet: När du använder buffrade kanaler, överväg noggrant buffertstorleken för att balansera prestanda och resursanvändning.
Stäng kanaler ordentligt: Se till att kanaler stängs när inget mer data ska skickas för att förebygga dödläge och resursläckor.

Samtidighetmönster

Arbetspoolmönster: Implementera arbetspoolar med goroutines och kanaler för effektiv uppgiftsfördelning och resultatinsamling.
Producent-konsumentmönster: Använd goroutines som producenter och konsumenter, med kanaler som underlättar dataflödet mellan dem.

Felhantering och resurshantering

Använd defer för rensning: Använd defer-satser för att säkerställa ordentlig resursrensning, även vid fel.
Hantera panik: Implementera recover() i långlivade goroutines för att förebygga att hela programmet kraschar på grund av en panik i en enda goroutine.

Kommunikation och synkronisering

Föredra kanaler framför delad minne: Använd kanaler för kommunikation mellan goroutines för att undvika race conditioner och förenkla synkronisering.
Använd select för flera kanaler: Använd select-satsen för att hantera flera kanaloperationer samtidigt.

Prestandaöverväganden

Begränsa samtidiga operationer: Använd semaforer eller arbetspoolar för att begränsa antalet samtidiga operationer och förebygga resursutarmning.
Undvik förtidig optimering: Profilera din kod för att identifiera flaskhalsar innan du tillämpar samtidighetsoptimeringar.

Testning och felsökning

Använd race detector: Kör dina tester regelbundet med -race-flaggan för att upptäcka race conditioner.
Skriv samtidiga tester: Skapa tester som specifikt testar dina samtidiga kodvägar för att säkerställa pålitlighet.

Genom att följa dessa bästa praxis kan du effektivt utnyttja Gos samtidighetsmodell, vilket gör dina program mer effektiva, underhållbara och mindre benägna att drabbas av vanliga samtidighetsrelaterade problem.

Se andra tekniska blogginlägg.

Uppgradering av golang på linux

gå till och ladda ner ny version: https://go.dev/doc/install
ta bort gammal version:

sudo rm -rf /usr/local/go

installera ny version:

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