wikinotes

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
{{tag>dev go golang}}


Notes et transcriptions du cours "[[https://www.coursera.org/learn/golang-getting-started/home/welcome|Démarrer avec Go]]" proposée par 
[[https://uci.edu/|University of California, Irvine]] disponible sur la plateforme [[https://www.coursera.org/|coursera]].

====== Allocation dynamique de tranche ======


La fonction ''make()'' peut être utilisée pour créer (entre autre) des tranches (slice).

La première façon de créer une slice, nous en avons parlé consiste à créer le tableau sous-jacent puis à créer la slice.

<code go>
// Déclaration d'un tableau de 5 entiers, definition implicite 
// à la valeur par défaut du type int (0)
var arr [5]int

// Déclaration de la slice à partir du tableau arr
var sli1 = arr[2:]
</code>

Une deuxième possibilité consiste à initialiser la tranche directement avec une définition de slice littérale.

<code go>
// Définition littérale de slice
var sli2 = []int {1, 2, 3, 4, 5}
</code>

L'utilisation de ''make()'' est la troisième méthode : vous créez la tranche mais vous n'initialisez pas avec des valeurs particulières (la valeur par défaut du type sera utilisée).

C'est un usage courant : vous souhaitez initialiser une slice à une taille particulière et vous avez besoin d'utiliser sa capacité à changer de taille.

Pour cela on peut appeler la fonction ''make''. Il y a deux manières de l'appeler : avec deux ou trois arguments.

Si vous appelez ''make()'' avec deux arguments, le premier argument est le type d'objets qui vont se trouver à l'intérieur de la tranche (string, int, etc). Le second argument est la longueur de la tranche.

Lorsque vous utilisez ''make()'' pour créer une tranche, la longueur et la capacité sont identiques car le tableau sous-jacent a exactement la même taille que la tranche. La longueur et la capacité sont donc les mêmes.

<code go>
sli := make( []int, 10)
</code>

Dans l'exemple ci dessus le premier argument permet de spécifier le type ''[]int'', puis le nombre d'éléments souhaités ici 10. Donc. La longueur et la capacité sont identiques : le tableau sous-jacent à la même taille que la tranche, et la tranche pointe vers le premier élément du tableau sous-jacent.

Dans la version à trois arguments de ''make()'', vous spécifiez la longueur et la capacité séparément. Cela signifie que le tableau sous-jacent est en fait plus grand que la tranche.

<code go>
var sli = make( []int, 10, 15 )
</code>

Dans l'exemple ci-dessus, le premier argument fournit le type. Le deuxième indique la longueur de la tranche. Le troisième argument est la capacité, c'est-à-dire la taille du tableau. Donc, dans ce cas, notre tranche est de taille 10, mais le tableau est de taille 15, nous pouvons donc augmenter la tranche jusqu'à la taille 15 si nous le voulons.

===== La fonction append() =====

Il existe donc une fonction ''append()'' qui peut être utilisée avec des tranches, et elle est utilisée pour augmenter la taille d'une tranche.

Si vous souhaitez ajouter des éléments à la fin d'une tranche et augmenter ainsi la taille de la tranche, utilisez la fonction ''append()''.

Notez maintenant qu'il s'agit d'un avantage clé par rapport aux tableaux classiques présents dans d’autres langages : vous ne pouvez pas simplement ajouter des éléments à la fin d'un tableau et augmenter continuellement sa taille, mais vous pouvez le faire avec la slice.

Cette fonction permet d' ajouter un ou plusieurs éléments. Dans l'exemple ci-dessous, nous allons n' en ajouter qu'un mais elle ajoute l'élément à la fin de la tranche. Cela signifie qu'elle l'insère dans le tableau sous-jacent, et augmente la tranche jusqu'à la capacité du tableau sous-jacent. La fonction ''append()'' augmentera la taille du tableau si nécessaire. 

Ainsi, si vous atteignez les limites de la taille du tableau sous-jacent, elle créera un nouveau tableau sous-jacent plus grand. Ainsi, les appels à ''append()'' ne cessent jamais d'ajouter. Vous pouvez ajouter des éléments en permanence même au-delà de la taille du tableau, et cela augmentera simplement la taille du tableau ( même si ce n'est pas souhaitable car il y a une pénalité de temps pour cela).

<code go hello_make_sli.go>
package main

import "fmt"


func main(){
   var sli = make( []int, 0, 3)
   fmt.Println( sli )

   sli = append( sli, 100 )
   fmt.Println( sli )
}
</code>

Ci-dessus nous créons une tranche, ''sli'', via l'appel à ''make()''. La longueur de la tranche est nulle, mais la longueur du tableau sous-jacent est de 3 éléments.

La tranche est vide, sa taille est nulle. La fonction ''append()'' permet d'ajouter l'entier 100 à la tranche. En premier argument, on passe le nom de la tranche, et en deuxième argument la valeur à ajouter ici 100.

[[315_slice|◁ Précédent]] |
[[000_start|⌂ Retour au sommaire ]] |
[[325_hash_table|Suivant ▷ ]]
wikinotes

Outils pour utilisateurs

Outils du site

Outils de la page
