Comment vérifier le format de date à l'aide d'une expression régulière dans Golang

En Golang, les expressions régulières sont un outil très puissant qui peut facilement vérifier des chaînes dans différents formats. Le format de date est également l’un des besoins de validation courants. Cet article explique comment utiliser des expressions régulières pour valider les formats de date courants.

En Golang, nous pouvons utiliser le package "regexp" pour effectuer des opérations d'expression régulière. Ce package fournit des fonctions et des types pour écrire et exécuter des expressions régulières.

Voici quelques formats de date courants et leurs expressions régulières correspondantes :

1. AAAA-MM-JJ

Ce format de date se compose d'une année à 4 chiffres, d'un mois à 2 chiffres et d'un jour à 2 chiffres, séparés par un symbole "-".

L'expression régulière correspondante est : ^d{4}-d{2}-d{2}$

où, ^ représente le début de la chaîne, d représente n'importe quel nombre, {4} représente le nombre répété 4 fois , - signifie correspondre au symbole "-" et $ signifie la fin de la chaîne.

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    date := "2022-12-30"
    re := regexp.MustCompile(`^d{4}-d{2}-d{2}$`)
    if re.MatchString(date) {
        fmt.Println("日期格式正确")
    } else {
        fmt.Println("日期格式不正确")
    }
}

2. MM/JJ/AAAA

Ce format de date se compose d'un mois à 2 chiffres, d'un jour à 2 chiffres et d'une année à 4 chiffres, séparés par un "/ " symbole.

L'expression régulière correspondante est : ^d{2}/d{2}/d{4}$

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    date := "12/30/2022"
    re := regexp.MustCompile(`^d{2}/d{2}/d{4}$`)
    if re.MatchString(date) {
        fmt.Println("日期格式正确")
    } else {
        fmt.Println("日期格式不正确")
    }
}

3. YYYY année MM mois JJ jour

Le format de date comprend de 4 chiffres Il se compose d'une année numérique, d'un mois à 2 chiffres et d'une date à 2 chiffres, séparés par trois caractères chinois : « année », « mois » et « jour ».

L'expression régulière correspondante est : ^d{4}yeard{2}monthd{2}day$

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    date := "2022年12月30日"
    re := regexp.MustCompile(`^d{4}年d{2}月d{2}日$`)
    if re.MatchString(date) {
        fmt.Println("日期格式正确")
    } else {
        fmt.Println("日期格式不正确")
    }
}

4. MM/DD/YY

Le format de date se compose de 2 chiffres Il se compose d'un mois numérique, d'un jour à 2 chiffres et d'une année à 2 chiffres, séparés par un symbole "/".

L'expression régulière correspondante est : ^d{2}/d{2}/d{2}$

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    date := "12/30/22"
    re := regexp.MustCompile(`^d{2}/d{2}/d{2}$`)
    if re.MatchString(date) {
        fmt.Println("日期格式正确")
    } else {
        fmt.Println("日期格式不正确")
    }
}

Ci-dessus sont quelques formats de date courants et les expressions régulières correspondantes. Nous pouvons écrire nos propres expressions régulières en fonction des besoins réels.

Résumé : Utiliser des expressions régulières pour vérifier le format de date est une compétence très basique et pratique, et elle ne fait pas exception dans le golang. Maîtriser l'utilisation des expressions régulières peut améliorer efficacement notre efficacité de développement et réduire les taux d'erreur de code.

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!