Go - ломтики

Go Slice - это абстракция над Go Array. Go Array позволяет вам определять переменные, которые могут содержать несколько элементов данных одного и того же типа, но он не предоставляет никаких встроенных методов для динамического увеличения его размера или получения собственного подмассива. Ломтики преодолевают это ограничение. Он предоставляет множество служебных функций, необходимых для Array, и широко используется в программировании на Go.

Определение среза

Чтобы определить срез, вы можете объявить его как массив без указания его размера. В качестве альтернативы вы можете использоватьmake функция для создания среза.

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*/

Функции len () и cap ()

Срез - это абстракция над массивом. Фактически в качестве базовой структуры используются массивы. Вlen() функция возвращает элементы, представленные в срезе, где cap()функция возвращает емкость среза (то есть, сколько элементов в нем можно разместить). В следующем примере объясняется использование среза -

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

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

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

Нулевой ломтик

Если срез объявлен без входных данных, то по умолчанию он инициализируется как nil. Его длина и вместимость равны нулю. Например -

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

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

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

Нарезка

Slice позволяет указывать нижнюю и верхнюю границы, чтобы получить его часть, используя[lower-bound:upper-bound]. Например -

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

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

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]

Функции append () и copy ()

Увеличить емкость среза можно с помощью append()функция. С помощьюcopy()функция, содержимое исходного слайса копируется в целевой слайс. Например -

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

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

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]