Utilisez des expressions régulières dans Golang pour vérifier si l'entrée est une chaîne légale en base64

Dans la programmation Golang, il est relativement courant d'utiliser des expressions régulières pour vérifier si l'entrée est une chaîne légale en base64. Pour les développeurs, les expressions régulières peuvent être utilisées pour vérifier rapidement et précisément que les entrées utilisateur sont correctes. Cet article explique comment utiliser les expressions régulières dans Golang pour vérifier si l'entrée est une chaîne légale en base64.

Commencez par la syntaxe de base

En Golang, l'utilisation d'expressions régulières nécessite l'utilisation de la bibliothèque "regexp". La bibliothèque propose deux fonctions principales "Compile" et "MatchString". La fonction « Compile » est utilisée pour compiler l'expression régulière en un objet d'expression régulière utilisable, et la fonction « MatchString » est utilisée pour vérifier si la chaîne peut correspondre à l'expression régulière.

Tout d'abord, nous devons définir une expression régulière pour les chaînes base64, par exemple :

var base64Pattern = regexp.MustCompile(`^[a-zA-Z0-9_-+/]+={0,3}$`)

Dans cette expression régulière, des jeux de caractères et des qualificatifs sont utilisés. Le jeu de caractères [a-zA-Z0-9_-+/] signifie qu'il ne peut contenir que des lettres majuscules, des lettres minuscules, des chiffres et les trois caractères spéciaux "_", "-", "+" et "/". Le qualificatif "=" signifie que le caractère peut apparaître 0 à 3 fois.

Ensuite, nous pouvons utiliser cette expression régulière pour vérifier si une chaîne est une chaîne légale en base64 :

input := "dGVzdA=="
if base64Pattern.MatchString(input) {
    fmt.Println("input is a valid base64 string")
} else {
    fmt.Println("input is not a valid base64 string")
}

Dans le code ci-dessus, nous passons une chaîne de test "dGVzdA==" à la fonction "MatchString", si la chaîne répond les exigences de l'expression régulière et est une chaîne base64 légale, alors "l'entrée est une chaîne base64 valide" est sortie.

Cependant, vous devez faire attention lors de l'écriture de l'expression régulière ci-dessus :

• la chaîne base64 ne peut contenir que des caractères dans le jeu de caractères et le caractère "=", sinon elle sera jugée illégale
• "==" ; doit apparaître dans le caractère La fin de la chaîne, et peut apparaître au maximum deux fois à la fois
• Si la longueur de la chaîne n'est pas un multiple de 4, le caractère "=" doit apparaître à la fin de la chaîne pour qu'elle soit peut être correctement analysé lors du codage des caractères.

Optimiser les expressions régulières

La vitesse de correspondance des expressions régulières ci-dessus peut répondre à la plupart des besoins, mais il peut y avoir des problèmes de performances dans certains cas particuliers. Nous pouvons améliorer la vitesse de correspondance en optimisant les expressions régulières.

Tout d'abord, nous pouvons déterminer si la chaîne est une chaîne légale en base64 selon les règles d'encodage de chaîne base64. Par exemple, si la longueur de la chaîne n’est pas un multiple de 4, la chaîne n’est certainement pas une chaîne légale en base64.

input := "dGVzdA==="
if len(input)%4 != 0 {
    fmt.Println("input is not a valid base64 string")
    return
}

Ensuite, nous pouvons utiliser le package "encoding/base64" de la bibliothèque standard pour décoder la chaîne. Si la chaîne peut être décodée avec succès, cela signifie qu’il s’agit d’une chaîne en base légale64.

if _, err := base64.StdEncoding.DecodeString(input); err == nil {
    fmt.Println("input is a valid base64 string")
} else {
    fmt.Println("input is not a valid base64 string")
}

Cette méthode est plus rapide que la correspondance d'expressions régulières et identifie correctement les chaînes base64 avec des caractères spéciaux. Cependant, il convient de noter que cette méthode présente également certaines limites : elle peut uniquement vérifier si la chaîne est une chaîne en base légale64, mais ne peut pas vérifier si la chaîne répond à nos attentes.

Résumé

Cet article présente l'utilisation d'expressions régulières dans la programmation Golang pour vérifier si l'entrée est une chaîne légale en base64. Nous avons d'abord présenté la syntaxe de base des expressions régulières et donné un exemple. Ensuite, nous avons optimisé l'expression régulière et introduit une méthode de vérification plus rapide. Enfin, les avantages et les inconvénients de ces deux méthodes sont résumés, dans l'espoir d'aider les lecteurs à mieux comprendre l'application des expressions régulières dans la programmation Golang.

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!