Golang Concat Strings
Dans ce guide, nous imploserons diverses méthodes pour effectuer une concaténation de cordes dans le langage de programmation Go.
Les bases
Commençons par les parties les plus élémentaires de tous. Comment créer une chaîne dans Go?
Nous pouvons créer une chaîne en entourant les caractères en double-quot.
Par exemple, le code ci-dessous crée une chaîne et le stocke à la variable Str.
str: = "Hello World"
L'utilisation de citations doubles crée un littéral de cordes interprété qui comprend des caractères spéciaux tels que les espaces blancs.
Pour créer une chaîne littérale, vous pouvez utiliser des back-ticks, comme indiqué dans l'exemple ci-dessous:
Str: = 'Hello World'
Une chaîne littérale en Go ne prend pas en charge l'utilisation de caractères spéciaux, y compris les séquences d'évasion.
Concaténation des cordes - l'opérateur d'addition
Si vous cherchez le moyen indolore et le plus simple de concaténer les cordes, vous opterez probablement pour l'opérateur plus (| +).
À l'aide de l'opérateur plus (+), vous pouvez combiner plusieurs chaînes sur une seule valeur de chaîne comme indiqué:
package principal
func main ()
str_1: = "Bienvenue à"
str_2: = "Linuxhint"
full_string: = str_1 + str_2
L'exemple ci-dessus utilise l'opérateur d'addition pour combiner deux chaînes. Nous pouvons alors stocker le résultat dans la variable.
Vous pouvez également effectuer une concaténation de cordes en utilisant l'une des méthodes d'impression du package FMT. Considérez l'exemple ci-dessous:
fmt.Println ("Bienvenue à" + "Linuxhint")
La fonction prend les deux littéraux de cordes et les combine en une seule chaîne.
Vous pouvez également passer deux chaînes ou plus à n'importe quelle méthode d'impression à partir du package FMT sans utiliser l'opérateur d'addition. Les fonctions combineront les cordes et ajouteront un espace entre eux.
Jetez un œil à l'exemple ci-dessous:
fmt.Println ("Bienvenue à", "Linuxhint.")
Cet exemple passe la chaîne pour concaténer sous forme de paramètres séparés par une virgule. La chaîne résultante est comme indiqué:
Bienvenue à Linuxhint.
Cordes.Méthode join ()
Nous pouvons également utiliser la méthode join () à partir du package Strings pour effectuer une concaténation de chaîne. La syntaxe de fonction est comme indiqué:
func join (a [] chaîne, chaîne de séparateur) chaîne
La fonction prend deux arguments. Le premier est une tranche de types de chaînes et le second est une chaîne décrivant le séparateur.
La fonction renvoie alors une seule chaîne concaténée à partir des valeurs de la tranche.
Pensez à l'exemple ci-dessous:
package principal
importer (
"FMT"
"Strings"
)
func main ()
str: = [] string "bienvenue", "à", "Linuxhint"
concat_str: = cordes.Rejoindre (str, "")
fmt.Println (concat_str)
La fonction prend les éléments de tranche de chaîne et les combine en une seule chaîne en utilisant un espace comme séparateur.
La valeur résultante est comme:
Bienvenue à Linuxhint
Formatage des chaînes - Sprintf
Nous pouvons également utiliser des modèles de formatage de chaînes fournis par les méthodes Sprintf, Sprint et Sprintln à partir du package FMT.
L'exemple suivant illustre comment effectuer la concaténation des chaînes à l'aide de la méthode sprintf ().
str_1: = "bonjour"
str_2: = "monde"
Concated_string: = FMT.Sprintf ("% s% s", str_1, str_2)
fmt.Println (Concated_string)
Ici, nous utilisons le format% s pour concaténer deux chaînes en utilisant la méthode sprintf ().
Byes.Méthode tampon ()
Golang contient un package d'octets qui fournit un type tampon, un tampon de taille variable d'octets avec des méthodes de lecture / écriture.
Nous pouvons écrire des chaînes en utilisant la méthode d'écriture, ce qui nous permet de les transformer en une chaîne.
Un exemple est comme indiqué:
package principal
importer (
"octets"
"FMT"
)
func main ()
str_1: = "bonjour"
str_2: = "monde"
var concat octets.Amortir
concat.WriteString (STR_1)
concat.WriteString (STR_2)
fmt.Println (Concat.Chaîne())
La méthode WriteString () ajoute la chaîne aux octets.type de tampon.
Cordes.Méthode Builder ()
L'ensemble des chaînes nous fournit également un type de générateur qui nous permet de construire des chaînes. Il a une méthode d'écriture similaire à celles fournies par le package des octets.
Considérez l'exemple:
package principal
importer (
"FMT"
"Strings"
)
func main ()
str_1: = "bonjour"
str_2: = "monde"
chaînes var concat.Constructeur
concat.WriteString (STR_1)
concat.WriteString (STR_2)
fmt.Println (Concat.Chaîne())
Résumé
Ce guide a couvert diverses techniques pour effectuer la concaténation des cordes dans Go. En utilisant l'opérateur plus, vous pouvez ajouter deux chaînes ou plus ensemble. Vous pouvez également opter pour d'autres méthodes, y compris la méthode de jointure, le sprintf, le tampon et plus.