Comment utiliser les chaînes.Remplacer la fonction dans Golang - Exemples

Les chaînes peuvent stocker de grandes données qui peuvent être utilisées plus tard dans le code. Quand il s'agit de manipuler les cordes à Golang, nous avons les cordes.Remplacer () Fonction. Avec cette fonction, nous pouvons facilement remplacer les sous-chaînes de chaque chaîne par d'autres sous-chaînes, sans avoir à manipuler manuellement la chaîne vous-même. Cet article couvre une description détaillée de cordes.Remplacer() à Golang.

Que sont les cordes.Remplacer () Fonction à Golang

Le langage de programmation Golang fournit les cordes.Remplacer () fonction, qui peut remplacer toutes les instances d'une sous-chaîne spécifique au sein d'une chaîne par une autre sous-chaîne.

Cette fonction prend quatre arguments:

Func Remplace (S, Old, nouvelle chaîne, n int) String

• S: est la chaîne d'origine sur laquelle vous souhaitez effectuer le remplacement.
• vieux: C'est la sous-chaîne qui doit être remplacée par la nouvelle.
• nouveau: La nouvelle sous-chaîne remplace l'ancienne substance.
• N: est le nombre maximum de remplacements à effectuer. Le code remplacera toutes les instances d'anciennes sous-chaînes par de nouvelles si n est inférieure à 0.

Comment utiliser les chaînes.Remplacer () dans Golang

Pour utiliser des chaînes.Remplacer () Dans Golang d'abord, nous devons définir une nouvelle chaîne à partir de laquelle nous voulons remplacer les caractères. Ensuite, nous devons passer le caractère que nous devons remplacer comme paramètre de cette fonction. Le code donné suivant utilisera les chaînes.Remplacer () fonction et remplacer toutes les occurrences d'une sous-chaîne dans une chaîne:

package principal
importer (
"FMT"
"Strings"
)
func main ()
str: = "Ceci est le tutoriel Golang sur Linuxhint"
fmt.Println ("String original:", str)
newstr: = cordes.Remplacer (str, "i", "x", -1)
fmt.Println ("String remplacé:", newstr)

Ce programme GO remplace toutes les occurrences de la lettre je dans la chaîne Str avec la lettre X en utilisant les cordes.Remplacer () Fonction. La chaîne modifiée est ensuite imprimée à la console en utilisant fmt.Println (). Le troisième paramètre des cordes.Remplacer () la fonction est définie sur -1, ce qui signifie que toutes les occurrences de la sous-chaîne spécifiée seront remplacées.

Remplacer uniquement la première occurrence d'un caractère en utilisant des chaînes.Remplacer () dans Golang

Maintenant, si nous voulons seulement remplacer la première occurrence d'une sous-chaîne, nous devons présenter un argument pour 1:

package principal
importer (
"FMT"
"Strings"
)
func main ()
str: = "Ceci est le tutoriel Golang sur Linuxhint"
fmt.Println ("String original:", str)
newstr: = cordes.Remplacer (str, "i", "x", 1)
fmt.Println ("String remplacé:", newstr)

Ici, dans ce code, la première occurrence de la lettre je dans la chaîne Str est remplacé par la lettre X en utilisant les cordes.Remplacer () Fonction. La chaîne modifiée est ensuite imprimée à la console en utilisant fmt.Println (). Le troisième paramètre des cordes.Remplacer () la fonction est définie sur 1, ce qui signifie que seule la première occurrence de la sous-chaîne spécifiée sera remplacée. Si nous définissons le quatrième paramètre de la fonction -1, alors toutes les occurrences seront remplacées.

Utilisation de cordes.RemplaceAll () à Golang

En plus des chaînes.Remplacer (), Golang fournit également un cordes.Remplace tout() fonction qui remplace toutes les instances d'une sous-chaîne dans une chaîne, sans avoir besoin de spécifier le nombre maximum de remplacements.

Par exemple, Ce qui suit est le code qui remplace toutes les occurrences de la lettre je avec la lettre X sans aucun besoin de spécifier le quatrième argument, qui est le nombre de remplacements à faire.

package principal
importer (
"FMT"
"Strings"
)
func main ()
str: = "Ceci est le tutoriel Golang sur Linuxhint"
fmt.Println ("String original:", str)
newstr: = cordes.Rempaceall (str, "i", "x")
fmt.Println ("String remplacé:", newstr)

Sortir

Après le remplacement, la chaîne modifiée est ensuite imprimée à la console en utilisant fmt.Println ().

Comment remplacer la sous-chaîne complète à l'aide de chaînes.Remplacer () Fonction à Golang

Nous allons maintenant examiner un code Golang qui remplace une sous-chaîne complète par une nouvelle sous-chaîne:

package principal
importer (
"FMT"
"Strings"
)
func main ()
S: = "Tutoriel Golang sur Linux"
Old: = "Linux"
Newstring: = "Linuxhint"
n: = 1
fmt.Println ("String original:", s)
TestResult: = chaînes.Remplacer (S, Old, Newsring, N)
fmt.Println ("Remplacer Linux par Linuxhint:", TestResult)

Ce programme GO remplace la première occurrence de la sous-chaîne Linux dans la chaîne s avec la sous-chaîne Linuxhint en utilisant les cordes.Remplacer la fonction (). La chaîne modifiée est ensuite imprimée à la console en utilisant fmt.Println (). Le troisième paramètre des cordes.La fonction remplace () est définie sur 1, ce qui signifie que seule la première occurrence de la sous-chaîne spécifiée sera remplacée.

Sortir

La sortie affichera la chaîne d'origine et la chaîne modifiée avec le remplacement appliqué.

Conclusion

Le cordes.Remplacer() La fonction peut manipuler des cordes à Golang en remplaçant le caractère souhaité par une nouvelle sous-chaîne. Les cordes.Remplacer () La fonction remplace toutes les instances de caractère ou remplace uniquement la première occurrence de caractère. De même, nous avons cordes.Remplace tout() remplace toutes les occurrences d'un personnage sans avoir besoin de spécifier le quatrième argument.