Arrays met vaste lengte

In Go heeft een array een vaste lengte, ingebakken in het type: [N]T. Het is een primitief dat zelden rechtstreeks in applicatiecode wordt gebruikt - dat zal wel zo zijn werk bijna altijd met slices (volgende les), die dynamisch zijn weergaven over arrays.

Toch is het goed begrijpen van arrays essentieel: alles in Go is gebouwd bovenop hen.

Verklaring en initialisatie

var a [3]int = [3]int{10, 20, 30}
b := [3]int{1, 2, 3}            // inference with :=
c := [3]int{}                   // all zero: [0, 0, 0]
d := [...]int{1, 2, 3, 4}       // length inferred = 4

De nulwaarde van een array is een array met de aangegeven lengte met elke element op zijn nulwaarde:

var nums [5]int  // [0 0 0 0 0]

Indexering en len

a := [3]int{10, 20, 30}
fmt.Println(a[0])      // 10
a[1] = 99
fmt.Println(len(a))    // 3

Toegang buiten bereik veroorzaakt een runtime-paniek (niet een stil ongedefinieerd zoals bij C).

Lengte is onderdeel van het type

var a [3]int
var b [4]int
// a = b   // ERROR: different types

[3]int en [4]int zijn verschillende typen, ook al gelden beide BESCHERMD_INLINE_5. Dit is de reden waarom arrays zelden worden doorgegeven aan functies: dat zou wel moeten codeer de lengte hard in het parametertype.

Kopiëren op waarde

In tegenstelling tot segmenten (referentie) en kaarten (referentie), worden arrays gekopieerd door waarde:

a := [3]int{1, 2, 3}
b := a               // copy
b[0] = 99
fmt.Println(a[0])    // 1 — a is unchanged

Hetzelfde geldt bij het doorgeven aan een functie: de functie ontvangt zijn eigen exemplaar.

Wanneer arrays gebruiken?

• Buffers met een vaste grootte die bekend zijn tijdens het compileren (bijvoorbeeld [16]byte voor een MD5).
• Samengestelde kaartsleutels (segmenten zijn niet "vergelijkbaar", arrays wel).
• Extreme prestaties (geen indirecte, cache-vriendelijk).

Voor 99% van de code: gebruik segmenten.

Probeer het

var a [3]int
var b [4]int
// a = b ?

Samenvatten

• [N]T: vaste lengte, onderdeel van het type.
• Nulwaarde: elk element op zijn nulwaarde.
• Met [...]int{...} kan de compiler de lengte afleiden.
• Kopiëren op waarde (inclusief interne functies).
• Buiten bereik = paniek, niet ongedefinieerd.
• Gebruik in de praktijk slices, dit zijn views over arrays.