Idź - plastry

Go Slice to abstrakcja dotycząca Go Array. Go Array umożliwia definiowanie zmiennych, które mogą przechowywać kilka elementów danych tego samego rodzaju, ale nie zapewnia żadnej wbudowanej metody dynamicznego zwiększania jego rozmiaru lub uzyskiwania własnej pod-tablicy. Plasterki pokonują to ograniczenie. Zapewnia wiele funkcji narzędziowych wymaganych w Array i jest szeroko stosowany w programowaniu w Go.

Definiowanie plastra

Aby zdefiniować wycinek, możesz zadeklarować go jako tablicę bez określania jego rozmiaru. Alternatywnie możesz użyćmake funkcja tworzenia plasterka.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

Funkcje len () i cap ()

Wycinek jest abstrakcją nad tablicą. W rzeczywistości wykorzystuje tablice jako podstawową strukturę. Pliklen() funkcja zwraca elementy obecne w wycinku, gdzie cap()funkcja zwraca pojemność wycinka (tj. ile elementów może pomieścić). Poniższy przykład wyjaśnia użycie plastra -

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

len = 3 cap = 5 slice = [0 0 0]

Brak plastra

Jeśli wycinek jest zadeklarowany bez danych wejściowych, to domyślnie jest inicjowany jako zero. Jego długość i pojemność są zerowe. Na przykład -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

len = 0 cap = 0 slice = []
slice is nil

Podlicowanie

Slice pozwala określić dolną i górną granicę, aby uzyskać podrzędną granicę za pomocą[lower-bound:upper-bound]. Na przykład -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

Funkcje append () i copy ()

Można zwiększyć pojemność plastra za pomocą append()funkcjonować. Za pomocącopy()funkcja, zawartość wycinka źródłowego jest kopiowana do wycinka docelowego. Na przykład -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]