Comment utiliser des expressions régulières dans Golang pour vérifier si l'entrée est un code de pays ISO 3166-1 Alpha-2 valide

Dans Golang, les expressions régulières peuvent être utilisées pour vérifier facilement le format des valeurs d'entrée, notamment en vérifiant la validité des codes de pays ISO 3166-1 Alpha-2.

Le code pays ISO 3166-1 Alpha-2 est un codage standard défini dans la norme internationale ISO 3166. Il utilise deux lettres pour représenter le code unique de chaque pays/région. Par exemple, le code de la Chine est « CN », le code. car les États-Unis sont « US ». Pour vérifier que l'entrée est un code de pays ISO 3166-1 Alpha-2 valide, vous devez suivre certaines règles, notamment :

1. doit être composé de deux lettres majuscules
2. doit être des lettres latines
3. est sensible à la casse ; Pas de code en double.
4. En Golang, les codes de pays ISO 3166-1 Alpha-2 peuvent être vérifiés à l'aide d'expressions régulières. Une expression régulière simple est la suivante :

^[A-Z]{2}$

La signification de cette expression régulière est la suivante :

commence par ^ et se termine par $, ce qui signifie que la valeur entière d'entrée doit remplir cette condition ; 2} signifie qu'il doit être composé de deux. Il est composé de lettres majuscules (A-Z). Le 2 entre accolades indique que la longueur doit être de 2 caractères.

Ensuite, nous pouvons vérifier si la valeur d'entrée est conforme à l'expression régulière en utilisant la fonction fournie par le package regexp dans golang. L'exemple de code est le suivant :

2. package main
   
   import (
       "fmt"
       "regexp"
   )
   
   func main() {
       input := "CN"
   
       // 编译正则表达式
       regex := regexp.MustCompile("^[A-Z]{2}$")
   
       // 验证输入值是否符合正则表达式
       if !regex.MatchString(input) {
           fmt.Printf("%s不是一个有效的ISO 3166-1 Alpha-2国家/地区代码
   ", input)
       } else {
           fmt.Printf("%s是一个有效的ISO 3166-1 Alpha-2国家/地区代码
   ", input)
       }
   }

Dans ce code, nous définissons d'abord une valeur d'entrée. , et compilez l'expression régulière ^[A-Z]{2}$ en regex. Ensuite, nous utilisons la fonction regex.MatchString(input) pour vérifier si la valeur d'entrée correspond à l'expression régulière. S'il ne correspond pas, un message d'erreur est généré ; s'il correspond, un message de réussite est généré.

Lorsque vous utilisez des expressions régulières pour la vérification, vous devez également faire attention à certains cas particuliers, tels que :

regex.MatchString(input)函数来验证输入值是否符合正则表达式。如果不符合，输出一条错误信息；如果符合，输出一条成功信息。

在使用正则表达式进行验证时，还需要注意一些特殊情况，例如：

1. 忽略大小写：如果需要忽略大小写，可以使用(?i)在正则表达式开头进行设置，示例代码如下：

regex := regexp.MustCompile("(?i)^[a-z]{2}$")

这里的(?i)Ignorer la casse : si vous devez ignorer la casse, vous pouvez utiliser (?i) dans l'expression régulière définie au début, l'exemple de code est le suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    input := "CN"
    codes := []string{"CN", "US", "JP"} // 已有的ISO 3166-1 Alpha-2国家/地区代码

    // 判断输入值是否已存在
    for _, code := range codes {
        if input == code {
            fmt.Printf("%s是一个重复的ISO 3166-1 Alpha-2国家/地区代码
", input)
            return
        }
    }

    // 编译正则表达式
    regex := regexp.MustCompile("^[A-Z]{2}$")

    // 验证输入值是否符合正则表达式
    if !regex.MatchString(input) {
        fmt.Printf("%s不是一个有效的ISO 3166-1 Alpha-2国家/地区代码
", input)
    } else {
        fmt.Printf("%s是一个有效的ISO 3166-1 Alpha-2国家/地区代码
", input)
    }
}

2. (?i) signifie ici ignorer la casse.

Évitez les codes en double : les codes de pays ISO 3166-1 Alpha-2 n'autorisent pas les codes en double. Afin d'éviter la duplication de code, nous pouvons stocker le code existant dans un tableau ou une carte. Chaque fois que nous utilisons la vérification d'expression régulière, nous déterminons d'abord si la valeur d'entrée est dans le tableau ou la carte. Si elle existe, cela signifie qu'elle l'est. Il ne s'agit pas d'un code de pays ISO 3166-1 Alpha-2 valide. L'exemple de code est le suivant :

🎜rrreee🎜Dans cet exemple de code, nous définissons d'abord un tableau de codes de pays ISO 3166-1 Alpha-2 existants et utilisons une boucle pour parcourir chaque élément du tableau. Si la valeur d'entrée existe déjà dans le tableau, cela signifie qu'il ne s'agit pas d'un code de pays ISO 3166-1 Alpha-2 valide ; si la valeur d'entrée n'existe pas dans le tableau, continuez à utiliser des expressions régulières pour la validation. 🎜

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!