0Pricing
Go Academy · Lekcja

Slice: listy dynamiczne

make, append, copy, len i cap

Slice: listy dynamiczne to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Czym jest wycinek

Wycinek to dynamicznie zmieniający rozmiar widok na tablicę bazową. Składa się z trzech elementów: wskaźnika do tablicy, długości i pojemności.

  • Wycinki są typami referencyjnymi — wiele wycinków może współdzielić tę samą tablicę bazową
  • W większości zastosowań przypominających listy w języku Go używa się wycinków, a nie tablic

Literały wycinków i make

Wycinki można tworzyć za pomocą literału lub 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 i cap

len zwraca liczbę elementów znajdujących się obecnie w wycinku. cap zwraca pojemność tablicy bazowej, liczoną od wskaźnika początku wycinka.

package main
import "fmt"

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

append: powiększanie wycinka

append dodaje elementy do wycinka, przydzielając nową tablicę bazową po przekroczeniu pojemności:

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

Tworzenie podwycinka

Składnia [low:high] służy do tworzenia podwycinka (współdzielącego tablicę bazową):

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: niezależne wycinki

copy kopiuje elementy między wycinkami i zwraca liczbę skopiowanych elementów. Miejsce docelowe i źródło nie współdzielą pamięci:

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
}

Wycinek nil a pusty wycinek

Wycinek nil nie ma tablicy bazowej. Pusty wycinek ma tablicę bazową, ale jego długość wynosi 0. Oba mają 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!
}

Usuwanie elementu

Go nie ma wbudowanej funkcji usuwania elementów z wycinków. Idiomatyczne podejście wykorzystuje 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]
}

Wstawianie elementu

Element na pozycji i można wstawić, łącząc append z tworzeniem wycinków:

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

Pułapka wycinków: współdzielona tablica bazowa

Podwycinki współdzielą tablicę bazową — modyfikacja jednego wpływa na drugi do momentu ponownego przydzielenia pamięci:

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

Szybkie sprawdzenie

Co zwraca append?

Podsumowanie: wycinki

Najważniejsze informacje:

  • Wycinki = wskaźnik + len + cap; są widokami na tablice
  • Należy używać make, aby z wyprzedzeniem przydzielać pojemność
  • Zawsze należy przypisywać wynik działania append
  • copy tworzy niezależne wycinki
  • Należy pamiętać o współdzielonych tablicach bazowych podwycinków

Zadanie praktyczne

Należy utworzyć wycinek 5 liczb całkowitych za pomocą make, dołączyć trzy kolejne wartości, a następnie skopiować go do nowego wycinka i zmodyfikować kopię bez wpływu na oryginał. Należy wypisać oba wycinki.

Często zadawane pytania

Czy lekcja „Slice: listy dynamiczne” jest bezpłatna?

Tak — pełny tekst „Slice: listy dynamiczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Slice: listy dynamiczne”?

make, append, copy, len i cap Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Slice: listy dynamiczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Tablice: kolekcje o stałej długości
  2. Slice: listy dynamiczne
  3. Mapy: magazyny klucz-wartość
  4. Iterowanie po kolekcjach za pomocą range
← Powrót do Go Academy