Oefening: matrices gebruiken
Matrices in Go zijn een gegevensstructuur met een vaste lengte van een bepaald type. Ze kunnen nul of meer elementen hebben en u moet de grootte definiëren wanneer u ze declareert of initialiseert. U kunt de grootte ook niet wijzigen nadat ze zijn gemaakt. Om deze redenen worden matrices niet vaak gebruikt in Go-programma's, maar vormen ze de basis voor segmenten en kaarten.
Matrices declareren
Als u een matrix in Go wilt declareren, moet u het gegevenstype van de elementen definiëren en het aantal elementen dat de matrix kan bevatten. Vervolgens kunt u elk element in de matrix openen met de subscript-notatie waarbij nul het eerste element is en het laatste element één kleiner is dan de lengte van de matrix (lengte - 1).
Laten we bijvoorbeeld de volgende code gebruiken:
package main
import "fmt"
func main() {
var a [3]int
a[1] = 10
fmt.Println(a[0])
fmt.Println(a[1])
fmt.Println(a[len(a)-1])
}
Wanneer u de voorgaande code uitvoert, krijgt u de volgende uitvoer:
0
10
0
Hoewel u een matrix hebt gedeclareerd, krijgt u geen foutmelding wanneer u de elementen opent. Standaard initialiseert Go elk element met het standaardgegevenstype. In dit geval is de standaardwaarde int voor nul. Maar u kunt een waarde toewijzen aan een specifieke positie, zoals we dat ook a[1] = 10hebben gedaan. En u hebt toegang tot dat element met behulp van dezelfde notatie. Merk ook op dat we naar het eerste element verwijzen, dat we hebben gebruikt a[0]. Om te verwijzen naar het laatste element, hebben we gebruikt a[len(a)-1]. De len functie is een ingebouwde functie in Go om het aantal elementen in een matrix, segment of kaart op te halen.
Matrices initialiseren
U kunt ook een matrix initialiseren met andere waarden dan de standaardwaarden wanneer u een matrix declareert. U kunt bijvoorbeeld de volgende code gebruiken om de syntaxis te bekijken en te testen:
package main
import "fmt"
func main() {
cities := [5]string{"New York", "Paris", "Berlin", "Madrid"}
fmt.Println("Cities:", cities)
}
Voer de voorgaande code uit en u ziet deze uitvoer:
Cities: [New York Paris Berlin Madrid ]
Hoewel de matrix vijf elementen moet hebben, hoeven we geen waarde toe te wijzen aan alle elementen. Zoals we eerder hebben gezien, heeft de laatste positie een lege tekenreeks omdat dit de standaardwaarde is voor een tekenreeksgegevenstype.
Beletselteken in matrices
Een andere manier om een matrix te declareren en initialiseren wanneer u niet weet hoeveel posities u nodig hebt, maar u weet welke set gegevenselementen u nodig hebt, is door een beletselteken (...) te gebruiken, zoals in dit voorbeeld:
q := [...]int{1, 2, 3}
Laten we het programma wijzigen dat we in de vorige sectie hebben gebruikt om een beletselteken te gebruiken. De code moet er als volgt uitzien:
package main
import "fmt"
func main() {
cities := [...]string{"New York", "Paris", "Berlin", "Madrid"}
fmt.Println("Cities:", cities)
}
Voer de voorgaande code uit en u ziet een vergelijkbare uitvoer, zoals in dit voorbeeld:
Cities: [New York Paris Berlin Madrid]
Zie je het verschil? Er is geen lege tekenreeks aan het einde. De matrixlengte is bepaald door de tekenreeksen die u hebt geplaatst toen u deze initialiseerde. U reserveert geen geheugen dat u niet weet of u uiteindelijk nodig hebt.
Een andere interessante manier om een matrix te initialiseren is door een beletselteken te gebruiken en alleen een waarde op te geven voor de laatste positie. Gebruik bijvoorbeeld de volgende code:
package main
import "fmt"
func main() {
numbers := [...]int{99: -1}
fmt.Println("First Position:", numbers[0])
fmt.Println("Last Position:", numbers[99])
fmt.Println("Length:", len(numbers))
}
Voer deze code uit en u krijgt deze uitvoer:
First Position: 0
Last Position: -1
Length: 100
U ziet dat de lengte van de matrix 100 is omdat u een waarde hebt opgegeven voor de 99e positie. Op de eerste positie wordt de standaardwaarde (nul) afgedrukt.
Multidimensionale matrices
Go biedt ondersteuning voor multidimensionale matrices wanneer u met complexe gegevensstructuren moet werken. Laten we een programma maken waarin u een tweedimensionale matrix declareert en initialiseert. Gebruik de volgende code:
package main
import "fmt"
func main() {
var twoD [3][5]int
for i := 0; i < 3; i++ {
for j := 0; j < 5; j++ {
twoD[i][j] = (i + 1) * (j + 1)
}
fmt.Println("Row", i, twoD[i])
}
fmt.Println("\nAll at once:", twoD)
}
Voer het voorgaande programma uit en u ziet een uitvoer zoals in dit voorbeeld:
Row 0 [1 2 3 4 5]
Row 1 [2 4 6 8 10]
Row 2 [3 6 9 12 15]
All at once: [[1 2 3 4 5] [2 4 6 8 10] [3 6 9 12 15]]
U hebt een tweedimensionale matrix gedeclareerd die aangeeft hoeveel posities de matrix in de tweede dimensie zou hebben, zoals deze var twoD [3][5]int. U kunt deze matrix beschouwen als één gegevensstructuur met kolommen en rijen, zoals een spreadsheet of een matrix. Op dit moment hebben alle posities een standaardwaarde van nul. In de for lus initialiseren we elke positie met een ander waardepatroon bij elke rij. Ten slotte drukt u alle waarden ervan af naar de terminal.
Wat moet u doen als u een driedimensionale matrix wilt declareren? Misschien denk je wat de syntaxis zou zijn, toch? U kunt dit doen zoals in dit voorbeeld:
package main
import "fmt"
func main() {
var threeD [3][5][2]int
for i := 0; i < 3; i++ {
for j := 0; j < 5; j++ {
for k := 0; k < 2; k++ {
threeD[i][j][k] = (i + 1) * (j + 1) * (k + 1)
}
}
}
fmt.Println("\nAll at once:", threeD)
}
Voer de voorgaande code uit en u ziet nu uitvoer zoals in dit voorbeeld:
All at once: [[[1 2] [2 4] [3 6] [4 8] [5 10]] [[2 4] [4 8] [6 12] [8 16] [10 20]] [[3 6] [6 12] [9 18] [12 24] [15 30]]]
Als we de uitvoer opmaken in een beter leesbare indeling, hebt u mogelijk iets zoals in dit voorbeeld:
All at once:
[
[
[1 2] [2 4] [3 6] [4 8] [5 10]
]
[
[2 4] [4 8] [6 12] [8 16] [10 20]
]
[
[3 6] [6 12] [9 18] [12 24] [15 30]
]
]
U ziet hoe de structuur verandert van een tweedimensionale matrix. U kunt naar behoefte meer dimensies hebben, maar we laten het hier voorlopig staan, omdat we andere gegevenstypen hebben om te verkennen.