Utilisez des expressions régulières dans Golang pour vérifier si l'entrée est un code ISO 4217 valide

Avec le développement continu de la technologie informatique, de plus en plus de programmes affichent une tendance à l'échelle, à la modularisation et à la complexité, et les expressions régulières, en tant qu'outil puissant de traitement de texte, sont de plus en plus privilégiées par les programmeurs. En Golang, l'utilisation d'expressions régulières pour vérifier si l'entrée est un code ISO 4217 valide peut nous aider à identifier rapidement et avec précision les entrées illégales et à améliorer la sécurité et la stabilité du système.

Tout d’abord, qu’est-ce que le code ISO 4217 ? ISO 4217 est une norme internationale de code de devise développée par l'Organisation internationale de normalisation. Elle est utilisée pour identifier différentes devises. Chaque devise a une représentation de code unique à trois lettres. Par exemple, le code du dollar américain est USD, le code de l’euro est EUR et le code du RMB est CNY. Lors de l'écriture d'un programme, il est parfois nécessaire de valider l'entrée pour s'assurer que les données d'entrée sont dans le bon format, et la validation des codes ISO 4217 est l'une de ces exigences.

En Golang, les expressions régulières peuvent être utilisées pour vérifier les codes ISO 4217. Le code ISO 4217 se compose de trois lettres majuscules et peut être mis en correspondance à l'aide de l'expression régulière ^[A-Z]{3}$. Parmi eux, ^ signifie correspondre à la position de départ de la chaîne d'entrée, [A-Z] signifie correspondre à n'importe quelle lettre majuscule, {3} signifie correspondre trois fois consécutives et $ signifie correspondre à la position finale de la chaîne d'entrée. Par conséquent, vous pouvez utiliser le package regexp de golang pour implémenter la fonction de vérification des expressions régulières des codes ISO 4217.

Voici un exemple qui montre comment utiliser des expressions régulières pour vérifier le code ISO 4217 :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    var code string = "CNY"
    matched, _ := regexp.MatchString("^[A-Z]{3}$", code)
    if matched {
        fmt.Println(code, "is a valid ISO 4217 code")
    } else {
        fmt.Println(code, "is not a valid ISO 4217 code")
    }
}

Dans le code ci-dessus, une variable de chaîne de code est d'abord définie, représentant le code ISO 4217. Utilisez ensuite la méthode regexp.MatchString pour transmettre l'expression régulière "^[A-Z]{3}$" et la variable de code pour effectuer l'opération de correspondance. Si la correspondance réussit, true est renvoyé, indiquant que la chaîne d'entrée est un code ISO 4217 valide ; sinon, false est renvoyé, indiquant que la chaîne d'entrée n'est pas un code ISO 4217 valide. Enfin, en fonction des résultats de correspondance, les informations d'invite correspondantes sont affichées.

Il convient de noter que lorsque vous utilisez des expressions régulières, vous devez faire attention à la gestion des exceptions. Si une exception se produit, vous devez éviter de la lancer directement et plutôt la gérer de manière appropriée. Dans Golang, vous pouvez utiliser le mot-clé recovery pour intercepter les exceptions et éviter les plantages du programme dus à des exceptions. Voici un exemple modifié qui montre comment gérer les exceptions de manière appropriée :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    var code string = "CNY"
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("an error occurred:", r)
        }
    }()
    matched, err := regexp.MatchString("^[A-Z]{3}$", code)
    if err != nil {
        panic(err)
    }
    if matched {
        fmt.Println(code, "is a valid ISO 4217 code")
    } else {
        fmt.Println(code, "is not a valid ISO 4217 code")
    }
}

Dans le code ci-dessus, nous plaçons l'opération de correspondance dans un bloc d'instruction defer, de sorte que même si une exception se produit, elle peut être interceptée et traitée dans le contrôle. La station émet un message d'erreur. De plus, lorsque nous appelons la méthode MatchString du package regexp, une erreur peut être renvoyée. À ce stade, nous devons déterminer si une erreur s'est produite et la gérer en conséquence. Si une erreur se produit, une exception doit être levée à l'aide du mot-clé panic afin qu'elle puisse être gérée en externe.

En bref, l'utilisation d'expressions régulières pour vérifier les codes ISO 4217 peut nous aider à identifier rapidement et précisément les entrées illégales et à éviter certains problèmes de sécurité. Dans Golang, vous pouvez utiliser la méthode MatchString dans le package regexp pour implémenter la vérification des codes ISO 4217. Pendant l'utilisation, il convient de prêter attention à la gestion des exceptions pour éviter les plantages du programme dus à des exceptions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!