Concaténer deux tranches en Go

1. Déclaration de la tranche
2. Concaténation des tranches
3. Fonctionnement de la fonction append()

Dans le Go, une tranche est la structure de données dynamique qui stocke plusieurs éléments du même type de données. On peut aussi les considérer comme des tableaux à taille variable qui ont une indexation dès le tableau mais leur taille n’est pas fixe car ils peuvent être redimensionnés. Comme les tranches sont de nature dynamique, nous pouvons ajouter un nouvel élément à la tranche ou concaténer deux tranches ou plus en utilisant la fonction append.

Déclaration de la tranche

La déclaration des tranches est similaire à celle des tableaux, mais la taille n’est pas spécifiée.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

Production:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Concaténation des tranches

Nous utilisons la fonction intégrée append() pour ajouter des éléments à la liste ou concaténer deux ou plusieurs tranches ensemble. Si la capacité est suffisante, la destination est redécoupée pour accueillir les nouveaux éléments. Si la capacité n’est pas suffisante, un nouveau sous-jacent est attribué et le contenu est copié. Enfin, la fonction append() retourne la tranche mise à jour.

Ajouter un seul élément à la tranche

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

Production:

slice_1: [1 2]
slice_2: [1 2 3]

Ajouter plusieurs éléments à une tranche

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

Production:

slice_3: [1 2 3 4 5 6]

Concaténer deux tranches

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

Production:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

Un point important à noter lors de la concaténation de deux tranches dans un go est que ... est essentiel après slice_4 car append() est une fonction variadique, tout comme les autres fonctions variadiques. ... vous permet de passer plusieurs arguments à une fonction à partir d’une tranche. Ici, la fonction append est appelée récursivement pour chaque élément de la slice_4.

Ajouter une chaîne de caractères à une tranche d’octet

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

Production:

slice: [97 98 99 32 100 101 102]

Ici, les caractères sont encodés en UTF-8 en utilisant 3 octets qui représentent la valeur ASCII des caractères. L’octet de tranche peut être reconverti en chaîne de caractères comme:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

Production:

Slice: abc def

Fonctionnement de la fonction append()

La fonction intégrée append() prend une tranche, ajoute tous les éléments à la fin d’une tranche d’entrée et retourne finalement la tranche concaténée. Si la tranche de destination a une capacité suffisante, la tranche est redécoupée pour accueillir les nouveaux éléments ajoutés. Mais si la destination n’a pas une capacité suffisante, un nouveau tableau est créé et les éléments présents dans les tranches existantes sont copiés dans le nouveau tableau et enfin, un nouveau tableau est renvoyé par la fonction.

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

Production:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

Ici, slice_1 n’a pas la capacité suffisante pour ajouter un nouvel élément, donc une nouvelle tranche de capacité 6 est créée et tous les éléments présents dans les tranches existantes sont copiés dans la nouvelle tranche créée.

Cependant, slice_2 a une capacité suffisante pour ajouter de nouveaux éléments et donc les éléments sont ajoutés dans la tranche existante.