Tifingersystem lektion: Programmering på Go sprog

Programmering i Go og blindskrift hænger naturligt sammen. Go har et sæt faste syntaksregler og specialtegn, der kan være udfordrende, når man skriver hurtigt. Blindskrift betyder at skrive uden at kigge på tastaturet, og i konteksten af Go er det vigtigt, fordi sproget kræver nøjagtighed: en manglende krølleparentes eller en fejl i en operator giver straks en kompileringsfejl.

Hvad er karakteristisk ved Go's syntaks?

Go er et kompileret sprog eng.: compiled language med en ren og minimalistisk stil. Kildekoden starter altid med en package-deklaration. Importer grupperes i blokke. Funktioner erklæres med nøgleordet func og bruger krølleparenteser {} til at afgrænse blokke. Indrykning er ikke valgfri - Go håndhæver formatering via go fmt. Sproget bruger normalt ikke semikolon, men compileren indsætter dem automatisk i slutningen af linjer. Derfor er Enter det rette sted ikke kun en vane, men et krav i Go.

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go")
}

Tegn man skal være opmærksom på

Når du skriver Go-kode, møder du bestemte tegn igen og igen. Krølleparenteser {} bruges efter hver funktion eller kontrolstruktur. Runde parenteser () bruges til funktionens parametre og kald. Firkantede parenteser [] definerer arrays og slices eng.: arrays, slices. Anførselstegn " og backticks ` bruges til strenge. Den korte deklarationsoperator := bruges konstant til at oprette variabler. Kanaler eng.: channels bruger operatoren <-, som er usædvanlig og kræver ekstra træning.

Variabler og deklarationer

I Go skelnes der mellem at erklære en variabel med var og at bruge den korte tilordning :=. Denne operator kombinerer kolon og lighedstegn, hvilket kan føles akavet i starten. Det er en god idé at øve sig, da det er en konstruktion, du skriver igen og igen.

var count int = 10
message := "typed correctly"

Kontrolstrukturer

Go bruger if, for og switch. Der findes ingen while. Syntaksen er kort, men du skal skrive sammenligningsoperatorer ==, !=, <, > og ++ meget præcist. Selv en lille fejl som = i stedet for == ødelægger koden.

for i := 0; i < 5; i++ {
 if i%2 == 0 {
 fmt.Println("even")
 }
}

Funktioner og flere returværdier

Funktioner kan returnere mere end én værdi. Det betyder, at du ofte skriver kommaer i returværdilister og tilordninger. Det er nyttigt at øve, indtil result, err := føles naturligt.

func divide(a, b int) (int, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a/b, nil
}

result, err := divide(10, 2)

Slice, maps og composite literals

Firkantede parenteser [] og krølleparenteser {} bruges konstant i slices og maps. Maps bruger også kolon : til at adskille nøgle og værdi. Disse linjer kan være besværlige at skrive hurtigt uden fejl.

nums := []int{1, 2, 3}
scores := map[string]int{"alice": 5, "bob": 7}

Structs og metoder

Typen struct grupperer data. Når du tilføjer metoder, skriver du parenteser til receivers eng.: receivers og bruger punktum . for at få adgang til felter eller metoder.

type User struct {
 Name string
}

func (u User) Greet() string {
 return "Hello " + u.Name
}

u := User{Name: "A"}
fmt.Println(u.Greet())

Interfaces

Interfaces i Go opfyldes implicit uden nøgleord som implements. Når du definerer dem, bruger du igen krølleparenteser og metodens signaturer.

type Stringer interface {
 String() string
}

Samtidighed og kanaler

Et af de mest karakteristiske træk i Go er kanal-operatoren <-. Den findes ikke i de fleste andre sprog og føles uvant i starten. Du bruger den til at sende ch <- value og til at modtage value := <-ch. Det er en god idé at træne dette symbol.

ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch

Strings og runes

Go bruger dobbelte anførselstegn til normale strenge, backticks til rå strenge eng.: raw strings og enkelte anførselstegn til runes. Det er let at forveksle dem, men compileren er streng. Vær særligt opmærksom, når du skifter mellem ", ` og '.

text := "normal string"
raw := `path\to\file`
r := 'a'

Indrykning og formatering

Go håndhæver en ensartet kodestil. Det er nyttigt, men betyder også, at du skal respektere, hvor linjeskift og krølleparenteser placeres. En typisk fejl er at trykke Enter efter return. Go giver straks en fejl. Når du vænner dig til reglerne, bliver skrive-rytmen naturlig.

Opsummering

Programmering i Go kræver præcision. De vigtigste tegn er krølleparenteser {}, parenteser (), firkantede parenteser [], den korte tilordning := og kanal-operatoren <-. Disse symboler er overalt i Go-kode. Når du træner dem, indtil de føles naturlige, kan du skrive Go hurtigt og uden fejl.