Golang compare la chaîne

En tant que programmeurs, nous rencontrons des cas où nous devons comparer les chaînes. Cela pourrait être que nous vérifions les entrées de l'utilisateur ou une tâche similaire. Quel que soit le besoin, il est important de savoir comment effectuer des comparaisons de cordes.

Tout au long de cet article, nous inspecterons différentes manières et méthodes pour effectuer des opérations de comparaison de chaînes dans le langage de programmation Go.

Méthode 1 - Opérateurs de comparaison

La forme la plus élémentaire de comparaison des chaînes est d'utiliser les opérateurs de comparaison GO. Voici quelques opérateurs de comparaison que vous pouvez utiliser:

1. == - Vérification de l'égalité
2. ! = - pas égal
3. > = - supérieur ou égal à
4. <= - less than or equal to

Regardons quelques exemples.

Opérateur d'égalité

L'opérateur d'égalité vous permet de vérifier si la valeur du côté gauche est égale à celle sur le côté droit.

Nous pouvons utiliser cet opérateur pour vérifier si une chaîne est égale à l'autre.

Un exemple est comme indiqué:

package principal
Importer "FMT"
func main ()
str_1: = "mysql"
str_2: = "sql"
fmt.Println (str_1 == str_2)

Dans l'exemple ci-dessus, nous vérifions si la valeur de la variable STR_1 est égale à la valeur de la variable STR_2.

Étant donné que les chaînes ne sont pas égales, le programme renvoie faux:

$ go run string_compare.aller
FAUX

Il est bon de se rappeler que l'opérateur d'égalité vérifie la sensibilité à la casse. Par exemple, la comparaison suivante renvoie False:

fmt.Println ("sql" == "SQL")

Si vous souhaitez effectuer une comparaison insensible au cas, vous pouvez d'abord convertir les chaînes en minuscules ou en majuscules (comme vous le voyez) ou utiliser la méthode intégrée (couverte plus tard).

L'exemple suivant montre comment convertir les chaînes en majuscules ou en minuscules:

fmt.Println (cordes.Tolower ("SQL") == "SQL")
fmt.Println (cordes.Toupper ("SQL") == "SQL")

Les comparaisons ci-dessus reviennent vrai car les deux chaînes sont égales.

Opérateur non égal

Vous pouvez également utiliser l'opérateur non égal (!=). Il fonctionne étroitement à l'opérateur d'égalité, sauf qu'il renvoie la version niée du résultat. Par conséquent, si deux chaînes sont égales, l'opérateur non égal revient faux.

Un exemple est comme indiqué:

package principal
Importer "FMT"
func main ()
str_1: = "mysql"
str_2: = "sql"
fmt.Println (str_1 != str_2)

Ici, les deux chaînes ne sont pas égales. Cela signifie que l'opérateur non égal renvoie vrai.

:: sortir
vrai

Opérateurs lexicographiques

Vous pouvez effectuer la comparaison lexicographique en utilisant plus que, moins, supérieure, supérieure ou égale à, et inférieure ou égale à. La comparaison lexicographique se compare si les chaînes sont de longueur égale et si les caractères sont dans une position similaire (par ordre alphabétique).

Considérez l'exemple de code ci-dessous:

package principal
Importer "FMT"
func main ()
fmt.Println ("ABCD"> "ABCD")
fmt.Println ("ABCD" = "ABCD")
fmt.Println ("DEFC" <= "abcd")

Le programme d'exemple ci-dessus effectue une comparaison lexicographique avec les chaînes spécifiées. La sortie résultante est comme indiqué:

FAUX
vrai
vrai
FAUX

Méthode 2 - Méthode compare ()

Le package Strings nous fournit une méthode intégrée pour effectuer une comparaison de chaînes. La méthode compare () prend deux chaînes sont ses arguments.

La fonction renvoie:

1. 0 Si les deux chaînes sont égales.
2. 1 Si la première chaîne est supérieure à la seconde.
3. -1 Si la première chaîne est inférieure à la seconde.

Remarque: La grandeur et la moindre ness des chaînes sont déterminées par une comparaison lexicographique.

L'exemple ci-dessous illustre comment utiliser la méthode compare ().

package principal
importer (
"FMT"
"Strings"
)
func main ()
str_1: = "bonjour"
str_2: = "hey"
fmt.Println (cordes.Comparer (str_1, str_2))

L'exemple ci-dessus renvoie -1.

Nous pouvons également passer des chaînes littérales à la méthode comme:

fmt.Println (cordes.Comparer ("hey", "hey"))
fmt.Println (cordes.Compare ("SQL", "SQL"))

Les extraits ci-dessus doivent renvoyer une sortie comme:

::sortir
0
-1

Méthode 3 - Méthode Equalfold ()

Comme vous le remarquerez à partir de l'exemple ci-dessus, la méthode compare () est sensible à la casse. Par conséquent, si deux cordes ne correspondent pas aux cas, il les considère pas égaux.

Cependant, nous pouvons vouloir effectuer une comparaison de chaînes sans effectuer de conversion en majuscules ou en minuscules.

Dans un tel cas, nous pouvons utiliser la méthode Equalfold (). Il fonctionne de manière similaire à la méthode compare () sans la sensibilité des cas.

Considérez l'exemple ci-dessous:

fmt.Println (cordes.Equalfold ("SQL", "SQL"))
vrai

La fonction renvoie un vrai booléen.

Conclusion

Ce guide vous emmène dans une visite de plusieurs méthodes pour effectuer une comparaison de cordes dans le langage de programmation Go.

Merci d'avoir lu!