Blind typen oefening: Programmeren in Go taal

Programmeren in Go en blind typen horen bij elkaar. Go heeft strikte syntaxisregels en speciale tekens die lastig kunnen zijn om snel te typen. Een fout in een accolade of operator leidt direct tot een compileerfout.

Wat is kenmerkend aan de Go-syntaxis?

Go is een gecompileerde taal (Engels: compiled language) met een duidelijke en minimalistische stijl. De code begint altijd met een package-verklaring. Imports worden in blokken gegroepeerd. Functies worden gedefinieerd met het sleutelwoord func en begrensd door accolades {}. Indentatie is verplicht - Go dwingt de formattering af met go fmt. Puntkomma's schrijf je niet, de compiler voegt ze automatisch in aan het einde van regels.

package main

import "fmt"

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

Belangrijke tekens

Veelgebruikte tekens in Go zijn: accolades {}, ronde haken (), vierkante haken [], aanhalingstekens ", backticks `, de korte toekenningsoperator := en de kanaalpijl <-.

Variabelen en declaraties

Go maakt onderscheid tussen var en de korte toekenning :=. Die laatste combineert twee symbolen en komt overal terug.

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

Controle structuren

Go kent if, for en switch, maar geen while. Vergelijkingsoperatoren zoals ==, !=, <, > en de ++-operator moeten nauwkeurig worden ingevoerd.

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

Functies en meerdere returnwaarden

Functies kunnen meerdere waarden teruggeven. Dat betekent vaker komma's bij returnlijsten en toewijzingen.

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)

Slices, maps en literalen

Vierkante haken [] en accolades {} zie je overal. In maps gebruik je een dubbele punt : tussen sleutel en waarde.

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

Structs en methoden

Het type struct groepeert gegevens. Methoden hebben een receiver en worden aangeroepen met een punt ..

type User struct {
 Name string
}

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

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

Interfaces

Interfaces in Go worden impliciet voldaan - er is geen sleutelwoord zoals implements.

type Stringer interface {
 String() string
}

Concurrency en kanalen

De kanaalpijl <- is typisch voor Go. Je gebruikt die voor zowel verzenden (ch <- value) als ontvangen (value := <-ch).

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

Strings en runes

Dubbele aanhalingstekens zijn voor gewone strings, backticks voor raw strings en enkele aanhalingstekens voor runes.

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

Indentatie en formattering

Go legt een uniforme stijl op. De plaatsing van accolades en regeleinden is belangrijk. Een veelgemaakte fout is een Enter na return.

Samenvatting

De belangrijkste tekens in Go zijn accolades {}, ronde haken (), vierkante haken [], de operator := en de kanaalpijl <-. Door die correct te typen kun je efficiënt en foutloos programmeren.