Övning – Använda matriser

Slutförd

Matriser i Go är en datastruktur med fast längd av en viss typ. De kan ha noll eller fler element och du måste definiera storleken när du deklarerar eller initierar dem. Du kan inte heller ändra storlek på dem när de har skapats. Därför används inte matriser ofta i Go-program, men de är grunden för sektorer och kartor.

Deklarera matriser

Om du vill deklarera en matris i Go måste du definiera datatypen för dess element och antalet element som matrisen kan innehålla. Du kan sedan komma åt varje element i matrisen med den nedsänkta notationen där noll är det första elementet och det sista elementet är ett mindre än matrislängden (längd - 1).

Vi använder till exempel följande kod:

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])
}

När du kör föregående kod får du följande utdata:

0
10
0

Även om du har deklarerat en matris får du inget fel när du kommer åt dess element. Som standard initierar Go varje element med standarddatatypen. I det här fallet är standardvärdet för int noll. Men du kan tilldela ett värde till en viss position, som vi gjorde med a[1] = 10. Och du kan komma åt det elementet med hjälp av samma notation. Observera också att vi använde a[0]för att referera till det första elementet . För att referera till det sista elementet använde a[len(a)-1]vi . Funktionen len är en inbyggd funktion i Go för att hämta antalet element i en matris, ett segment eller en karta.

Initiera matriser

Du kan också initiera en matris med andra värden än standardvärdena när du deklarerar en matris. Du kan till exempel använda följande kod för att se och testa syntaxen:

package main

import "fmt"

func main() {
    cities := [5]string{"New York", "Paris", "Berlin", "Madrid"}
    fmt.Println("Cities:", cities)
}

Kör föregående kod så bör du se följande utdata:

Cities: [New York Paris Berlin Madrid ]

Även om matrisen ska ha fem element behöver vi inte tilldela ett värde till alla element. Som vi har sett tidigare har den sista positionen en tom sträng eftersom det är standardvärdet för en strängdatatyp.

Ellips i matriser

Ett annat sätt att deklarera och initiera en matris när du inte vet hur många positioner du behöver, men du känner till uppsättningen med dataelement, är att använda en ellips (...), som i det här exemplet:

q := [...]int{1, 2, 3}

Nu ska vi ändra programmet som vi använde i föregående avsnitt för att använda en ellips. Koden bör se ut så här:

package main

import "fmt"

func main() {
    cities := [...]string{"New York", "Paris", "Berlin", "Madrid"}
    fmt.Println("Cities:", cities)
}

Kör föregående kod och du bör se liknande utdata, som i det här exemplet:

Cities: [New York Paris Berlin Madrid]

Kan du se skillnaden? Det finns ingen tom sträng i slutet. Matrislängden fastställdes av de strängar som du lade till när du initierade den. Du reserverar inte minne som du inte vet om du kommer att behöva.

Ett annat intressant sätt att initiera en matris är att använda en ellips och endast ange ett värde för den sista positionen. Använd till exempel följande kod:

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))
}

Kör den här koden så får du följande utdata:

First Position: 0
Last Position: -1
Length: 100

Observera hur matrislängden är 100 eftersom du angav ett värde för den 99:e positionen. Den första positionen skriver ut standardvärdet (noll).

Flerdimensionella matriser

Go har stöd för flerdimensionella matriser när du behöver arbeta med komplexa datastrukturer. Nu ska vi skapa ett program där du deklarerar och initierar en tvådimensionell matris. Använd följande kod:

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)
}

Kör föregående program och du bör se utdata som det här exemplet:

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]]

Du har deklarerat en tvådimensionell matris som anger hur många positioner matrisen skulle ha i den andra dimensionen, som den här var twoD [3][5]int. Du kan tänka på den här matrisen som en datastruktur med kolumner och rader, till exempel ett kalkylblad eller en matris. I det här läget har alla positioner ett standardvärde på noll. I loopen for initierar vi varje position med ett annat värdemönster på varje rad. Slutligen skriver du ut alla dess värden till terminalen.

Vad händer om du vill deklarera en tredimensionell matris? Du kanske gissar vad syntaxen skulle vara, eller hur? Du kan göra det som i det här exemplet:

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)
}

Kör föregående kod och du bör se utdata som det här exemplet:

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]]]

Om vi formaterar utdata i ett mer läsbart format kan du ha något som liknar det här exemplet:

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]
    ]
]

Observera hur strukturen ändras från en tvådimensionell matris. Du kan fortsätta att ha fler dimensioner som du behöver, men vi lämnar det här för tillfället eftersom vi har andra datatyper att utforska.