Strukturer är en av de primära och populärt använda datatyperna som tillhandahålls i programmeringsspråket Go. Många paket över olika funktioner, från databaspaket till ORM, och vissa webbramverk använder strukturer för enkel dataanalys och andra operationer.
Strukturvalidering är en vanlig uppgift i Go, och Go-valideringspaketet ger ett enkelt och effektivt sätt att validera strukturer i dina projekt.
Vad är Go Validator-paketet
De Gå validator paket implementerar värdevalideringar för struct och enskilda fält baserat på specificerade taggar på struct-deklarationen.
Go-valideringspaketet tillhandahåller funktioner för korsfälts- och tvärstrukturvalidering med taggar, segment, array och kartdykning som tillåter nivåer av flerdimensionell fältvalidering, anpassad fältvalidering, extrahering av specialdefinierade fältnamn, anpassningsbara felmeddelanden och stöd för populär Gin ram som standardvalidator för paketet.
Kör ett av dessa kommandon i terminalen i din arbetskatalog för att installera validator paket.
gå skaffa gopkg.in/gå-lekplats/validator.v9
gå skaffa github.com/gå-lekplats/validator/v10
Versioner är suffixet till URL: en. Det första kommandot installerar version 9 och det andra installerar version 10 av paketet.
Efter installation av paketet kan du importera paketet till dina projekt beroende på vilken version du installerade.
importera (
"gopkg.in/go-playground/validator.v9"
)
Du kan nu fortsätta att använda Go-valideringspaketet. Om det finns några problem med din installation, försök att installera om/uppgradera till den senaste Go-versionen.
Validera strukturer med Validatorpaketet
Du måste skapa en instans av validator. Bekräfta struct, definiera den struct du vill validera med hjälp av valideringstaggar för att specificera valideringsreglerna för fälten.
Så här kan du skapa en instans av validator. Bekräfta struktur.
funchuvud() {
validera := validator. Ny()
}
Du kan definiera en struktur som du vill validera genom att ange taggar för fälten och därigenom ställa in valideringsregler. Valideringstaggar är speciella kommentarer till strukturfältsdefinitioner som anger reglerna.
Här är en vanlig struktur för validering.
typ Användare struktur {
namn sträng
Ålder int
E-post sträng
}
Här är ett exempel på strukturen, redo för validering.
typ Användare struktur {
namn sträng`validera:"required"`
Ålder int`validera:"gte=0,lte=130"`
E-post sträng`validera:"required, email"`
}
I det här exemplet angav du namn fältet som krävs vid instansiering Ålder fältet måste vara större än eller lika med 0 och mindre än eller lika med 130, och E-post fältet är obligatoriskt och måste vara en giltig e-postadress vid instansieringen.
Olika valideringstaggar är tillgängliga i Go-valideringspaketet, inklusive taggar för obligatoriska fält, lägsta och högsta värden och vanliga uttryck. Du kan hitta en komplett lista över tillgängliga valideringstaggar i dokumentationen för Go-valideringspaketet.
När du har definierat strukturen du vill validera och specificerat valideringsreglerna för varje fält, kan du använda Struktur metod för validator. Bekräfta struct för att validera strukturen.
användare := Användare{
// Namn inte instansierat
Ålder: 3990000,
E-post: "[email protected]",
}
// Observera att fälten Namn och Ålder misslyckas med valideringen
fel := validera. Struktur (användare)
om fel!= noll {
// Strukturen är ogiltig
}
De Struktur metod returnerar ett fel om det finns valideringsfel och du kan hantera felet baserat på din operation.
Du kan komma åt dessa fel med hjälp av Valideringsfel metod för felet.
om fel!= noll {
för _, fel := räckvidd err.(validator. Validationsfel) {
fmt. Println (fel. Fält(), fel. Märka())
}
}
De Valideringsfel metod returnerar namnet på varje fält med ett valideringsfel och valideringstaggen som orsakade felet.
Du kan också definiera anpassade valideringstaggar om specifika valideringskrav inte är en del av de inbyggda taggarna.
Du kan använda Registervalidering metod för validator. Bekräfta struktur. De Registervalidering metoden tar två argument; namnet på valideringstaggen och en valideringsfunktion. Valideringsfunktionen är en återuppringningsfunktion som anropas för varje fält som har den anpassade valideringstaggen, och funktionen måste returnera Sann om fältet är giltigt och falsk om annat.
Här är ett exempel på en definition av en anpassad valideringstagg. Taggen validerar fält för jämna nummer.
bekräfta. RegisterValidation("även", func(fl validator. Fältnivå)bool {
// Försök att få fältvärdet som en int
värde, ok := fl. Fält().Interface().(int)
om !ok {
// Om fältvärdet inte är en int, returnera false
lämna tillbakafalsk
}
// Returnera sant om värdet är jämnt, falskt, annars
lämna tillbaka värde % 2 == 0
})
Koden definierar en anpassad valideringstagg även använda Registervalidering metod för validator. Bekräfta struktur. Du definierade valideringstaggen med en funktion som tar ett enda argument av typen validator. Fältnivå.
Du kan nu använda den anpassade valideringstaggen i structdefinitioner på samma sätt som för inbyggda valideringstaggar.
typ MyStruct struktur {
Värde int`validera:"jämn"`
}
Det finns fler strukturer att gå
Strukturer är förstklassiga medborgare i Go, och det finns så mycket du kan göra med strukturer. Om du är bekant med rent objektorienterade språk kan du använda Go-strukturer för att arbeta med data som du skulle göra med klasser.