Golang String contient une sous-chaîne

Go vous fournit différentes façons de vérifier si une chaîne contient une sous-chaîne spécifique. En utilisant ce guide, vous apprendrez diverses méthodes et astuces pour rechercher une sous-chaîne à l'intérieur d'une chaîne.

Méthode 1 - La chaîne contient

La méthode la plus simple et la plus populaire pour vérifier si une chaîne contient une sous-chaîne consiste à utiliser la méthode contient () du package de chaînes.

La syntaxe de fonction est comme:

cordes.Contient (String, substring)

La fonction prend la chaîne principale et la sous-chaîne comme paramètres. Il renvoie un booléen vrai si la sous-chaîne est située à l'intérieur de la chaîne et false si autrement.

Considérez l'exemple ci-dessous:

package principal
Importer des "chaînes"
Importer "FMT"
funcmain ()
str: = "Hello World de Linuxhint"
fmt.Println (cordes.Contient (str, "Linuxhint"))

La méthode vérifiera si la variable STR contient la sous-chaîne spécifiée. Si la sous-chaîne est située à l'intérieur du STR, la fonction renvoie vrai et false si autrement.

Un exemple de sortie est comme indiqué:

$ Go Run Sous-chaîne.aller
vrai

Dans la plupart des cas, c'est la seule méthode dont vous aurez besoin pour vérifier une sous-chaîne dans Go.

Cependant, cela ne fait pas de mal de sélectionner des options pour divers cas d'utilisation. Regardons quelques exemples:

Méthode 2 - Contient

Vous pouvez également utiliser la méthode CONTAINALY () à partir du package Strings. Cette fonction vérifie si une chaîne contient un caractère Unicode spécifié.

Par exemple:

packagemain
importer (
"FMT"
"Strings"
)
funcmain ()
str: = "Bienvenue sur Linuxhint 🤗"
fmt.Println (cordes.Contient (str, "Linux"))
fmt.Println (cordes.Contient (str, ""))
fmt.Println (cordes.Contient (str, "🤗"))

L'exemple ci-dessus de la méthode CONTAINALY () pour vérifier les caractères Unicode correspondants dans une chaîne.

Un exemple de sortie est comme indiqué:

vrai
FAUX
vrai

Méthode 3 - Hasprefix & Hassuffix

Go nous fournit également deux méthodes, Hasprefix () et Hassuffix (), pour vérifier si une sous-chaîne est un préfixe ou un suffixe d'une autre chaîne, respectivement.

Par exemple, pour vérifier si une sous-chaîne est le préfixe d'une chaîne principale spécifique, nous pouvons faire:

str: = "Bienvenue sur Linuxhint 🤗"
fmt.Println (cordes.Hasprefix (str, "bienvenue"))

L'exemple ci-dessus renvoie vrai, car la sous-chaîne «bienvenue» est le préfixe de la variable STR.

Le même cas s'applique à la méthode Hassuffix (). Un exemple est comme indiqué ci-dessous:

str: = "Bienvenue sur Linuxhint 🤗"
fmt.Println (cordes.Hassuffix (Str, "Bienvenue"))

L'exemple ci-dessus renvoie false, car la chaîne «bienvenue» n'est pas le suffixe de la variable STR.

Méthode 4 - Index

Nous pouvons également utiliser la méthode d'index pour vérifier si une chaîne contient une sous-chaîne spécifique. La méthode d'index prend la chaîne principale et la sous-chaîne pour rechercher comme paramètres.

La fonction renverra alors l'index de la première instance de la sous-chaîne si elle se trouve dans la chaîne principale. Si la fonction ne trouve pas la sous-chaîne, elle renvoie un entier -1.

Considérez l'exemple ci-dessous:

str: = "Bienvenue sur Linuxhint 🤗"
fmt.Println (cordes.Index (str, "Linuxhint"))

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

$ Go Run Sous-chaîne.aller
11

La sortie ci-dessus montre l'indice de la première occurrence de la correspondance pour la sous-chaîne spécifiée.

Considérez l'exemple ci-dessous:

str: = "Bienvenue sur Linuxhint 🤗"
fmt.Println (cordes.Index (str, "No Match"))

Dans cet exemple, le code ci-dessus renvoie -1 car aucune correspondance pour la sous-chaîne n'est trouvée.

Conclusion

Ce guide a couvert diverses méthodes et techniques que vous pouvez utiliser pour rechercher si une chaîne contient une sous-chaîne.

Merci pour la lecture!