Comment la suppression d'éléments dès le début d'une Go Slice affecte-t-elle sa capacité ?

Comprendre les changements de capacité des tranches dans Go

Lorsque vous travaillez avec des tranches Go, il est essentiel de comprendre leurs propriétés sous-jacentes, y compris leur capacité. Alors que la suppression des n derniers éléments d'une tranche maintient sa capacité, la suppression des n premiers éléments affecte la capacité.

La structure Go Slice

Les tranches Go sont implémentées sous forme de structures composé de trois champs :

<code class="go">type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}</code>

• array : pointeur vers le tableau sous-jacent soutenant la tranche.
• len : nombre d'éléments dans la tranche.
• cap : Capacité de la tranche, qui représente le nombre d'éléments qu'elle peut contenir.

Supprimer les n derniers éléments

Lorsque nous supprimons les n derniers éléments d'un slice, en utilisant l'expression s[:len(s)-n], nous créons une nouvelle tranche qui partage le même tableau sous-jacent que l'original. Cependant, la longueur de la nouvelle tranche est réduite, tandis que la capacité reste inchangée. En effet, le tableau sous-jacent a une capacité suffisante pour accueillir les éléments restants.

Suppression des n premiers éléments

D'un autre côté, lorsque nous supprimons les n premiers éléments de une tranche, en utilisant l'expression s[n:], nous créons non seulement une nouvelle tranche avec une longueur plus courte, mais nous allouons également un nouveau tableau sous-jacent. La capacité de la nouvelle tranche est ajustée pour accueillir le nombre réduit d'éléments.

Exemple

Considérez le code suivant :

<code class="go">func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    printSlice(s)

    // Drop its last two values
    s = s[:len(s)-2]
    printSlice(s)

    // Drop its first two values
    s = s[2:]
    printSlice(s)
}</code>

Le la sortie montre les changements de longueur, de capacité et du pointeur du tableau sous-jacent lorsque nous manipulons la tranche :

ptr=0x450000 len=6 cap=6 [2 3 5 7 11 13]
ptr=0x450000 len=4 cap=6 [2 3 5 7]
ptr=0x450008 len=2 cap=4 [5 7]

Conclusion

Comprendre la structure interne des tranches Go est crucial pour les manipuler efficacement. En reconnaissant que la suppression des n derniers éléments affecte la capacité différemment de la suppression des n premiers éléments, les développeurs peuvent optimiser leur code et éviter d'éventuels problèmes de performances liés au redimensionnement des tranches.

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!