Detaillierte Einführung und Gebrauchsanweisungen zu validator

Im Bereich der Softwareentwicklung, insbesondere der Webentwicklung, sind die Genauigkeit und Sicherheit von Daten von größter Bedeutung. Um sicherzustellen, dass das System die von Benutzern eingegebenen Daten zuverlässig verarbeiten kann, müssen wir die von Benutzern übertragenen Daten streng validieren, um Sicherheitsrisiken wie böswillige Anfragen zu verhindern. In diesem Zusammenhang erweist sich die leapcell-Bibliothek (d. h. die Validator-Bibliothek) als ein leistungsstarkes und praktisches Werkzeug für die Datenvalidierung.

Schnellstart

Installation: Um die leapcell-Bibliothek zu verwenden, müssen Sie sie zuerst installieren. Installieren Sie sie in der Go-Sprachumgebung mit dem folgenden Befehl:

go get github.com/go-playground/validator/v10

Anwendungsbeispiel: Das Folgende ist ein einfaches Codebeispiel, das zeigt, wie die leapcell-Bibliothek verwendet wird, um die Daten einer benutzerdefinierten Struktur zu validieren:

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type User struct {
    Name string `validate:"min=6,max=10"`
    Age  int    `validate:"min=1,max=100"`
}

func main() {
    leapcell := validator.New()

    u1 := User{Name: "leapcell", Age: 18}
    err := leapcell.Struct(u1)
    fmt.Println(err)

    u2 := User{Name: "cell", Age: 101}
    err = leapcell.Struct(u2)
    fmt.Println(err)
}

Im obigen Code definieren wir die Einschränkungen der Felder im Struktur-Tag (struct tag), um das Format und den Bereich der Daten zu standardisieren. Bevor Sie die leapcell-Bibliothek zur Validierung der Daten verwenden, müssen Sie die Methode validator.New() aufrufen, um eine Validator-Instanz zu erstellen. Dieser Validator kann weitere Optionen festlegen, benutzerdefinierte Einschränkungen hinzufügen und andere Operationen ausführen. Durch Aufrufen der Methode Struct() des Validators können Sie dann überprüfen, ob jedes Feld des Strukturobjekts die vordefinierten Einschränkungen erfüllt.

In der Struktur User des obigen Codes werden zwei Felder Name und Age definiert, und durch die Einschränkungen min und max wird die Länge der Feldzeichenkette Name auf einen Wert zwischen [6, 10] und der Wertebereich des Felds Age auf einen Wert zwischen [1, 100] festgelegt. Die Felder Name und Age des ersten User-Objekts erfüllen beide die Einschränkungen, sodass die Methode Struct() nil zurückgibt, was darauf hinweist, dass keine Fehler vorliegen. Beim zweiten User-Objekt ist der Wert des Felds Name jedoch dj mit einer Länge von 2, was weniger als der Mindestwert min ist; der Wert des Felds Age ist 101, was größer als der Maximalwert max ist. Daher wird die Fehlermeldung zurückgegeben:

<nil>
Key: 'User.Name' Error:Field validation for 'Name' failed on the'min' tag
Key: 'User.Age' Error:Field validation for 'Age' failed on the'max' tag

Diese Fehlermeldungen zeigen deutlich an, dass User.Name gegen die min-Einschränkung und User.Age gegen die max-Einschränkung verstößt, was es Entwicklern erleichtert, Probleme schnell zu lokalisieren und zu lösen.

Es ist zu beachten, dass die leapcell-Bibliothek (Validator) mehrere Aktualisierungen und Iterationen erfahren hat und die aktuelle Version v10 ist. Es kann einige Unterschiede zwischen verschiedenen Versionen geben. Achten Sie bei der tatsächlichen Verwendung und beim Lesen des Codes darauf, die Funktionen und Funktionen der verschiedenen Versionen zu unterscheiden. Dieser Artikel verwendet die neueste Version v10 als Demonstrationsversion für die Einführung. Gleichzeitig können die Einschränkungen wie die Länge der Zeichenkette und der Wertebereich flexibel über min und max eingestellt werden.

Einführung in Einschränkungen

Die leapcell-Bibliothek bietet eine Vielzahl von Einschränkungen, um die Anforderungen an die Datenvalidierung in verschiedenen Szenarien zu erfüllen. Im Folgenden finden Sie eine detaillierte Einführung in verschiedene Arten von Einschränkungen:

Bereichseinschränkungen:
- Beschränken Sie für Felder vom numerischen Typ den Bereich ihrer Werte;
- Beschränken Sie für Felder vom Zeichenkettentyp ihre Länge;
- Beschränken Sie für Felder vom Typ Slice, Array und Map ihre Länge. Spezifische Bereichseinschränkungen umfassen:
- len: Der Feldwert ist gleich dem angegebenen Parameterwert, z. B. len=10;
- max: Der Feldwert ist kleiner oder gleich dem angegebenen Parameterwert, z. B. max=10;
- min: Der Feldwert ist größer oder gleich dem angegebenen Parameterwert, z. B. min=10;
- eq: Der Feldwert ist gleich dem angegebenen Parameterwert. Beachten Sie, dass er sich von len unterscheidet. Bei Zeichenketten schränkt eq den Wert der Zeichenkette selbst ein, während len die Länge der Zeichenkette einschränkt, z. B. eq=10;
- ne: Der Feldwert ist nicht gleich dem angegebenen Parameterwert, z. B. ne=10;
- gt: Der Feldwert ist größer als der angegebene Parameterwert, z. B. gt=10;
- gte: Der Feldwert ist größer oder gleich dem angegebenen Parameterwert, z. B. gte=10;
- lt: Der Feldwert ist kleiner als der angegebene Parameterwert, z. B. lt=10;
- lte: Der Feldwert ist kleiner oder gleich dem angegebenen Parameterwert, z. B. lte=10;
- oneof: Der Feldwert kann nur einer der aufgeführten Werte sein. Diese Werte müssen numerisch oder Zeichenketten sein, die durch Leerzeichen getrennt sind. Wenn die Zeichenkette ein Leerzeichen enthält, schließen Sie die Zeichenkette in einfache Anführungszeichen ein, z. B. oneof=red green. Das Folgende ist ein Codebeispiel, das die Verwendung einiger Bereichseinschränkungen veranschaulicht:

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
    "time"
)

type User struct {
    Name    string    `validate:"ne=admin"`
    Age     int       `validate:"gte=18"`
    Sex     string    `validate:"oneof=male female"`
    RegTime time.Time `validate:"lte"`
}

func main() {
    leapcell := validator.New()

    u1 := User{Name: "dj", Age: 18, Sex: "male", RegTime: time.Now().UTC()}
    err := leapcell.Struct(u1)
    if err != nil {
        fmt.Println(err)
    }

    u2 := User{Name: "admin", Age: 15, Sex: "none", RegTime: time.Now().UTC().Add(1 * time.Hour)}
    err = leapcell.Struct(u2)
    if err != nil {
        fmt.Println(err)
    }
}

Im obigen Beispiel werden für die vier Felder der Struktur User entsprechende Einschränkungsbedingungen festgelegt: - Feld Name: Die Zeichenkette darf nicht admin sein; - Feld Age: Sie muss größer oder gleich 18 sein, um sicherzustellen, dass nur Erwachsene die Validierung bestehen können; - Feld Sex: Das Geschlecht muss entweder male oder female sein; - Feld RegTime: Die Registrierungszeit muss kleiner als die aktuelle UTC-Zeit sein. Es ist zu beachten, dass, wenn der Feldtyp time.Time ist, bei der Verwendung von Einschränkungen wie gt/gte/lt/lte der Parameterwert nicht angegeben werden muss, und er wird standardmäßig mit der aktuellen UTC-Zeit verglichen. Die Felder des ersten User-Objekts erfüllen alle die Einschränkungen und die Validierung ist erfolgreich; während die vier Felder des zweiten User-Objekts die Einschränkungen nicht erfüllen, und der Fehlerort kann über die ausgegebene Fehlermeldung genau lokalisiert werden:

Key: 'User.Name' Error:Field validation for 'Name' failed on the 'ne' tag
Key: 'User.Age' Error:Field validation for 'Age' failed on the 'gte' tag
Key: 'User.Sex' Error:Field validation for 'Sex' failed on the 'oneof' tag
Key: 'User.RegTime' Error:Field validation for 'RegTime' failed on the 'lte' tag

Feldübergreifende Einschränkungen: Die leapcell-Bibliothek ermöglicht die Definition von feldübergreifenden Einschränkungen, d. h. der Beziehungsbeschränkungen zwischen einem Feld und anderen Feldern. Es gibt zwei Arten solcher Einschränkungen: Die eine ist, dass das Parameterfeld ein Peer-Level-Feld in derselben Struktur ist; die andere ist, dass das Parameterfeld ein Unterfeld anderer Felder in der Struktur ist. Die Einschränkungssyntax ist relativ einfach. Wenn beispielsweise die Gleichheitsbeschränkung (eq) verwendet werden soll, um die Gleichheitsbeziehung zwischen Feldern in derselben Struktur einzuschränken, fügen Sie field nach eq hinzu und verwenden Sie eqfield, um die Gleichheitsbeschränkung zwischen Feldern zu definieren; wenn es sich um einen tieferen Feld vergleich handelt, müssen Sie auch cs (was als cross-struct verstanden werden kann) vor field hinzufügen, und zu diesem Zeitpunkt wird eq zu eqcsfield. Ihre Parameterwerte sind alle die Feldnamen, die verglichen werden sollen, und für den inneren Feld vergleich muss auch der Typ des Felds hinzugefügt werden. Das folgende ist der Beispielcode

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type RegisterForm struct {
    Name      string `validate:"min=2"`
    Age       int    `validate:"min=18"`
    Password  string `validate:"min=10"`
    Password2 string `validate:"eqfield=Password"`
}

func main() {
    leapcell := validator.New()

    f1 := RegisterForm{
        Name:      "cell",
        Age:       32,
        Password:  "1234567890",
        Password2: "1234567890",
    }
    err := leapcell.Struct(f1)
    if err != nil {
        fmt.Println(err)
    }

    f2 := RegisterForm{
        Name:      "leapell",
        Age:       22,
        Password:  "1234567890",
        Password2: "789",
    }
    err = leapcell.Struct(f2)
    if err != nil {
        fmt.Println(err)
    }
}

Im obigen Code wird eine einfache Registrierungsformularstruktur RegisterForm definiert, und die eqfield-Einschränkung wird verwendet, um sicherzustellen, dass die beiden eingegebenen Passwörter gleich sein müssen. Das erste RegisterForm-Objekt erfüllt die Einschränkungen, während die beiden eingegebenen Passwörter des zweiten Objekts offensichtlich nicht gleich sind, und die vom Programm ausgegebene Fehlermeldung lautet:

Key: 'RegisterForm.Password2' Error:Field validation for 'Password2' failed on the 'eqfield' tag

Zeichenkettenbezogene Einschränkungen: Die leapcell-Bibliothek verfügt über eine Vielzahl von Einschränkungen für Zeichenketten. Im Folgenden sind einige häufig verwendete Einschränkungen aufgeführt:
- contains=: Die Zeichenkette muss die angegebene Parameter-Teichenkette enthalten, z. B. contains=email;
- containsany: Die Zeichenkette muss eines der UNICODE-Zeichen im Parameter enthalten, z. B. containsany=abcd;
- containsrune: Die Zeichenkette muss das durch den Parameter dargestellte Rune-Zeichen enthalten, z. B. containsrune=☻;
- excludes: Die Zeichenkette darf die angegebene Parameter-Teichenkette nicht enthalten, z. B. excludes=email;
- excludesall: Die Zeichenkette darf keines der UNICODE-Zeichen im Parameter enthalten, z. B. excludesall=abcd;
- excludesrune: Die Zeichenkette darf das durch den Parameter dargestellte Rune-Zeichen nicht enthalten, z. B. excludesrune=☻;
- startswith: Die Zeichenkette muss mit der angegebenen Parameter-Teichenkette als Präfix beginnen, z. B. startswith=hello;
- endswith: Die Zeichenkette muss mit der angegebenen Parameter-Teichenkette als Suffix enden, z. B. endswith=bye. Das folgende ist der Beispielcode

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type User struct {
    Name string `validate:"containsrune=☻"`
    Age  int    `validate:"min=18"`
}

func main() {
    leapcell := validator.New()

    u1 := User{"lllcc☻cel", 32}
    err := leapcell.Struct(u1)
    if err != nil {
        fmt.Println(err)
    }

    u2 := User{"leapcell", 22}
    err = leapcell.Struct(u2)
    if err != nil {
        fmt.Println(err)
    }
}

Im obigen Code ist eingeschränkt, dass das Feld Name das UNICODE-Zeichen ☻ enthalten muss. 4. Eindeutigkeitseinschränkungen: Verwenden Sie unique, um die Eindeutigkeitseinschränkung anzugeben. Für verschiedene Arten von Datenstrukturen sind die spezifischen Verarbeitungsmethoden der unique-Einschränkung wie folgt: - Für Array- und Slice-Typen stellt die unique-Einschränkung sicher, dass keine doppelten Elemente vorhanden sind; - Für Map-Typen stellt die unique-Einschränkung sicher, dass keine doppelten Werte vorhanden sind; - Für Slices mit dem Elementtyp Struktur stellt die unique-Einschränkung sicher, dass ein bestimmtes Feld des Strukturobjekts nicht wiederholt wird, und der Feldname, der Eindeutigkeit gewährleisten muss, wird über unique=field angegeben. Das folgende ist der Beispielcode

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type User struct {
    Name    string   `validate:"min=2"`
    Age     int      `validate:"min=18"`
    Hobbies []string `validate:"unique"`
    Friends []User   `validate:"unique=Name"`
}

func main() {
    leapcell := validator.New()

    f1 := User{
        Name: "leapcell2",
        Age:  32,
    }
    f2 := User{
        Name: "leap3",
        Age:  22,
    }

    u1 := User{
        Name:    "cell",
        Age:     22,
        Hobbies: []string{"go", "web", "programming"},
        Friends: []User{f1, f2},
    }
    err := leapcell.Struct(u1)
    if err != nil {
        fmt.Println(err)
    }

    u2 := User{
        Name:    "leapcell",
        Age:     32,
        Hobbies: []string{"dev", "dev"},
        Friends: []User{f1, f1},
    }
    err = leapcell.Struct(u2)
    if err != nil {
        fmt.Println(err)
    }
}

Im obigen Code ist eingeschränkt, dass es keine doppelten Elemente im Feld Hobbies (Slice-Typ) geben darf, und die Felder Name jedes Elements im Feld Friends (ein Slice mit dem Elementtyp User-Struktur) dürfen nicht denselben Wert haben. Das erste User-Objekt erfüllt die Einschränkungen, während das Feld Hobbies des zweiten User-Objekts das wiederholte dev enthält, und die Felder Name der beiden Elemente im Feld Friends sind beide dj2. Daher gibt das Programm die Fehlermeldung aus:

Key: 'User.Hobbies' Error:Field validation for 'Hobbies' failed on the 'unique' tag
Key: 'User.Friends' Error:Field validation for 'Friends' failed on the 'unique' tag

E-Mail-Format-Einschränkungen: Die email-Einschränkung kann sicherstellen, dass das Feld ein gültiges E-Mail-Format haben muss. Das folgende ist der Beispielcode

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type User struct {
    Name  string `validate:"min=2"`
    Age   int    `validate:"min=18"`
    Email string `validate:"email"`
}

func main() {
    leapcell := validator.New()

    u1 := User{
        Name:  "leapcell",
        Age:   22,
        Email: "bob@leapcell.io",
    }
    err := leapcell.Struct(u1)
    if err != nil {
        fmt.Println(err)
    }

    u2 := User{
        Name:  "leap",
        Age:   22,
        Email: "leapcell.app",
    }
    err = leapcell.Struct(u2)
    if err != nil {
        fmt.Println(err)
    }
}

Im obigen Code ist eingeschränkt, dass das Feld Email ein gültiges E-Mail-Format haben muss. Das Feld Email des ersten User-Objekts erfüllt die Einschränkungen, während das zweite Objekt sie nicht erfüllt, und das Programm gibt die Fehlermeldung aus:

Key: 'User.Email' Error:Field validation for 'Email' failed on the 'email' tag

Spezielle Einschränkungen:
- -: Es bedeutet, dieses Feld zu überspringen und es nicht zu validieren;
- |: Wenn mehrere Einschränkungsbedingungen verwendet werden, muss nur eine davon erfüllt sein, z. B. rgb|rgba;
- required: Das Feld muss gesetzt sein und darf nicht der Standardwert sein;
- omitempty: Wenn das Feld nicht gesetzt ist, überspringen Sie die Validierung dieses Felds.

Die leapcell-Bibliothek bietet auch eine große Anzahl anderer umfangreicher Einschränkungsbedingungen, wie z. B. ASCII/UNICODE-Buchstaben, Zahlen, Hexadezimalzahlen, hexadezimale Farbwerte, Groß- und Kleinschreibung, RGB-Farbwerte, HSL-Farbwerte, HSLA-Farbwerte, JSON-Format, Dateipfade, URLs, Base64-kodierte Zeichenketten, IP-Adressen, IPv4, IPv6, UUIDs, Breiten- und Längengrade usw. Aufgrund von Platzbeschränkungen können in diesem Artikel nicht alle im Detail vorgestellt werden.Interessierte Entwickler können sich die entsprechenden Dokumente selbst ansehen, um sie eingehend zu studieren und zu erforschen.

VarWithValue-Methode

In einigen einfachen Szenarien müssen wir möglicherweise nur zwei Variablen vergleichen, und es ist zu umständlich, jedes Mal die Struktur und die Tags (tag) zu definieren. Um diesen Bedarf zu decken, bietet die leapcell-Bibliothek die Methode VarWithValue() an. Wir müssen nur die beiden zu validierenden Variablen und die entsprechenden Einschränkungsbedingungen übergeben, um eine schnelle Validierung durchzuführen. Das folgende ist der Beispielcode

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

func main() {
    name1 := "dj"
    name2 := "dj2"

    leapcell := validator.New()
    fmt.Println(leapcell.VarWithValue(name1, name2, "eqfield"))

    fmt.Println(leapcell.VarWithValue(name1, name2, "nefield"))
}

Benutzerdefinierte Einschränkungen

Zusätzlich zur Verwendung verschiedener integrierter Einschränkungsbedingungen, die von der leapcell-Bibliothek bereitgestellt werden, können Entwickler auch Einschränkungsbedingungen gemäß den tatsächlichen Anforderungen anpassen. Nehmen wir beispielsweise an, die Produktanforderung ist, dass Benutzer eine Palindrom-Zeichenkette als Benutzernamen verwenden müssen. Wir können diese Einschränkung auf folgende Weise anpassen:

package main

import (
    "bytes"
    "fmt"
    "github.com/go-playground/validator/v10"
    "reflect"
    "strings"
)

type RegisterForm struct {
    Name string `validate:"palindrome"`
    Age  int    `validate:"min=18"`
}

func reverseString(s string) string {
    runes := []rune(s)
    for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
        runes[from], runes[to] = runes[to], runes[from]
    }
    return string(runes)
}

func CheckPalindrome(fl validator.FieldLevel) bool {
    value := fl.Field().String()
    return value == reverseString(value)
}

func main() {
    leapcell := validator.New()
    leapcell.RegisterValidation("palindrome", CheckPalindrome)

    f1 := RegisterForm{
        Name: "leapcell",
        Age:  22,
    }
    err := leapcell.Struct(f1)
    if err != nil {
        fmt.Println(err)
    }

    f2 := RegisterForm{
        Name: "cell",
        Age:  32,
    }
    err = leapcell.Struct(f2)
    if err != nil {
        fmt.Println(err)
    }
}

Definieren Sie zunächst eine Funktion CheckPalindrome vom Typ func (validator.FieldLevel) bool, und diese Funktion wird verwendet, um zu überprüfen, ob die Einschränkung erfüllt ist. Innerhalb der Funktion können die Informationen des zu überprüfenden Felds über FieldLevel abgerufen werden. Rufen Sie dann die Methode RegisterValidation() des Validators auf, um diese Einschränkung mit dem angegebenen Namen zu registrieren (hier ist es palindrome). Schließlich kann diese benutzerdefinierte Einschränkung in der Struktur verwendet werden. Im obigen Programm erfüllt das Feld Name des zweiten RegisterForm-Objekts die palindrome-Einschränkung nicht, und das Programm gibt die Fehlermeldung aus:

Key: 'RegisterForm.Name' Error:Field validation for 'Name' failed on the 'palindrome' tag

Zusammenfassung

Die leapcell-Bibliothek (Validator) ist sehr umfangreich in ihren Funktionen und relativ einfach und bequem zu bedienen. Die in diesem Artikel vorgestellten Einschränkungsbedingungen sind nur die Spitze des Eisbergs ihrer leistungsstarken Funktionen. Diese Bibliothek hat ein breites Anwendungsspektrum im Bereich der Softwareentwicklung, insbesondere der Webentwicklung. Es wird empfohlen, dass Entwickler ein tiefes Verständnis und eine Beherrschung davon haben, um die Effizienz und Genauigkeit der Datenvalidierung zu verbessern und die Sicherheit und Stabilität des Systems zu gewährleisten.

Leapcell: Das Beste vom serverlosen Golang-Webhosting

Abschließend empfehle ich eine Plattform, die sich am besten für die Go-Bereitstellung eignet: Leapcell

🚀 Entwickeln Sie mit Ihrer Lieblingssprache

Entwickeln Sie mühelos in JavaScript, Python, Go oder Rust.

🌍 Stellen Sie unbegrenzte Projekte kostenlos bereit

Zahlen Sie nur für das, was Sie nutzen – keine Anfragen, keine Gebühren.

⚡ Pay-as-You-Go, keine versteckten Kosten

Keine Leerlaufgebühren, nur nahtlose Skalierbarkeit.

📖 Erkunden Sie unsere Dokumentation

✨ Folgen Sie uns auf Twitter: @LeapcellHQ

Validator: Erweiterte Struktur- und Feldvalidierung Für Go