Comment éviter les erreurs hors limites lors du découpage en Go ?

Slicing : erreur hors limites dans Go

Dans Go, le slicing est une opération puissante qui vous permet de créer une nouvelle tranche à partir d'un celui existant. Cependant, il est important de comprendre les pièges potentiels pour éviter les erreurs d'exécution.

Le problème

Le code suivant démontre une erreur hors limites lors du découpage d'un zéro- tranche de longueur :

package main

import "fmt"

func main() {
    a := make([]int, 5)
    printSlice("a", a)
    b := make([]int, 0, 5)
    printSlice("b", b)
    c := b[1:]
    printSlice("c", c)
}

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

Lors de son exécution, ce code produit un message hors limites erreur :

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
panic: runtime error: slice bounds out of range

goroutine 1 [running]:
main.main()
   /private/var/folders/q_/53gv6r4s0y5f50v9p26qhs3h00911v/T/compile117.go:10 +0x150

Comprendre l'erreur

Pour comprendre l'erreur, il est important de clarifier le concept de découpage en tranches. En Go, une tranche est une référence à une région contiguë de la mémoire. Lorsque vous créez une tranche découpée, vous créez une nouvelle référence à un sous-ensemble de la tranche d'origine.

Dans le cas du code ci-dessus, la tranche b a une longueur de 0 et une capacité de 5. Selon selon la spécification Go, "un index de tranche i fait référence au ième élément de la tranche dans son état actuel". Ainsi, tenter d'accéder à un élément à l'index 1 d'une tranche de longueur 0 est hors limites.

La solution

Pour éviter le hors- erreur de limites, assurez-vous que les indices utilisés lors du découpage se trouvent dans la plage valide pour la tranche d'origine. Pour les tranches, cette plage est déterminée par la longueur et la capacité de la tranche.

Par exemple, les opérations suivantes seraient valides :

• c := b[1:1] : Crée une tranche de longueur 0 et de capacité 4.
• c := b[1:2] : Crée une tranche de longueur 1 et de capacité 4.
• c := b[1:cap(b)] : Crée une tranche de longueur 4 et de capacité 4.

Conclusion

Slicing in Go est une opération fondamentale pour manipuler des données. Cependant, il est essentiel d’en comprendre les limites pour éviter les erreurs d’exécution. En vous assurant que les indices utilisés lors du découpage se situent dans la plage valide, vous pouvez efficacement éviter les erreurs hors limites et travailler avec les tranches en toute sécurité.

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!