Concaténation de slices en Go : 5 meilleures méthodes 2025

Concaténation de slices en Go : du débutant au pro en 2025

Les slices en Go sont des tableaux dynamiques qui sont au cœur de la plupart des applications Go. Tôt ou tard, chaque développeur est confronté à la question : « Comment fusionner deux slices en un seul ? ». Une opération apparemment triviale, mais, comme beaucoup de choses en Go, elle comporte ses pièges et ses nuances de performance.

Sur Stack Overflow, cette question a recueilli des milliers de vues, et ce n'est pas pour rien : une concaténation non optimale peut entraîner des allocations mémoire excessives et une réduction de la vitesse de l'application. Dans cet article, nous allons passer en revue toutes les méthodes légales pour assembler deux slices, du classique append aux nouveautés de la bibliothèque standard de 2025, et déterminer quelle méthode choisir en fonction de la situation.

Pourquoi la simple addition ne fonctionne-t-elle pas ?

Contrairement à Python (list1 + list2) ou JavaScript (arr1.concat(arr2)), Go ne supporte pas l'opérateur + pour les slices. Cela a été fait délibérément : Go est un langage qui exige de l'explicite. Chaque opération sur les slices doit être transparente, notamment en matière de gestion de la mémoire.

Allons droit au but. Voici la méthode la plus simple et la plus courante :

package main

import "fmt"

func main() {    slice1 := []int{1, 2, 3}    slice2 := []int{4, 5, 6}

    // Méthode n°1 : append avec dépaquetage    result := append(slice1, slice2...)    fmt.Println(result) // [1 2 3 4 5 6]}

Ce code fonctionne, mais il a une nuance. Si slice1 a une capacité (cap) suffisante, alors append le modifiera lui-même, au lieu de créer un nouveau slice. Cela peut entraîner des effets secondaires inattendus si vous ne vous attendiez pas à une mutation du slice d'origine.

Concaténation sécurisée avec make + copy

Si vous avez besoin d'une indépendance garantie du résultat par rapport aux slices d'origine, utilisez la combinaison make et copy. C'est le « gold standard » pour créer un nouveau slice sans risque de modifier l'original.

func concatSlices[T any](a, b []T) []T {    result := make([]T, len(a)+len(b))    copy(result, a)    copy(result[len(a):], b)    return result}

// Utilisation :combined := concatSlices(slice1, slice2)

Pourquoi est-ce bien ?

• Prévisibilité : Vous créez toujours un nouveau slice. Les données d'origine restent intactes.
• Contrôle : Vous allouez explicitement la mémoire une fois, sans dépendre de la logique interne de append.
• Generics (Go 1.18+) : La fonction fonctionne avec n'importe quel type de données.

Approche moderne : slices.Concat (Go 1.22+)

Depuis la version Go 1.22 (qui est déjà devenue la norme en 2025), la fonction Concat est apparue dans le paquet golang.org/x/exp/slices. Dans Go 1.22, elle a été déplacée dans la bibliothèque standard.

C'est la méthode officielle et recommandée pour la concaténation, qui combine la sécurité de copy et la concision de append.

import "slices"

func main() {    a := []string{"Go", "Python", "Rust"}    b := []string{"JavaScript", "TypeScript"}

    combined := slices.Concat(a, b)    // combined = ["Go", "Python", "Rust", "JavaScript", "TypeScript"]}

Avantages de slices.Concat :

• Lisibilité : Le nom parle de lui-même. Le code devient déclaratif.
• Optimisation : En interne, une allocation efficace et copy sont utilisés.
• Flexibilité : Vous pouvez passer n'importe quel nombre de slices : slices.Concat(s1, s2, s3, s4).

Si vous écrivez du code en Go 1.22+ (et en 2025, c'est le courant dominant), utilisez slices.Concat sans hésiter. C'est le meilleur choix pour 90% des tâches.

Quand append est-il encore nécessaire ?

Classique