Comment concaténer efficacement des chaînes dans Go

1. Avec l’opérateur plus (+)
2. Avec les arguments multiples de la fonction Print()
3. Avec la fonction Join()
4. Méthode Sprintf()
5. Méthode bytes.Buffer
6. méthode strings.Builder
7. Ajouter avec += Opérateur
8. Comparaison des différentes méthodes

L’acte de fusion de deux ou plusieurs chaînes en une seule nouvelle chaînes est appelé concaténation de chaînes. La concaténation de chaînes est l’une des opérations les plus répandues en programmation. Dans cet article, nous allons discuter des différentes méthodes de concaténation de chaînes dans le langage de programmation Go avec leurs avantages et leurs inconvénients.

Avec l’opérateur plus (+)

L’utilisation de + est la méthode la plus simple et la plus utilisée pour la concaténation de chaînes. Parfois, l’opérateur + est également appelé opérateur de concaténation.

package main

import "fmt"

func main() {

    str_1 := "Welcome to "
    str_2 := "the Blog!!"
    fmt.Println("str_1: ", str_1)
    fmt.Println("str_2: ", str_2)
    fmt.Println("Combined String: ", str_1+str_2)
}

Production:

str_1:  Welcome to
str_2:  the Blog!!
Combined String:  Welcome to the Blog!!

Avec les arguments multiples de la fonction Print()

Nous pouvons passer plusieurs chaînes de caractères en argument à la fonction Print() dans Go. Les chaînes sont automatiquement concaténées en ajoutant un espace blanc entre les chaînes.

package main

import "fmt"

func main() {

    fmt.Println("String", "Concatenation!!")
}      

Production:

String Concatenation!!

Avec la fonction Join()

Nous pouvons également concaténer des chaînes de caractères en utilisant la fonction join() présente dans le paquet de chaînes qui prend une tranche de chaînes et un séparateur pour les joindre en produisant une seule chaîne.

Syntaxe:

func Join(str []string, sep string) string

str est la tranche de chaîne à partir de laquelle nous concaténons les éléments et sep est le séparateur placé entre les tranches.

   package main

import (
    "fmt"
    "strings" //for join() function
)

func main() {

    str_slices := []string{"This", "is",
        "String", "Concatenation!!"}

    str_concat := strings.Join(str_slices, "-")
    fmt.Println(str_concat)
}
  

Production:

This-is-String-Concatenation!!

Méthode Sprintf()

L’utilisation de la méthode Sprintf() dans le paquet fmt est également l’une des méthodes les plus simples pour la concaténation de chaînes.

package main

import "fmt"

func main() {
    str_1 := "We will"
    str_2 := " Rock"
    str_3 := " You!!"

    str_final := fmt.Sprintf("%s%s%s", str_1, str_2, str_3)

    fmt.Println(str_final)
} 

Production:

We will Rock You!!

Méthode bytes.Buffer

Un moyen efficace de concaténer des chaînes de caractères sans générer l’objet string inutile est la méthode byte.buffer. Nous pouvons écrire des chaînes dans un tampon d’octets en utilisant la méthode WriteString() et la transformer ensuite en chaîne de caractères.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var byte_buf bytes.Buffer

    byte_buf.WriteString("Hello ")
    byte_buf.WriteString("World!!")

    fmt.Println(byte_buf.String())
}

Production:

Hello World!!

méthode strings.Builder

Cette méthode permet une concaténation efficace des chaînes en utilisant très peu de mémoire par rapport aux autres.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str_build strings.Builder
    str_build.WriteString("Hello ")
    str_build.WriteString("World!!")
    fmt.Println(str_build.String())
}

Production:

Hello World!!

Ajouter avec += Opérateur

Elle est similaire à la concaténation de chaînes de caractères utilisant l’opérateur plus, mais légèrement plus courte que la précédente. L’opérateur += ajoute une nouvelle chaîne à droite de la chaîne spécifiée.

package main

import "fmt"

func main() {
    str_1 := "Hello "

    str_1 += "World!!"
    fmt.Println("Final String:", str_1)

}

Production:

Final String: Hello World!!

Comparaison des différentes méthodes

Les méthodes bytes.Buffer et strings.Builder sont beaucoup plus rapides que les autres méthodes de concaténation de chaînes de caractères. Par conséquent, lorsque nous devons effectuer une concaténation de chaînes de caractères en grande quantité, nous préférons les méthodes bytes.Buffer et strings.Builder. Cependant, lorsque le nombre de concaténations est faible, nous pouvons utiliser les opérateurs + ou +=.