Go jest nowoczesnym językiem programowania stworzonym przez Google, który zdobywa popularność dzięki swojej prostocie i efektywności. Jednym z fundamentalnych elementów Go są slice’y. W tym wpisie przyjrzymy się, czym są slice’y, jak z nimi pracować oraz przedstawimy kilka przykładów kodu, aby lepiej zrozumieć ich zastosowanie.

Czym jest slice?

Slice’y w Go to dynamiczne, zmienialne sekwencje elementów o tym samym typie. Można je porównać do tablic (array), jednak w przeciwieństwie do tablic, slice’y mogą zmieniać swój rozmiar. Slice’y są bardziej elastyczne i wygodne w użyciu, dlatego są preferowane w codziennym programowaniu w Go.

Slice’y są tworzone na podstawie tablic i przechowują trzy wartości:

1. pointer – wskazuje na pierwszy element tablicy, który jest częścią slice’a;
2. length – długość slice’a, czyli liczba elementów, które zawiera;
3. capacity – pojemność slice’a, czyli liczba elementów od pierwszego elementu slice’a do końca tablicy bazowej.

Tworzenie Slice’ów

Slice’y można tworzyć na kilka sposobów. Oto kilka przykładów:

Tworzenie slice za pomocą funkcji make

package main

import "fmt"

func main() {
	slice1 := make([]int, 3, 5)
	fmt.Println(slice1)      // Output: [0 0 0]
	fmt.Println(len(slice1)) // Output: 3
	fmt.Println(cap(slice1)) // Output: 5

	slice2 := make([]int, 3)
	fmt.Println(slice2)      // Output: [0 0 0]
	fmt.Println(len(slice2)) // Output: 3
	fmt.Println(cap(slice2)) // Output: 3
}

Funkcja make pozwala na utworzenie slice’a z określoną długością i pojemnością. W pierwszym przypadku (zmienna slice1) tworzymy slice z trzema elementami o pojemności pięciu. Pojemność może zostać pominięta. W takim przypadku będzie ona równa długości początkowej (zmienna slice2).

Inicjalizacja slice’a za pomocą literali

package main

import "fmt"

func main() {
	slice := []int{1, 2, 3, 4, 5}
	fmt.Println(slice) // Output: [1 2 3 4 5]

	sliceEmpty := []int{}
	fmt.Println(sliceEmpty) // Output: []
}

Możemy inicjalizować slice bezpośrednio za pomocą literali:

Inicjalizacja slice’a z tablicy (array)

package main

import "fmt"

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	slice := arr[1:4]

	fmt.Println(slice) // Output: [2 3 4]
}

Slice można także utworzyć z fragmentu tablicy (array). W powyższym przykładzie tworzymy tablicę o rozmiarze 5, a następnie tworzymy slice z elementów od indeksu 1 do 3 (przed indeksem 4).

Operacje na slice’ach

Dodawanie elementów

package main

import "fmt"

func main() {
	slice := []int{1, 2, 3}
	slice = append(slice, 4, 5)

	fmt.Println(slice) // Output: [1 2 3 4 5]
}

Funkcja append pozwala na dodawanie elementów do slice’a. Jeśli pojemność slice’a jest zbyt mała, Go automatycznie powiększy tablicę bazową.

Kopiowanie slice’ów

package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3}
	slice2 := make([]int, len(slice1))
	copy(slice2, slice1)

	fmt.Println(slice2) // Output: [1 2 3]
}

Funkcja copy kopiuje elementy z jednego slice’a do drugiego. W powyższym przykładzie tworzymy nowy slice slice2 o tej samej długości co slice1 i kopiujemy zawartość slice1 do slice2.

Podslice’y

package main

import "fmt"

func main() {
	slice := []int{1, 2, 3, 4, 5}
	subSlice := slice[1:4]

	fmt.Println(subSlice) // Output: [2 3 4]
}

Możemy tworzyć podslice’y, korzystając z operatora indeksowania. W powyższym przykładzie tworzymy podslice, który zawiera elementy od indeksu 1 do 3. Operacja jest podoba do inicjalizacji nowego slice’a z tablicy opisanej powyżej, jednak tutaj operujemy na innym slice.

Usuwanie elementu slice z danego indeksu

W Go usuwanie pojedynczego elementu z slice’a można osiągnąć poprzez połączenie dwóch podslice’ów: przed i po usuwanym elemencie. Poniższy kod pokazuje, jak usunąć element z danego indeksu i:

package main

import "fmt"

func main() {
	slice := []int{1, 2, 3, 4, 5}
	i := 2 // indeks elementu do usunięcia

	slice = append(slice[:i], slice[i+1:]...)

	fmt.Println(slice) // Output: [1 2 4 5]
}

W powyższym przykładzie, tworzymy nowy slice, który składa się z elementów przed i po usuniętym elemencie. Używamy funkcji append do połączenia dwóch podslice’ów, co pozwala na skuteczne usunięcie elementu z pierwotnego slice’a.

Podsumowanie

Slice’y w Go to potężne narzędzie, które oferuje elastyczność i prostotę pracy z sekwencjami danych. Dzięki nim możemy efektywnie zarządzać dynamicznymi kolekcjami danych, co jest niezwykle przydatne w codziennym programowaniu. Wszystkie przykłady powyżej oparte zostały na slice’ach z liczbami całkowitymi (int), ale slice może zawierać dowolny typ zmiennej. Zachęcam do eksperymentowania z nimi w swoich projektach, aby w pełni wykorzystać ich możliwości!