Variabelen en types in Go: compleet overzicht

Variabelen en types in Go vormen de fundering van elk programma dat je gaat schrijven. Of je nu een simpele CLI-tool bouwt of een schaalbare backend-service, je hebt dagelijks te maken met het declareren van variabelen, het kiezen van het juiste type en het begrijpen van hoe Go met geheugen omgaat.

In deze gids duiken we in alles wat je moet weten: van de basis var en := tot constanten, slices, maps en structs. Na het lezen ken je de verschillen tussen de types, weet je wanneer je welke syntax gebruikt en voorkom je de meest gemaakte fouten door beginners.

Heb je Go nog niet geïnstalleerd? Volg dan eerst onze installatiegids voor je eerste Go programma voordat je verder leest.

Waarom types belangrijk zijn in Go

Go is een statisch getypeerde taal. Dat betekent dat de compiler bij het bouwen van je programma controleert of alle types kloppen. Pas je per ongeluk een string toe op een plek waar een int verwacht wordt, dan krijg je een compileerfout in plaats van een crash op productie.

Die strengheid is een van de redenen waarom Go zo populair is voor backends. Het vangt een hele categorie bugs af voordat je code überhaupt draait.

Tegelijk blijft Go prettig om mee te werken, omdat de compiler types vaak zelf kan afleiden. Je hoeft dus niet elke keer expliciet op te schrijven wat het type is.

Variabelen declareren met var

De meest expliciete manier om een variabele te maken is met het sleutelwoord var:

var naam string = "Sander"
var leeftijd int = 35
var actief bool = true

Je kunt het type weglaten als je een beginwaarde meegeeft. Go leidt het type dan zelf af:

var naam = "Sander"       // string
var leeftijd = 35        // int
var actief = true        // bool

En je kunt een variabele declareren zonder waarde. In dat geval krijgt hij de zogeheten zero value van zijn type:

var naam string          // ""
var leeftijd int         // 0
var actief bool          // false

Die zero values zijn een bewuste keuze van de Go-ontwerpers. Je hebt in Go nooit te maken met undefined of null-achtige chaos bij niet-geïnitialiseerde variabelen.

Meerdere variabelen tegelijk

Je kunt meerdere variabelen in één statement declareren:

var (
    naam     string = "Sander"
    leeftijd int    = 35
    actief   bool   = true
)

Dit is handig bovenin een bestand voor pakket-niveau variabelen.

De korte notatie met :=

Binnen functies gebruik je meestal de korte declaratie met :=. Die combineert declareren en toekennen in één stap:

naam := "Sander"
leeftijd := 35
actief := true

Dit werkt alleen binnen functies. Op pakketniveau (buiten functies) moet je altijd var gebruiken.

De korte notatie is idiomatisch Go: je ziet hem overal in productiecode. Gebruik var vooral wanneer:

• Je een variabele wilt declareren zonder beginwaarde
• Je op pakketniveau werkt
• Je expliciet een type wilt specificeren dat afwijkt van wat Go zou afleiden

Meervoudige toekenning

Je kunt meerdere variabelen tegelijk toekennen, wat vooral handig is bij functies die meerdere waarden teruggeven:

voornaam, achternaam := "Sander", "van der Burgt"
waarde, fout := strconv.Atoi("42")

Dit patroon zie je overal in Go, omdat foutafhandeling bijna altijd via een extra return-waarde gaat.

De basistypes in Go

Go heeft een compact aantal ingebouwde types. Hieronder de belangrijkste:

Numerieke types

Gebruik int en float64 als standaardkeuze. Kies pas voor specifieke breedtes (int32, int64) als je een reden hebt, zoals binaire protocollen of geheugenefficiëntie in grote arrays.

Booleans

var klaar bool = false

Simpel: true of false. Geen truthy/falsy magie zoals in JavaScript.

Strings

Strings in Go zijn immutable en UTF-8 gecodeerd:

bericht := "Hallo wereld"
lengte := len(bericht) // aantal bytes, niet tekens!

Let op: len() geeft het aantal bytes terug, niet het aantal karakters. Voor Unicode-karakters gebruik je utf8.RuneCountInString() uit het standaardpakket. Zie ook de officiële Go documentatie over strings voor meer achtergrond.

Constanten met const

Een constante is een waarde die tijdens de uitvoering niet kan veranderen:

const Pi = 3.14159
const AppNaam = "We Develop Communication API"
const MaxVerbindingen = 100

Constanten worden bij compileren vastgelegd. Je kunt ze niet dynamisch vullen met het resultaat van een functie.

Gebruik const voor:

• Wiskundige of fysische constanten
• Configuratiewaarden die nooit wijzigen
• API-endpoints en URL-paden
• Foutmeldingen en statuswaarden

Iota voor opsommingen

Go kent geen echte enums, maar iota is de idiomatische oplossing:

const (
    Zondag = iota // 0
    Maandag       // 1
    Dinsdag       // 2
    Woensdag      // 3
)

iota telt automatisch op binnen een const-blok. Handig voor statuscodes, prioriteiten en andere opsommingen.

Samengestelde types

Naast de primitieve types heeft Go een aantal samengestelde types die je veel zult gebruiken.

Arrays en slices

Een array heeft een vaste grootte:

var getallen [3]int = [3]int{1, 2, 3}

Een slice is een flexibele, groeiende wrapper rond een array en wordt veel vaker gebruikt:

namen := []string{"Alice", "Bob", "Charlie"}
namen = append(namen, "Dave")

In praktijk zie je zelden arrays. Slices zijn de go-to keuze voor lijsten.

Maps

Een map is een key-value structuur:

scores := map[string]int{
    "Alice": 90,
    "Bob":   85,
}
scores["Charlie"] = 78

Gebruik maps voor snelle lookups op basis van een sleutel, zoals configuraties, caches of tellingen.

Structs

Met een struct bundel je gerelateerde velden in één type:

type Gebruiker struct {
    Naam     string
    Email    string
    Leeftijd int
}

sander := Gebruiker{
    Naam:  "Sander",
    Email: "[email protected]",
    Leeftijd: 35,
}

Structs zijn de basis van domeinmodellering in Go. Ze vervangen grotendeels wat je in andere talen met classes zou doen.

Type conversie

Go converteert nooit automatisch tussen types. Dit is expliciet:

var x int = 10
var y float64 = float64(x)
var z int = int(y)

Dit voorkomt subtiele bugs door impliciete conversies, maar dwingt je wel om er bewust over na te denken. Voor string-naar-nummer conversies gebruik je het strconv pakket:

getal, fout := strconv.Atoi("42")
if fout != nil {
    // handel fout af
}

Zichtbaarheid: hoofdletters doen ertoe

In Go bepaalt de eerste letter van een naam of iets geëxporteerd wordt uit het pakket:

• Hoofdletter (bijv. Gebruiker, NaamOphalen) → publiek, beschikbaar buiten het pakket
• Kleine letter (bijv. gebruiker, naamOphalen) → privé, alleen binnen het pakket

Dit geldt voor variabelen, functies, types en struct-velden. Er zijn geen public/private keywords; het is puur conventie via hoofdlettergebruik.

type Gebruiker struct {
    Naam     string // publiek
    email    string // privé
}

Pointers: een korte kennismaking

Een pointer verwijst naar het geheugenadres van een variabele. Dit is een concept dat je in Go regelmatig tegenkomt:

x := 10
p := &x       // p is een pointer naar x
fmt.Println(*p) // 10 - dereference
*p = 20       // verandert x

Pointers gebruik je vooral om:

• Grote structs niet onnodig te kopiëren
• Functies een waarde te laten muteren
• De afwezigheid van een waarde te modelleren (via nil)

De zero value van een pointer is nil. Dereference een nil-pointer en je programma crasht met een panic, dus check altijd op nil waar dat relevant is.

Praktische tips voor beginners

Een paar vuistregels die je veel frustratie besparen:

1. Gebruik := binnen functies, var erbuiten. Dit volgt de Go-conventies die je in elke codebase terugziet.
2. Vertrouw op zero values. Initialiseer alleen expliciet als je een niet-standaard waarde nodig hebt.
3. Declareer geen ongebruikte variabelen. Go weigert te compileren als je een variabele declareert en niet gebruikt. Dit lijkt streng, maar houdt je code schoon.
4. Gebruik _ voor waarden die je wilt negeren. Bijvoorbeeld _, fout := doeIets() als je alleen de foutwaarde wilt.
5. Kies beschrijvende namen. Go-code is idiomatisch kort, maar niet cryptisch. usr is prima, u1234 niet.

Meer diepgaande stijlgidsen vind je in de Effective Go documentatie, dé standaardreferentie voor idiomatische Go.

Veelgestelde vragen

Wat is het verschil tussen var en := in Go?

Met var declareer je een variabele expliciet, eventueel zonder waarde. Met := combineer je declaratie en toekenning in één stap, maar dat kan alleen binnen functies. Buiten functies moet je altijd var gebruiken.

Is Go statisch of dynamisch getypeerd?

Go is statisch getypeerd. Dat betekent dat het type van elke variabele bij compileren vastligt en niet kan veranderen. Wel kan Go het type zelf afleiden via type inference, wat de code beknopter maakt.

Wat is de zero value in Go?

Elke variabele in Go krijgt automatisch een standaardwaarde als je geen waarde toekent. Voor int is dat 0, voor string een lege string, voor bool false en voor pointers nil. Je krijgt dus nooit undefined gedrag door niet-geïnitialiseerde variabelen.

Wanneer gebruik je een constante in plaats van een variabele?

Gebruik const wanneer een waarde tijdens de uitvoering nooit verandert, zoals configuratiewaarden, wiskundige constanten of API-eindpunten. Dit voorkomt onbedoelde wijzigingen en maakt je code beter leesbaar.

Wat is het verschil tussen int en int64?

int is platformafhankelijk: op een 64-bit systeem is int 64 bits, op 32-bit systemen 32 bits. int64 is altijd precies 64 bits. Gebruik int voor algemene tellingen en int64 wanneer je een gegarandeerde grootte nodig hebt.

Volgende stappen

Je kent nu de belangrijkste bouwstenen van Go: variabelen declareren, de basistypes, constanten, structs en pointers. Dit is de fundering waarop alle verdere Go-code rust.

In het volgende artikel in deze serie duiken we dieper in functies, controlestructuren en foutafhandeling, de onderwerpen waar je variabelen en types actief mee gaat gebruiken. Begin vooral met experimenteren: maak een klein programma dat een struct definieert, een slice vult en iets uitprint. Oefening leert je sneller dan alleen lezen.