Git - Dilimler

Go Slice, Go Array üzerinde bir soyutlamadır. Go Array, aynı türden birkaç veri öğesini tutabilen değişkenler tanımlamanıza olanak tanır, ancak boyutunu dinamik olarak artırmak veya kendi alt dizisini almak için herhangi bir dahili yöntem sağlamaz. Dilimler bu sınırlamanın üstesinden gelir. Array'de gerekli olan birçok yardımcı işlevi sağlar ve Go programlamasında yaygın olarak kullanılır.

Bir dilim tanımlama

Bir dilimi tanımlamak için, boyutunu belirtmeden onu bir dizi olarak bildirebilirsiniz. Alternatif olarak kullanabilirsinizmake dilim oluşturma işlevi.

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 () ve cap () işlevleri

Bir dilim, dizi üzerinde bir soyutlamadır. Aslında dizileri temel yapı olarak kullanır. len() işlev, dilimde bulunan öğeleri döndürür cap()işlev, dilimin kapasitesini döndürür (yani, kaç öğenin barındırılabileceğini). Aşağıdaki örnek dilim kullanımını açıklamaktadır -

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

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

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

Nil dilim

Bir dilim giriş olmadan bildirilirse, o zaman varsayılan olarak sıfır olarak başlatılır. Uzunluğu ve kapasitesi sıfırdır. Örneğin -

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

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

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

Alt dilimleme

Dilim, alt sınırın ve üst sınırın, alt dilimini kullanarak alması için belirtilmesine izin verir.[lower-bound:upper-bound]. Örneğin -

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

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

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 () ve copy () İşlevleri

Bir dilimin kapasitesi, append()işlevi. Kullanmacopy()fonksiyon, bir kaynak dilimin içeriği bir hedef dilime kopyalanır. Örneğin -

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

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

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]