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 kan leiden 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 kun je afzonderlijk declareren of in een blok groeperen. Functies worden gedefinieerd met het sleutelwoord func en begrensd door accolades {}. Inspringing bepaalt in Go niet waar blokken beginnen en eindigen; go fmt past een standaardopmaak toe. Puntkomma's worden meestal weggelaten in de broncode en de compiler voegt ze volgens bepaalde regels toe bij regeleinden.

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 declaratieoperator := en de kanaalpijl <-.

Variabelen en declaraties

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

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

Besturingsstructuren

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

Types voldoen in Go impliciet aan interfaces - 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

gofmt geeft de code een uniforme opmaak. De plaatsing van accolades en regeleinden is belangrijk. Een veelgemaakte fout is op Enter drukken tussen return en de teruggegeven waarde.

Samenvatting

De belangrijkste tekens in Go zijn accolades {}, ronde haken (), vierkante haken [], de operator := en de kanaalpijl <-. Oefen het typen van deze tekens om meer routine te krijgen in het snel en nauwkeurig invoeren van Go-code.