Golang – 5 façons différentes de comparer deux chaînes de caractères avec des explications

La logique des programmes dépend souvent de la comparaison des chaînes de caractères pour prendre une décision. En Go, les chaînes de caractères sont en réalité une séquence d’octets, et les comparer implique de comparer les octets individuels de la chaîne.

Quelle méthode choisir

• == et != : une comparaison simple entre de petites chaînes.
• strings.Compare() : la méthode recommandée pour comparer des chaînes sensibles à la casse.
• strings.EqualFold() : la méthode recommandée pour comparer des chaînes insensibles à la casse.
• strings.Contains() : comparer une sous-chaîne sensible à la casse.
• strings.Contains() avec ToLower() : comparer des sous-chaînes insensibles à la casse.

Comment utiliser == pour comparer des chaînes en Golang?

Vous pouvez vérifier si la chaîne est égale à une autre en utilisant l’opérateur ==.

package main

import (
    "fmt"
)

func main() {
    // Vérifier si la chaîne de recherche et le nom sont identiques
    name := "Apprendre Go"
    searchText := "Apprendre Go"

    if name == searchText {
        fmt.Println("Les chaînes sont identiques")
    }
}

Vous pouvez également utiliser != pour vérifier l’inégalité en Go.

package main

import (
    "fmt"
)

func main() {
    // Vérification de l'inégalité
    name := "Apprendre Go"
    searchText := "Tester"

    if name != searchText {
        fmt.Println("Les chaînes sont différentes")
    }
}

Comment comparer en utilisant le package strings en Golang?

Il existe une méthode Compare() dans le package strings qui peut être utilisée pour obtenir une valeur entière se trouvant dans les valeurs suivantes :

• Compare() renvoie 0 – les chaînes sont identiques.
• Compare() renvoie 1 – la première chaîne est plus grande.
• Compare() renvoie -1 – la première chaîne est plus petite.

Définition de la méthode

func Compare(a, b string) int

Doc officielle pour la méthode Contains()

Exemple

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Vérifier si la chaîne de recherche et le nom sont identiques
    name := "Apprendre Go"
    searchText := "Apprendre Go"

    if strings.Compare(name, searchText) == 0 {
        fmt.Println("Les chaînes sont identiques")
    }

    // Vérification de l'inégalité
    name = "Apprendre Go"
    searchText = "Tester"

    if strings.Compare(name, searchText) != 0 {
        fmt.Println("Les chaînes sont différentes")
    }
}

Comment comparer des chaînes insensibles à la casse en Go?

La méthode EqualFold() du package strings peut être utilisée pour comparer des chaînes insensibles à la casse. Cette méthode renvoie true si les chaînes sont égales, sinon elle renvoie false.

Définition de la méthode

func EqualFold(s, t string) bool

Doc officielle pour la méthode EqualFold()

Exemple

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Vérifier si la chaîne de recherche et le nom sont identiques
    name := "ApprenDre Go"
    searchText := "Apprendre Go"

    if strings.EqualFold(name, searchText) {
        fmt.Println("Les chaînes sont identiques")
    }
}

Comment comparer des sous-chaînes en Go?

Lorsque vous implémentez la logique de recherche et de filtrage dans votre programme Go, vous devez comparer le texte de recherche avec une recherche partielle dans votre base de données et renvoyer les résultats de l’opération.

Vous pouvez utiliser la méthode Contains() du package strings pour effectuer cette recherche partielle. Elle renvoie true si la sous-chaîne est présente dans l’autre chaîne, sinon elle renvoie false.

Définition de la méthode

func Contains(s, substr string) bool

Doc officielle pour la méthode Contains()

Exemple

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Vérifier si la chaîne de recherche est présente dans le nom
    name := "Apprendre Go"
    searchText := "Apprendre"

    if strings.Contains(name, searchText) {
        fmt.Println("La sous-chaîne est présente")
    }
}

Comment comparer des sous-chaînes insensibles à la casse en Go?

Vous pouvez utiliser la méthode Contains() en convertissant toutes les chaînes en minuscules pour obtenir une recherche de sous-chaîne insensible à la casse en Go.

Définition de la méthode

func ToLower(s string) string

Doc officielle pour la méthode ToLower()

Exemple

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Vérifier si la chaîne de recherche est présente dans le nom
    name := strings.ToLower("Apprendre Go")
    searchText := strings.ToLower("Apprendre")

    if strings.Contains(name, searchText) {
        fmt.Println("La sous-chaîne est présente")
    }
}