Validation des structures Go à l’aide de Govalidator

Les structures sont l’un des types de données principaux et couramment utilisés fournis dans le langage de programmation Go. De nombreux packages à travers diverses fonctionnalités, des packages de base de données aux ORM, et certains frameworks Web utilisent des structures pour faciliter l’analyse des données et d’autres opérations.

La validation de structure est une tâche courante dans Go, et le package de validation Go fournit un moyen simple et efficace de valider des structures dans vos projets.

Qu’est-ce que le package Go Validator

Le package Go validator implémente des validations de valeur pour les struct et les champs individuels en fonction des balises spécifiées sur la déclaration de struct.

Le package Go validator fournit des fonctionnalités de validation inter-champs et inter-structures à l’aide de balises, de tranches, de tableaux et de plongées cartographiques qui permettent des niveaux de validation de champs multidimensionnels, de validation de champs personnalisés, d’extraction de noms de champs personnalisés, de messages d’erreur personnalisables et prise en charge du framework Gin populaire en tant que validateur par défaut pour le package.

Exécutez l’une de ces commandes dans le terminal de votre répertoire de travail pour installer le package de validation .

go get gopkg.in/go-playground/validator.v9
go get github.com/go-playground/validator/v10


Les versions sont le suffixe de l’URL. La première commande installe la version 9 et la seconde installe la version 10 du package.

Après avoir installé le package, vous pouvez importer le package dans vos projets en fonction de la version que vous avez installée.

import (
    "gopkg.in/go-playground/validator.v9"
)


Vous pouvez maintenant continuer à utiliser le package Go validator. S’il y a des problèmes avec votre installation, essayez de réinstaller/mettre à niveau vers la dernière version de Go.

Validation des structures avec le package Validator

Vous devrez créer une instance de la structure validator.Validate , définir la structure que vous souhaitez valider à l’aide de balises de validation pour spécifier les règles de validation des champs.

Voici comment vous pouvez créer une instance de la structure validator.Validate .

func main() {
    validate: = validator.New()
}


Vous pouvez définir une structure que vous souhaitez valider en spécifiant des balises pour les champs, définissant ainsi des règles de validation. Les balises de validation sont des annotations spéciales des définitions de champ struct qui spécifient les règles.

Voici une structure régulière pour la validation.

type User struct {
    Name string
    Age int
    Email string
}


Voici un exemple de la structure, prête pour la validation.

type User struct {
    Name string `validate:"required"`
    Age int `validate:"gte=0,lte=130"`
    Email string `validate:"required,email"`
}


Dans cet exemple, vous avez spécifié le champ Nom comme requis lors de l’instanciation, le champ Âge doit être supérieur ou égal à 0 et inférieur ou égal à 130, et le champ E- mail est obligatoire et doit être une adresse e-mail valide lors de l’instanciation.

Différentes balises de validation sont disponibles dans le package de validation Go, y compris les balises pour les champs obligatoires, les valeurs minimales et maximales et les expressions régulières. Vous pouvez trouver une liste complète des balises de validation disponibles dans la documentation du package Go validator.

Une fois que vous avez défini la structure que vous souhaitez valider et spécifié les règles de validation pour chaque champ, vous pouvez utiliser la méthode Struct de la structure validator.Validate pour valider la structure.

user: = User{
    // Name not instantiated
    Age: 3990000,
    Email: "john@example.com",
}
// note that the Name and Age fields fail the validation


err: = validate.Struct(user)
if err! = nil {
    // Struct is invalid
}


La méthode Struct renvoie une erreur si des erreurs de validation existent et vous pouvez gérer l’erreur en fonction de votre opération.

Vous pouvez accéder à ces erreurs à l’aide de la méthode ValidationErrors de l’erreur.

if err! = nil {
    for _, err: = range err.(validator.ValidationErrors) {
        fmt.Println(err.Field(), err.Tag())
    }
}


La méthode ValidationErrors renverra le nom de chaque champ avec une erreur de validation et la balise de validation qui a causé l’erreur.

Définir des balises de validation personnalisées

Vous pouvez également définir des balises de validation personnalisées si des exigences de validation spécifiques ne font pas partie des balises intégrées.

Vous pouvez utiliser la méthode RegisterValidation de la structure validator.Validate . La méthode RegisterValidation prend deux arguments ; le nom de la balise de validation et une fonction de validation. La fonction de validation est une fonction de rappel qui est appelée pour chaque champ ayant la balise de validation personnalisée, et la fonction doit renvoyer true si le champ est valide et false sinon.

Voici un exemple de définition d’une balise de validation personnalisée. La balise valide les champs pour les nombres pairs.

validate.RegisterValidation("even", func(fl validator.FieldLevel) bool {
    // Try to get the field value as an int
    value, ok: = fl.Field().Interface().(int)
    if! ok {
        // If the field value is not an int, return false
        return false
    }
    // Return true if the value is even, false, otherwise
    return value % 2 == 0
})


Le code définit une balise de validation personnalisée même en utilisant la méthode RegisterValidation de la structure validator.Validate . Vous avez défini la balise de validation à l’aide d’une fonction qui prend un seul argument de type validator.FieldLevel.

Vous pouvez désormais utiliser la balise de validation personnalisée dans les définitions de structure de la même manière que vous le feriez pour les balises de validation intégrées.

type MyStruct struct {
    Value int `validate:"even"`
}


Il y a plus à faire

Les structs sont des citoyens de première classe dans Go, et vous pouvez faire tellement de choses avec les structs. Si vous êtes familier avec les langages purement orientés objet, vous pouvez utiliser des structures Go pour opérer sur des données comme vous le feriez avec des classes.