Cvičení – použití polí

Dokončeno

Pole v Go jsou datová struktura určitého typu s pevnou délkou. Mohou mít nula nebo více prvků a při deklaraci nebo inicializaci je nutné definovat velikost. Po vytvoření také nemůžete změnit jejich velikost. Z těchto důvodů se pole běžně nepoužívají v programech Go, ale představují základ pro řezy a mapy.

Deklarace polí

Chcete-li deklarovat pole v jazyce Go, musíte definovat datový typ jeho prvků a počet prvků, které pole může obsahovat. Pak můžete přistupovat ke každému prvku v poli s zápisem dolního indexu, kde nula je první prvek a poslední prvek je jeden menší než délka pole (délka - 1).

Pojďme například použít následující kód:

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

Při spuštění předchozího kódu získáte následující výstup:

0
10
0

I když jste deklarovali pole, při přístupu k jeho prvkům se nezobrazí chyba. Ve výchozím nastavení Go inicializuje každý prvek s výchozím datovým typem. V tomto případě je výchozí hodnota nula int . Můžete ale přiřadit hodnotu ke konkrétní pozici, jak jsme to udělali s a[1] = 10. A k ho prvku můžete přistupovat pomocí stejného zápisu. Všimněte si také, že pro odkaz na první prvek jsme použili a[0]. Pro odkaz na poslední prvek jsme použili a[len(a)-1]. Funkce len je integrovaná funkce v go, která získá počet prvků v poli, řezu nebo mapě.

Inicializace polí

Při deklarování pole můžete také inicializovat s jinými hodnotami, než jsou výchozí hodnoty. K zobrazení a otestování syntaxe můžete použít například následující kód:

package main

import "fmt"

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

Spusťte předchozí kód a měli byste vidět tento výstup:

Cities: [New York Paris Berlin Madrid ]

I když pole by mělo mít pět prvků, nemusíme všem prvkům přiřazovat hodnotu. Jak jsme viděli dříve, poslední pozice má prázdný řetězec, protože se jedná o výchozí hodnotu pro datový typ řetězce.

Tři tečky v polích

Dalším způsobem, jak deklarovat a inicializovat pole, když nevíte, kolik pozic budete potřebovat, ale znáte sadu datových prvků, je použít tři tečky (...), jako je tento příklad:

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

Pojďme upravit program, který jsme použili v předchozí části, a použít tři tečky. Kód by měl vypadat jako v tomto příkladu:

package main

import "fmt"

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

Spusťte předchozí kód a měli byste vidět podobný výstup, jako je tento příklad:

Cities: [New York Paris Berlin Madrid]

Vidíte rozdíl? Na konci není žádný prázdný řetězec. Délka pole byla určena řetězci, které jste dali při inicializaci. Nezarezervujete paměť, kterou nevíte, jestli budete potřebovat.

Dalším zajímavým způsobem inicializace pole je použití tří teček a určení hodnoty pouze pro poslední pozici. Použijte například následující kód:

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

Spusťte tento kód a získáte tento výstup:

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

Všimněte si, že délka pole je 100, protože jste zadali hodnotu pro 99. pozici. První pozice vytiskne výchozí hodnotu (nula).

Multidimenzionální pole

Go podporuje multidimenzionální pole, když potřebujete pracovat se složitými datovými strukturami. Pojďme vytvořit program, ve kterém deklarujete a inicializujete dvojrozměrné pole. Použijte následující kód:

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

Spusťte předchozí program a měli byste vidět výstup podobný tomuto příkladu:

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

Deklarovali jste dvojrozměrnou matici, která určuje, kolik pozic bude mít pole ve druhé dimenzi, například v tomto var twoD [3][5]intpřípadě . O této matici byste mohli uvažovat jako o jedné datové struktuře se sloupci a řádky, jako je tabulka nebo matice. V tomto okamžiku mají všechny pozice výchozí hodnotu nula. for Ve smyčce inicializujeme každou pozici s jiným vzorem hodnoty na každém řádku. Nakonec vypíšete všechny jeho hodnoty do terminálu.

Co když chcete deklarovat trojrozměrné pole? No, můžeš hádat, co by syntaxe byla, že? Můžete to udělat takto:

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

Spusťte předchozí kód a měli byste vidět výstup podobný tomuto příkladu:

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

Pokud formátujeme výstup v čitelnějším formátu, můžete mít něco jako v tomto příkladu:

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

Všimněte si, jak se struktura mění z dvojrozměrného pole. Můžete i nadále mít více dimenzí, jak potřebujete, ale prozatím ho necháme tady, protože máme další datové typy, které je potřeba prozkoumat.