Golang Split String

La manipulation des cordes est l'une des tâches les plus fondamentales de tout langage de programmation. Vous pouvez extraire des chaînes, des chaînes de recherche, des chaînes de réorganisation et bien d'autres opérations en utilisant diverses techniques de manipulation de cordes.

Une telle tâche de manipulation de chaîne est le fractionnement des cordes. Lorsque vous avez une longue chaîne, à partir de l'entrée utilisateur, d'un fichier, d'une base de données ou de variables d'environnement, vous devrez peut-être vous séparer en morceaux plus petits et effectuer des opérations sur chaque. Un exemple serait de diviser une chaîne à partir d'un fichier séparé des virgules auprès des virgules en tant que délimiteur.

En utilisant ce guide, vous apprendrez divers divisions d'une chaîne dans le langage de programmation Go.

Cordes.Fonction Split ()

Go est un vaste langage de programmation qui vient avec de nombreux outils et fonctionnalités hors de la boîte. En utilisant le package Strings de la bibliothèque standard, nous pouvons utiliser la fonction Split () pour diviser une chaîne en fonction d'un délimiteur spécifique.

La syntaxe de la fonction est comme indiqué:

Func Split (STR, SEP String) [] String

La fonction prend la chaîne et le délimiteur comme arguments. Il renvoie ensuite une tranche des cordes, chaque élément de la tranche étant une sous-chaîne séparée par le délimiteur.

Prenons l'exemple ci-dessous:

package principal
importer (
"FMT"
"Strings"
func main ()
path_str: = "/ usr / local / sbin: / usr / local / bin: / usr / sbin: / usr / bin: / sbin: / bin: / usr / jeux: / usr / local / jeux:"
Chemin: = chaînes.Split (path_str, ":")
fmt.Println (chemin)

Dans l'exemple ci-dessus, nous avons une variable Path_Str qui contient la sortie de la variable d'environnement de chemin dans Linux.

Nous utilisons ensuite la méthode Split () pour séparer chaque valeur du chemin avec le délimiteur comme côlon (:)

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

[/ usr / local / sbin / usr / local / bin / usr / sbin / usr / bin / sbin / bin / usr / jeux / usr / local / jeux]

Une fois que nous avons la tranche de chaînes, nous pouvons utiliser la notation d'index pour accéder à chaque élément comme indiqué:

fmt.Println (chemin [0])

Ce qui précède doit renvoyer l'élément à l'index 0 comme indiqué dans la sortie ci-dessous:

/ usr / local / sbin

En raison de sa simplicité et de sa diversité, c'est probablement celle dont vous aurez besoin lorsque vous aurez besoin de diviser une chaîne en Go.

Cordes.Splitn ()

La méthode Splitn () du package des chaînes vous permet de séparer une chaîne en fonction du délimiteur spécifié. Cependant, contrairement à la méthode Split (), la méthode Splitn prend trois arguments, comme le montre la syntaxe ci-dessous:

Func SplitAftern (STR, SEP String, M int) [] String

La fonction Splitn () vous permet de spécifier la chaîne pour séparer, le délimiteur et le nombre de chaînes à inclure dans la tranche.

Si le nombre de sous-chaînes à inclure dans la tranche équivaut à 0, la fonction renvoie nil.

Considérez l'exemple ci-dessous:

package principal
importer (
"FMT"
"Strings"
)
func main ()
path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Chemin: = chaînes.Splitn (path_str, ",", 3)
fmt.Println (chemin)

Dans cet exemple, nous utilisons une chaîne séparée par des virgules. Nous utilisons ensuite la méthode Splitn () pour extraire la sous-chaîne en fonction de la virgule. Nous spécifions également le nombre d'éléments dans la tranche.

La sortie résultante est comme indiqué:

[Samsung Apple Microsoft, Amazon, Google]

Notez que la fonction inclut la chaîne après le nombre d'éléments comme une seule chaîne.

Cordes.Fractionnement

Le package des cordes est très diversifié. Il propose également la fonction SplitAfter (). Il fonctionne de manière similaire à la méthode Split () mais conserve les délimiteurs après chaque sous-chaîne dans la tranche.

Tournez votre attention vers le code ci-dessous:

package principal
importer (
"FMT"
"Strings"
)
func main ()
path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Chemin: = chaînes.Splitafter (path_str, ",")
fmt.Println (chemin)

L'exemple ci-dessus utilise la méthode Splitafter () pour diviser la chaîne en fonction de la virgule comme délimiteur. Nous préservons également le délimiteur après chaque élément comme indiqué dans la sortie ci-dessous:

[Samsung, Apple, Microsoft, Amazon, Google]

Cordes.SplitAftern ()

Tu l'as deviné. Cette fonction fonctionne de manière similaire aux chaînes.Méthode Splitn (). Cela vous permet de spécifier le numéro de la sous-chaîne à inclure dans la tranche.

Un exemple est indiqué ci-dessous:

package principal
importer (
"FMT"
"Strings"
)
func main ()
path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Chemin: = chaînes.Splitafter (path_str, ",")
fmt.Println (chemin)

La sortie résultante:

[Samsung, Apple, Microsoft, Amazon, Google]

Cordes.Des champs()

Les cordes.Fields () Méthode vous permet de diviser les chaînes par les espaces blancs disponibles. Contrairement à SplitAfter () et SplitAftern (), cette méthode n'inclut pas les espaces blancs dans la tranche.

Si vous ne vous souciez pas de quel blanc, c'est probablement la meilleure méthode pour vous.

Considérez un exemple comme indiqué:

package principal
importer (
"FMT"
"Strings"
)
func main ()
path_str: = "\ nsamsung \ t Apple \ v Microsoft \ r Amazon Google"
Chemin: = chaînes.Champs (path_str)
fmt.Println (chemin)

La fonction prend la chaîne et la divise dans tous les espaces disponibles disponibles.

Un exemple de sortie est comme indiqué:

[Samsung Apple Microsoft Amazon Google]

Conclusion

Les cordes sont incroyables dans le langage de programmation Go. Par conséquent, il s'agit de comprendre comment effectuer diverses actions sur eux, comme le montre ce guide.

Continuez à pratiquer et à coder heureux!