Quelle est la capacité et la longueur d'une tranche en Go?

Quelle est la capacité et la longueur d'une tranche en Go?

En Go, une tranche est une structure de données flexible et puissante qui est construite sur un tableau. Il a deux propriétés clés: la longueur et la capacité.

• Longueur : la longueur d'une tranche est le nombre d'éléments qu'il contient. Il représente la taille de la tranche à laquelle vous pouvez accéder directement. Vous pouvez obtenir la longueur d'une tranche en utilisant la fonction len() .
• Capacité : La capacité d'une tranche est le nombre maximum d'éléments que la tranche peut contenir sans allouer une nouvelle mémoire. Il représente l'espace total alloué pour le tableau sous-jacent. Vous pouvez obtenir la capacité d'une tranche en utilisant la fonction cap() .

Voici un exemple simple démontrant l'utilisation de len() et cap() :

 <code class="go">package main import "fmt" func main() { s := make([]int, 5, 10) // Creates a slice with length 5 and capacity 10 fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Dans cet exemple, la tranche s a une longueur de 5 et une capacité de 10.

Comment puis-je modifier la capacité d'une tranche en Go?

La capacité d'une tranche en GO est immuable une fois qu'elle est créée. Vous ne pouvez pas modifier directement la capacité d'une tranche existante. Cependant, vous pouvez créer une nouvelle tranche avec une capacité différente en utilisant quelques méthodes:

1. En utilisant la fonction make : vous pouvez créer une nouvelle tranche avec une longueur et une capacité spécifiées.

    <code class="go">newSlice := make([]int, len(oldSlice), newCapacity) copy(newSlice, oldSlice)</code>

2. En utilisant la fonction append : lorsque vous ajoutez des éléments à une tranche, GO augmentera automatiquement la capacité si nécessaire.

    <code class="go">s := []int{1, 2, 3} s = append(s, 4, 5, 6) // This might increase the capacity if needed</code>

3. À l'aide de la fonction copy : vous pouvez copier le contenu de l'ancienne tranche en une nouvelle tranche avec une capacité différente.

    <code class="go">newSlice := make([]int, len(oldSlice), newCapacity) copy(newSlice, oldSlice)</code>

Voici un exemple pour illustrer ces méthodes:

 <code class="go">package main import "fmt" func main() { s := []int{1, 2, 3} // Length: 3, Capacity: 3 fmt.Printf("Original: Length: %d, Capacity: %d\n", len(s), cap(s)) // Using make and copy newSlice := make([]int, len(s), 10) copy(newSlice, s) fmt.Printf("After make and copy: Length: %d, Capacity: %d\n", len(newSlice), cap(newSlice)) // Using append s = append(s, 4, 5, 6, 7) fmt.Printf("After append: Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Que se passe-t-il lorsque j'essaie d'accéder à un index au-delà de la longueur d'une tranche en Go?

Dans Go, tenter d'accéder à un index au-delà de la longueur d'une tranche entraînera une panique d'exécution. En effet, la longueur de la tranche définit la gamme des indices auxquels vous pouvez accéder en toute sécurité.

Voici un exemple:

 <code class="go">package main import "fmt" func main() { s := []int{1, 2, 3} // Length: 3 fmt.Println(s[0]) // This is valid fmt.Println(s[3]) // This will cause a runtime panic }</code>

Le message d'erreur que vous verriez est quelque chose comme ceci:

 <code>panic: runtime error: index out of range [3] with length 3</code>

Cette panique se produit car l'indice 3 est en dehors des limites de la tranche, dont la longueur est 3.

Quelle est la différence entre la longueur et la capacité d'une tranche en Go?

La longueur et la capacité d'une tranche dans GO servent des objectifs différents et ont des rôles différents:

• Longueur : la longueur d'une tranche est le nombre d'éléments qu'il détient actuellement. Il détermine les indices valides de la tranche. Vous pouvez accéder aux éléments de la tranche jusqu'à len(s) - 1 , et tenter d'accéder à un index au-delà de cela entraînera une panique d'exécution.
• Capacité : La capacité d'une tranche est le nombre total d'éléments que le tableau sous-jacent peut contenir. Il définit la longueur de potentiel maximale que la tranche peut atteindre sans avoir besoin d'allouer une nouvelle mémoire. Vous pouvez augmenter la longueur de la tranche jusqu'à la capacité à l'aide de la fonction append sans déclencher la réallocation de la mémoire.

Voici un résumé de leurs différences:

• Longueur :

  • Définit le nombre actuel d'éléments dans la tranche.
  • Accessible via len(s) .
  • Détermine la gamme des indices valides.

• Capacité :

  • Définit le nombre maximum d'éléments que le tableau sous-jacent peut contenir.
  • Accessible via cap(s) .
  • Indique la croissance potentielle de la tranche sans réallocation de la mémoire.

Voici un exemple illustrant ces concepts:

 <code class="go">package main import "fmt" func main() { s := make([]int, 3, 5) // Length: 3, Capacity: 5 fmt.Printf("Initial: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 4) // Length: 4, Capacity: 5 fmt.Printf("After first append: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 5) // Length: 5, Capacity: 5 fmt.Printf("After second append: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 6) // Length: 6, Capacity might increase fmt.Printf("After third append: Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Dans cet exemple, la tranche commence par une longueur de 3 et une capacité de 5. Au fur et à mesure que nous ajoutons les éléments, la longueur augmente jusqu'à ce qu'elle atteigne la capacité. La capacité peut augmenter lorsque nous dépassons la capacité d'origine.

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!