Convalida delle strutture Go tramite Govalidator

Le strutture sono uno dei tipi di dati primari e comunemente usati forniti nel linguaggio di programmazione Go. Molti pacchetti con varie funzionalità, dai pacchetti di database agli ORM, e alcuni framework Web utilizzano struct per una facile analisi dei dati e altre operazioni.

La convalida delle strutture è un’attività comune in Go e il pacchetto Go validator fornisce un modo semplice ed efficiente per convalidare le strutture nei progetti.

Cos’è il pacchetto Go Validator

Il pacchetto Go validator implementa le convalide dei valori per struct e singoli campi in base a tag specificati nella dichiarazione struct.

Il pacchetto Go validator fornisce funzionalità per la convalida cross-field e cross-struct utilizzando tag, slice, array e map diving che consentono livelli di convalida multidimensionale del campo, convalida del campo personalizzato, estrazione di nomi di campo definiti dall’utente, messaggi di errore personalizzabili e supporto per il popolare framework Gin come validatore predefinito per il pacchetto.

Esegui uno di questi comandi nel terminale della tua directory di lavoro per installare il pacchetto validator .

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


Le versioni sono il suffisso dell’URL. Il primo comando installa la versione 9 e il secondo installa la versione 10 del pacchetto.

Dopo aver installato il pacchetto, puoi importarlo nei tuoi progetti a seconda della versione che hai installato.

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


Ora puoi procedere con l’utilizzo del pacchetto Go validator. In caso di problemi con l’installazione, prova a reinstallare/aggiornare all’ultima versione di Go.

Convalidare Struct con il pacchetto Validator

Dovrai creare un’istanza della struttura validator.Validate , definire la struttura che desideri convalidare utilizzando i tag di convalida per specificare le regole di convalida per i campi.

Ecco come creare un’istanza della struttura validator.Validate .

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


È possibile definire una struttura che si desidera convalidare specificando i tag per i campi, impostando quindi le regole di convalida. I tag di convalida sono annotazioni speciali delle definizioni dei campi struct che specificano le regole.

Ecco una struttura regolare per la convalida.

type User struct {
    Name string
    Age int
    Email string
}


Ecco un esempio della struttura, pronta per la convalida.

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


In questo esempio, hai specificato il campo Nome come richiesto durante la creazione dell’istanza, il campo Età deve essere maggiore o uguale a 0 e minore o uguale a 130 e il campo Email è obbligatorio e deve essere un indirizzo email valido durante la creazione dell’istanza.

Diversi tag di convalida sono disponibili nel pacchetto del validatore Go, inclusi tag per campi obbligatori, valori minimi e massimi ed espressioni regolari. È possibile trovare un elenco completo dei tag di convalida disponibili nella documentazione per il pacchetto del validatore Go.

Una volta definita la struttura che si desidera convalidare e specificate le regole di convalida per ogni campo, è possibile utilizzare il metodo Struct della struttura validator.Validate per convalidare la struttura.

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
}


Il metodo Struct restituisce un errore se esistono errori di convalida ed è possibile gestire l’errore in base all’operazione.

È possibile accedere a questi errori utilizzando il metodo ValidationErrors dell’errore.

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


Il metodo ValidationErrors restituirà il nome di ogni campo con un errore di convalida e il tag di convalida che ha causato l’errore.

Definizione di tag di convalida personalizzati

Puoi anche definire tag di convalida personalizzati se i requisiti di convalida specifici non fanno parte dei tag incorporati.

È possibile utilizzare il metodo RegisterValidation della struttura validator.Validate . Il metodo RegisterValidation accetta due argomenti; il nome del tag di convalida e una funzione di convalida. La funzione di convalida è una funzione di callback che viene chiamata per ogni campo con il tag di convalida personalizzato e la funzione deve restituire true se il campo è valido e false in caso contrario.

Ecco un esempio di definizione di un tag di convalida personalizzato. Il tag convalida i campi per i numeri pari.

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
})


Il codice definisce un tag di convalida personalizzato anche utilizzando il metodo RegisterValidation della struttura validator.Validate . Hai definito il tag di convalida utilizzando una funzione che accetta un singolo argomento di tipo validator.FieldLevel.

Ora puoi utilizzare il tag di convalida personalizzato nelle definizioni struct nello stesso modo in cui lo faresti per i tag di convalida incorporati.

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


C’è altro da fare Structs

Gli struct sono cittadini di prima classe in Go e c’è così tanto che puoi fare con gli struct. Se hai familiarità con i linguaggi puramente orientati agli oggetti, puoi utilizzare Go struct per operare sui dati come faresti con le classi.