Go Langue tranche (tranche)

tranche Go Langue est un tableau d'abstraction.

Aller longueur du tableau ne peut pas être changé, de sorte que la collection est pas aussi utile dans certains scénarios, Go fournit un flexible, puissant intégré dans la section de type ( "tableau dynamique"), par rapport à la longueur matrice de tranche est pas fixe , les éléments peuvent être ajoutés lorsque les augmentations de capacité supplémentaires peuvent faire des tranches.

Défini tranche

Vous pouvez déclarer un tableau de taille non spécifiée pour définir la tranche:

var identifier []type

longueur explicite en tranches.

Ou pour créer une tranche en utilisant make () fonction:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

Vous pouvez également spécifier la capacité, où la capacité est facultative.

make([]T, length, capacity)

Ici len est la longueur de la matrice ainsi que la longueur initiale de la tranche.

Slice initialisation

s :=[] int {1,2,3 } 

sections d'initialisation directe [] représentent un type de tranche, {1,2,3} valeurs d'initialisation suivie par 1,2,3 son bouchon = len = 3

s := arr[:] 

Initialisation tranche s, est une référence à l'arr array

s := arr[startIndex:endIndex] 

Il va créer une nouvelle tranche de l'élément à l'index startIndex endIndex 1-dessous dans arr

s := arr[startIndex:] 

Le dernier élément doit arr défaut lorsque endIndex

s := arr[:endIndex] 

Indiquant à partir du premier élément du arr temps par défaut startIndex

s1 := s[startIndex:endIndex] 

Tranche par tranche s initialize s1

s :=make([]int,len,cap) 

Grâce à la fonction intégrée make () Initialise tranche s, [] int identifie ses éléments de type tranches int

fonction len () et le capuchon ()

Tranche est indexée et peut être obtenue par la méthode de la longueur len ().

Slice fournit une méthode pour calculer le plafond de capacité () peut être mesuré jusqu'à un nombre maximum de tranches.

Les exemples spécifiques suivants:

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

Exécutez l'exemple ci-dessus est sortie:

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

Empty (néant) en tranches

Une tranche avant défaut non initialisée est nulle, une longueur de 0, les exemples sont les suivants:

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

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

Exécutez l'exemple ci-dessus est sortie:

len=0 cap=0 slice=[]
切片是空的

Slice interception

Vous pouvez définir la tranche d'interception [limite inférieure: borne supérieure ] en mettant inférieure et supérieure, des exemples sont les suivants:

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

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

Exécuter les résultats de sortie de code ci-dessus:

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 () et copier () fonction

Si vous souhaitez augmenter la capacité de la tranche, nous devons créer une nouvelle et plus grande tranche des fragments originaux du contenu est copié.

Le code suivant décrit la copie de la tranche et la méthode de copie pour ajouter un nouvel élément à ajouter la méthode de tranche.

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

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

La sortie est le code ci-dessus est exécuté:

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]