Comment vérifier que l'entrée est un horodatage Unix valide à l'aide de regex dans Golang

L'horodatage Unix, en tant que méthode courante de représentation du temps, est également largement utilisé dans Golang. Dans le développement réel, nous devons souvent vérifier l'horodatage Unix saisi par l'utilisateur pour garantir l'exactitude et la sécurité du programme. Les expressions régulières, en tant qu'outil de vérification couramment utilisé, sont également très adaptées à la vérification des horodatages Unix. Cet article explique comment utiliser des expressions régulières dans Golang pour vérifier si l'entrée est un horodatage Unix valide.

La définition d'un horodatage Unix est simple, c'est le nombre de secondes qui se sont écoulées depuis le 1er janvier 1970 00:00:00 UTC. Les horodatages Unix sont généralement des entiers positifs ou négatifs. Les entiers positifs représentent le nombre de secondes depuis 1970 et les entiers négatifs représentent le nombre de secondes avant 1970.

Tout d'abord, nous devons comprendre comment utiliser les expressions régulières dans Golang. Le package Regexp est fourni dans Golang, qui implémente des fonctions d'analyse et de correspondance d'expressions régulières. Nous pouvons utiliser les fonctions fournies par ce package, telles que Compile(), MatchString(), FindString(), etc., pour effectuer des opérations sur les expressions régulières.

Dans Golang, nous pouvons utiliser l'expression régulière suivante pour vérifier les horodatages Unix :

^(-?[1-9]d{0,9}|0)$

Cette expression régulière peut correspondre à des entiers signés 32 bits, c'est-à-dire à tous les entiers, y compris les entiers positifs, les entiers négatifs et 0. Parmi eux, "^" représente le début de la chaîne et "$" représente la fin de la chaîne. "?" signifie que le caractère précédent peut apparaître 0 ou 1 fois, "d" représente un caractère numérique, "{0,9}" signifie que le caractère précédent peut apparaître 0 à 9 fois, "|" représente ou.

Voici un exemple de code :

package main

import (
    "fmt"
    "regexp"
)

func main() {

    re := regexp.MustCompile(`^(-?[1-9]d{0,9}|0)$`) // 编译正则表达式

    input := "1629755400" // 需要判断的 Unix 时间戳

    if !re.MatchString(input) {
        fmt.Println("输入不是有效的 Unix 时间戳")
    } else {
        fmt.Println("输入是有效的 Unix 时间戳")
    }
}

Dans cet exemple de code, nous stockons d'abord l'horodatage Unix qui doit être vérifié dans la variable d'entrée. Ensuite, nous utilisons la fonction Regexp.MustCompile() pour compiler l'expression régulière "^(-?[1-9]d{0,9}|0)$" dans un objet d'expression régulière re.

Enfin, nous utilisons la fonction MatchString() pour faire correspondre l'entrée. Si l'expression régulière ne correspond pas, affichez "L'entrée n'est pas un horodatage Unix valide", sinon affichez "L'entrée est un horodatage Unix valide".

Il convient de noter que l'utilisation d'expressions régulières pour la vérification ne peut déterminer que si le format d'entrée est correct, mais elle ne peut pas garantir si l'horodatage d'entrée est raisonnable pour l'entreprise. Par conséquent, dans le développement réel, une vérification et une vérification supplémentaires de l'horodatage sont nécessaires. traitement pour garantir l’exactitude et la sécurité de l’entreprise.

Grâce à l'introduction de cet article, je pense que les lecteurs ont appris à utiliser des expressions régulières dans Golang pour vérifier s'il s'agit d'un horodatage Unix valide. Les expressions régulières sont un outil très puissant. Maîtriser l'utilisation des expressions régulières peut grandement améliorer l'efficacité et la fiabilité du programme.

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!