Quelle est la longueur et la capacité des tranches de golang

En Golang, la longueur de la tranche est le nombre d'éléments dans la tranche ; la capacité de la tranche est le nombre d'éléments dans le tableau sous-jacent à partir de l'index où la tranche est créée, c'est-à-dire à partir du premier élément de la tranche. à la fin du numéro d'éléments du tableau sous-jacent. La longueur et la capacité d'une tranche peuvent être calculées. La méthode intégrée len() peut obtenir la longueur, et cap() peut obtenir la capacité lors de l'utilisation de la tranche, si append() est utilisé pour créer la tranche ; longueur de la tranche supérieure à la capacité de la tranche, alors la tranche La capacité sera automatiquement augmentée en doublant.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Les tranches de langue Go ont une longueur et une capacité.

• La longueur d'une tranche est le nombre d'éléments dans la tranche

• La capacité d'une tranche est le nombre d'éléments dans le tableau sous-jacent à partir de l'index auquel la tranche a été créée, c'est-à-dire en comptant à partir de son premier élément, à son sous-jacent Le nombre d'éléments à la fin du tableau.

Les tranches sont indexables et la longueur peut être obtenue par la méthode len(). Les tranches fournissent la méthode cap() pour calculer la capacité, qui peut mesurer la longueur de la tranche. Lorsque nous utilisons le découpage, si nous utilisons append pour rendre la longueur de la tranche supérieure à la capacité de la tranche, la capacité de la tranche sera automatiquement étendue au double de sa forme.

Le découpage obtient en fait une certaine partie du tableau, le résultat de len slice<=cap slice<=len array

cap() détermine les détails d'attention de l'interception de tranche

var sTest01 []int
func sliceTest01() {
	fmt.Printf("%T \n cap(sTest01) = %v \n", sTest01, cap(sTest01)) 
	sTest01 = append(sTest01, 1, 2, 3, 4, 5, 6)
	fmt.Printf("%T \n cap(sTest01) = %v \n", sTest01, cap(sTest01)) 
}

Le résultat de l'opération :

[]int 
 cap(sTest01) = 0 
[]int 
 cap(sTest01) = 6

par On peut voir qu'au début, la longueur de la tranche est de 0, et après avoir ajouté des éléments, la longueur réelle est de 6

Exemple prouvant que le tableau est un type valeur et la tranche est un type référence :

func sliceTest02() {
x := [...]int{1, 2, 3, 4, 5, 6}
y := []int{100, 200, 300, 400}
w := x
z := y
w[0] = 777
z[0] = 999
fmt.Println("x = ", x, "\nw = ", w)
fmt.Println("y = ", y, "\nz = ", z)
}

Résultat d'exécution :

x =  [1 2 3 4 5 6]
w =  [777 2 3 4 5 6]
y =  [999 200 300 400]
z =  [999 200 300 400]

From Comme le montrent les résultats d'exécution, le changement de z affecte la valeur de y, indiquant que la tranche est un type de référence.

slice n'a aucune donnée propre, c'est juste une référence au tableau sous-jacent. Toute modification apportée à la tranche sera reflétée dans le tableau sous-jacent. Les tableaux sont des types valeur, tandis que les tranches sont des types référence. Résultats d'exécution :

func sliceCap() {
arr := [...]string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"}
fmt.Println("cap(arr) = ", cap(arr), arr)

//截取数组，形成切片
s1 := arr[2:8]
fmt.Printf("%T \n", s1) 
fmt.Println("cap(s1) = ", cap(s1), s1)

//截取数组，形成切片
s2 := arr[4:7]
fmt.Printf("%T \n", s2)
fmt.Println("cap(s2) = ", cap(s2), s2) 

//截取数组，形成切片
s3 := s1[3:9]
fmt.Printf("%T \n", s3)
fmt.Println("cap(s3) = ", cap(s3), s3) 

//截取数组，形成切片
s4 := s2[4:7]
fmt.Printf("%T \n", s4)
fmt.Println("cap(s4) = ", cap(s4), s4) 

//证明切片是引用类型
s4[0] = "x"
fmt.Println(arr, s1, s2, s3, s4)
}

D'après les résultats, nous pouvons voir que l'interception de tranches ne peut générer que des tranches. Si le contenu n'est pas suffisant pour intercepter, les valeurs suivantes seront données à partir du tableau sous-jacent. Si la longueur n'est pas suffisante, une erreur sera signalée.

Pour déterminer si une tranche est vide, il est inexact d'utiliser directement nil.

Golang autorise les tranches où len est 0 mais cap n'est pas 0, ou les deux sont 0, donc la longueur de la tranche est généralement obtenue via len pour déterminer s'il s'agit d'une tranche vide, au lieu de comparer directement la tranche avec zéro.

【Recommandations associées :

Tutoriel vidéo Go

, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!