Dieser Artikel stellt hauptsächlich den Feldvalidator Validator in Golang Engineering Components vor und konzentriert sich auf seine Anwendung bei der kartenbasierten Regelvalidierung. Zunächst stellen wir Validator kurz vor und zeigen die gegenseitige Konvertierung zwischen seiner Struktur und Map. Anschließend erläutern wir detailliert die Verwendung und Implementierung der kartenbasierten Regelvalidierung.
1. Übersicht über Validator
Validator ist eine Open-Source-Bibliothek, die verschiedene Datenvalidierungsfunktionen bereitstellt, mit denen Benutzer schnell Datenvalidierungen durchführen und relevante Ergebnisse zurückgeben können. Die Bibliothek unterstützt eine Vielzahl gängiger Datentypen (z. B. Zeichenfolgen, Zahlen, Zeit usw.) und benutzerdefinierte Arten der Überprüfung sowie Kettenaufrufe.
- Gegenseitige Konvertierung zwischen Struktur und Karte
Bei der Verwendung von Validator ist es in der Regel erforderlich, verschiedene Arten von Daten zu überprüfen. Für die Daten des Strukturtyps ist es normalerweise erforderlich, sie vor der Überprüfung in den Kartentyp zu konvertieren, damit die vom Validator bereitgestellte Methode bequem zur Überprüfung verwendet werden kann. Schauen wir uns an, wie man zwischen Strukturen und Karten konvertiert:
Angenommen, Sie haben die folgende Struktur:
type User struct {
Name string `json:"name"`
Age int `json:"age"`
Gender string `json:"gender"`
}Es kann durch Schreiben des folgenden Codes in ein Kartenformular umgewandelt werden:
u := User{
Name: "Tom",
Age: 28,
Gender: "Male",
}
m := make(map[string]interface{})
s := reflect.ValueOf(&u).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
m[typeOfT.Field(i).Name] = f.Interface()
}
fmt.Println(m) // Output: map[Name:Tom Age:28 Gender:Male]Im obigen Code definieren wir zunächst eine Benutzerstruktur und initialisieren ihre Mitgliedsvariablen. Anschließend erhalten wir durch Reflexion die Wert- und Typinformationen der Struktur und konvertieren sie in einen Kartentyp.
Wenn Sie außerdem den Kartentyp in den entsprechenden Strukturtyp konvertieren müssen, können Sie die von Validator bereitgestellte Methode verwenden:
v := validator.New()
type User struct {
Name string `json:"name"`
Age int `json:"age"`
Gender string `json:"gender"`
}
m := map[string]interface{}{
"name": "Tom",
"age": 28,
"gender": "Male",
}
var u User
err := v.MapToStruct(m, &u)
if err != nil {
fmt.Printf("error: %v", err)
}
fmt.Printf("%+v\n", u) // Output: {Name:Tom Age:28 Gender:Male}Im obigen Code definieren wir zunächst eine User-Struktur und übergeben eine Map, die die Felder der Struktur enthält, als Parameter an die MapToStruct-Funktion. Schließlich können wir das Benutzerobjekt erhalten, das den Originaldaten entspricht.
2. Überprüfung basierend auf Kartenregeln
Die auf Kartenregeln basierende Validierung ist eine der am häufigsten verwendeten Datenvalidierungsmethoden in der Validator-Bibliothek. Ihre Hauptidee besteht darin, die zu validierenden Daten in einen Kartentyp umzuwandeln und entsprechende Regeln in der Karte zu definieren. Werfen wir einen Blick auf die Verwendung der kartenbasierten Regelvalidierung.
- Validierungsregeln definieren
Wenn Sie eine kartenbasierte Regelüberprüfung durchführen, müssen Sie zunächst die entsprechenden Überprüfungsregeln definieren. Diese Regeln umfassen normalerweise Informationen wie Feldnamen, Datentypen und bestimmte Validierungsmethoden. Hier ist ein Beispiel:
rules := map[string]interface{}{
"name": map[string]interface{}{
"type": "string",
"rules": []string{"required", "alpha"},
},
"age": map[string]interface{}{
"type": "int",
"rules": []string{"min:18"},
},
}Im obigen Code haben wir zwei Felder (Name und Alter) und entsprechende Validierungsregeln definiert. Darunter muss das Feld „Name“ vom Typ „String“ sein und darf nicht leer sein und darf nur alphabetische Zeichen enthalten; das Feld „Alter“ muss eine Ganzzahl sein und sein Wert darf nicht kleiner als 18 sein.
- Führen Sie den Verifizierungsvorgang durch
Nachdem die entsprechenden Verifizierungsregeln definiert wurden, kann der Verifizierungsvorgang durchgeführt werden. Hier ist ein Beispiel:
v := validator.New()
data := map[string]interface{}{
"name": "",
"age": 16,
}
err := v.ValidateWithRules(data, rules)
if err != nil {
fmt.Printf("error: %v", err)
}Im obigen Code instanziieren wir zunächst das Validator-Objekt und übergeben die zu validierenden Daten und Validierungsregeln als Parameter an die Funktion ValidateWithRules. Wenn die Datenvalidierung fehlschlägt, wird schließlich eine entsprechende Fehlermeldung zurückgegeben.
- benutzerdefinierte Authentifizierungsmethode
Zusätzlich zu den von der Validator-Bibliothek bereitgestellten Standardvalidierungsmethoden können Benutzer auch entsprechende benutzerdefinierte Validierungsmethoden entsprechend ihren eigenen Anforderungen schreiben. Hier ist ein Beispiel:
func HasUsername(value interface{}, args ...interface{}) error {
username := value.(string)
if strings.Index(username, "@") == -1 {
return fmt.Errorf("username must contain '@'")
}
return nil
}
rules := map[string]interface{}{
"name": map[string]interface{}{
"type": "string",
"rules": []string{"required", "alpha", "has_username"},
},
}
v := validator.New()
v.SetValidationFunc("has_username", HasUsername)
data := map[string]interface{}{
"name": "",
}
err := v.ValidateWithRules(data, rules)
if err != nil {
fmt.Printf("error: %v", err)
}Im obigen Code definieren wir zunächst eine benutzerdefinierte Überprüfungsmethode HasUsername und registrieren sie im Validator-Objekt. Fügen Sie dann die benutzerdefinierte Methode zur Regel hinzu (Hinweis: Die zur Regel hinzugefügte benutzerdefinierte Methode muss mit der tatsächlichen Definition übereinstimmen) und führen Sie Datenüberprüfungsvorgänge durch. Wenn festgestellt wird, dass das Namensfeld das Symbol „@“ nicht enthält, wird die benutzerdefinierte Überprüfungsmethode ausgelöst und die entsprechende Fehlermeldung zurückgegeben.
Zusammenfassen
Anhand der obigen Einführung können wir erkennen, dass die auf Kartenregeln basierende Überprüfung eine sehr häufige und flexible Methode zur Datenüberprüfung in der Validator-Bibliothek ist. Wenn Sie diese Methode verwenden, müssen Sie zunächst die Art der zu überprüfenden Daten und die zu überprüfenden Regeln klären. Anschließend können Sie die vom Validator bereitgestellte Methode verwenden, um die Daten zu überprüfen, und entsprechend der tatsächlichen Situation eine entsprechende benutzerdefinierte Überprüfungsmethode schreiben.
Gleichzeitig haben wir auch die Konvertierung zwischen Strukturen und Karten vorgestellt. Diese Methode ist bei der Verwendung der Validator-Bibliothek sehr wichtig, da sie Benutzern dabei helfen kann, komplexe Strukturdaten in ein einfach zu handhabendes Kartenformat zu konvertieren und Datenvalidierungsvorgänge bequem durchzuführen.
Kurz gesagt: Durch die rationelle Nutzung verschiedener in der Validator-Bibliothek bereitgestellter Funktionen können wir die Datenüberprüfung und Fehlerbehandlung schnell und effizient durchführen und so die Entwicklungseffizienz und Codequalität verbessern.