Go Academy · Lektion

Slices: dynamiska listor

make, append, copy, len och cap

Lektion 2 av 413 steg

Slices: dynamiska listor är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad är en slice

En slice är en vy med dynamisk storlek över en underliggande array. Den har tre komponenter: en pekare till arrayen, en längd och en kapacitet.

Slices är referenstyper – flera slices kan dela samma underliggande array
Det mesta listliknande arbetet i Go använder slices, inte arrayer

Sliceliteraler och make

Skapa slices med en literal eller make:

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len och cap

len returnerar antalet element som för närvarande finns i slicen. cap returnerar kapaciteten hos den underliggande arrayen från slicens startpekare.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append: växa en slice

append lägger till element i en slice och allokerar en ny underliggande array när kapaciteten överskrids:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Skära ut en del av en slice

Använd syntaxen [low:high] för att skapa en del-slice (den delar den underliggande arrayen):

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy: oberoende slices

copy kopierar element mellan slices och returnerar antalet kopierade element. Destinationen och källan delar inte minne:

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

nil-slice eller tom slice

En nil-slice har ingen underliggande array. En tom slice har en underliggande array men längden 0. Båda har len == 0:

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Ta bort ett element

Go har ingen inbyggd delete-funktion för slices. Det idiomatiska sättet använder append:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Infoga ett element

Infoga på position i genom att kombinera append och slicing:

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Fallgrop med slices: delad underliggande array

Del-slices delar den underliggande arrayen – om ni ändrar den ena påverkas den andra tills en ny allokering sker:

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Snabb kontroll

Vad returnerar append?

Besvara frågan i den interaktiva lektionen

Sammanfattning: slices

Viktiga punkter:

Slices = pekare + len + cap; de omsluter arrayer
Använd make för att förallokera kapacitet
Tilldela alltid resultatet från append
copy skapar oberoende slices
Var medveten om delade underliggande arrayer hos del-slices

Övningsuppgift

Skapa en slice med 5 heltal med make, lägg till ytterligare tre värden, kopiera den sedan till en ny slice och ändra kopian utan att påverka originalet. Skriv ut båda.

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Slices: dynamiska listor” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Slices: dynamiska listor”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Slices: dynamiska listor”?

make, append, copy, len och cap Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Slices: dynamiska listor”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Go Academy