Cordes de Golang

Une chaîne fait référence à une séquence d'un ou plusieurs caractères, y compris des lettres, des chiffres et des caractères spéciaux. Les cordes sont un concept essentiel dans la plupart des langages de programmation malgré la définition simpliste.

En effet, les chaînes nous aident à travailler avec des informations textuelles dans nos programmes. En règle générale, il est difficile de créer une application non triviale sans utiliser de chaînes.

Dans ce guide, nous couvrirons les bases du travail avec des chaînes dans le langage de programmation Go.

Qu'est-ce qu'une chaîne?

En Go, nous appelons une chaîne comme une tranche d'octets en lecture seule. Nous pouvons créer une chaîne dans GO en entourant la séquence de caractères à l'intérieur des doubles citations ou des citations arrière.

Gardez à l'esprit que la méthode que vous utilisez pour créer une chaîne dans Go compte.

Utiliser les tiques de retour («) pour créer une chaîne en go crée un littéral de chaîne brute. Un littéral de chaîne brute signifie que la chaîne peut contenir n'importe quel caractère à l'exception d'une tique de dos.

L'exemple suivant montre un littéral de chaîne brute.

RAW_STRING: = 'Ceci est une chaîne'

Contrairement aux littéraux de chaîne interprétés créés à l'aide de citations doubles, les caractères de contrecoup n'ont pas de dénotation spéciale à l'intérieur d'un littéral de chaîne brute. Par exemple, \ n, qui peut insérer un personnage de Newline dans les chaînes interprétées, nous l'imprimons comme dans les littéraux de cordes brutes.

Pour créer une chaîne littérale interprétée dans Go, enferme l'ensemble des caractères dans les doubles-quotes, comme indiqué dans l'exemple ci-dessous:

interprété_string: = "Ceci est une chaîne"

Ici, les personnages de contrecoups sont interprétés comme ayant une signification particulière. Par exemple, pour insérer une nouvelle ligne dans la chaîne, nous pouvons utiliser \ n comme:

interprété_string: = "Ceci est \ n une chaîne"

Il est courant d'utiliser la chaîne littérale interprétée car ils vous permettent d'ajouter des caractères spéciaux et d'échapper aux séquences.

Aller, imprimer la chaîne

Vous pouvez imprimer une chaîne en Go en utilisant la méthode println () du package FMT. Assurez-vous d'importer le package avant d'appeler la méthode. Un exemple de code est comme indiqué:

package principal
Importer "FMT"
func main ()
fmt.Println ("Ceci est une chaîne")

Le code ci-dessus utilise le FMT.Méthode println () pour imprimer une chaîne interprétée littérale. Vous pouvez également stocker une chaîne en tant que variable et la référencer dans la méthode comme indiqué:

package principal
Importer "FMT"
func main ()
my_string: = "Ceci est une chaîne"
fmt.Println (my_string)

Opérations de cordes en Go

Il existe une collection d'opérations que vous pouvez effectuer sur des types de chaînes. Go fournit un ensemble de méthodes pour effectuer des opérations de chaîne dans le package des chaînes.

https: // pkg.aller.Dev / Strings

Laissez-nous regarder quelques opérations que vous pouvez effectuer sur les chaînes.

Concaténation des cordes

La concaténation des cordes fait référence à la technique de combinaison de deux ou plusieurs littéraux de cordes pour créer une nouvelle chaîne.

En Go, nous pouvons concaténer les chaînes en utilisant l'opérateur d'addition (+).

Par exemple, combinons les cordes «Linux» et «indice» comme indiqué.

package principal
Importer "FMT"
func main ()
fmt.Println ("linux" + "indice")

Si nous exécutons le code ci-dessus, nous devons obtenir une sortie comme:

$ va exécuter golang_strings.aller
linuxhint

Gardez à l'esprit que vous ne pouvez pas utiliser l'opérateur d'addition (+) avec des valeurs de différents types. Par exemple, si vous essayez de concaténer une chaîne et un int, vous obtiendrez une erreur comme:

fmt.Println ("Linux" + 12)

Le code ci-dessus renvoie une erreur comme:

Fonctionnement non valide: "Linux" + 12 (Types dépareillés String non typés et intratisé INT)

Un moyen de surmonter cela consiste à enfermer les deux valeurs en doubles. Cela convertit la valeur numérique en une chaîne, vous permettant d'effectuer une concaténation de chaîne.

La concaténation des cordes se traduit toujours par une nouvelle chaîne que vous pouvez stocker dans une variable et réutiliser dans d'autres parties de votre programme.

Convertir la corde en minuscules ou en majuscules

Comme mentionné, GO nous fournit le package des chaînes, qui vous permet d'effectuer des opérations sur les types de chaînes.

Deux méthodes utiles de l'emballage sont Tolower et Toupper, qui convertissent une chaîne en minuscules et en majuscules, respectivement.

Remarque: En Go, les types de chaînes sont immuables. Cela signifie que vous ne pouvez pas modifier la valeur d'origine de la chaîne une fois créée.

L'exemple ci-dessous convertit la chaîne «Linuxhint» en minuscules.

package principal
Importer "FMT"
Importer des "chaînes"
func main ()
my_string: = "Linuxhint"
fmt.Println (cordes.Tolower (my_string))

La fonction Tolower () prend la chaîne pour se convertir en minuscules comme argument. Il renvoie ensuite la séquence des caractères de la chaîne convertie en minuscules. La fonction renvoie une nouvelle chaîne, car les chaînes sont des types de données immuables.

Si nous exécutons le code ci-dessus, nous devons obtenir une sortie comme:

linuxhint

Pour convertir une chaîne en majuscules, nous pouvons utiliser la méthode Toupper (), comme indiqué dans l'exemple ci-dessous:

my_string: = "Linuxhint"
fmt.Println (cordes.Toupper (my_string))

La chaîne résultante est comme indiqué:

Linuxhint

Obtenir la longueur de la chaîne

Pour obtenir la longueur d'une chaîne en Go, vous pouvez utiliser la méthode Len () et passer la chaîne comme argument.

La méthode renverra le nombre de caractères dans la chaîne.

Par exemple:

my_string: = "Linuxhint"
fmt.Println (len (my_string))

Une fois que nous exécutons le code ci-dessus, nous devons obtenir le nombre de caractères de la chaîne comme:

$ va exécuter golang_strings.aller
9

Le nombre de caractères, dans ce cas, fait référence à tout caractère enfermé en doubles citations, y compris des symboles et d'autres caractères spéciaux.

Vérifiez si la chaîne contient

Vous pouvez également rechercher une sous-chaîne dans GO en utilisant la méthode contient. La méthode accepte la chaîne principale dans laquelle rechercher la sous-chaîne et la sous-chaîne pour rechercher et comme arguments.

La fonction renvoie alors une valeur booléenne si la sous-chaîne est trouvée et fausse autrement.

Considérez l'exemple ci-dessous:

package principal
importer (
"FMT"
"Strings"
)
func main ()
full_string: = "Bienvenue à la programmation Go Langugae!"
fmt.Println (cordes.Contient (full_string, "go"))

Une fois que nous exécutons le code ci-dessus, nous devrions obtenir une sortie comme:

$ va exécuter golang_strings.aller
vrai

Le substring «go» se trouve dans la variable full_string; la fonction renvoie true.

Conclusion

Ce tutoriel couvre les bases de travailler avec des cordes dans Go. Si vous commencez à aller, consultez nos tutoriels sur le sujet pour en savoir plus. Vous pouvez également consulter la documentation des informations supplémentaires.