Estructura y mapa del validador del validador de campo de los componentes de ingeniería de Golang basados en la verificación de la regla del mapa

Este artículo presenta principalmente el validador de campo Validator en los componentes de ingeniería de Golang, centrándose en su aplicación en la validación de reglas basadas en mapas. Primero, presentaremos brevemente Validator y mostraremos la conversión mutua entre su estructura y Map; luego, explicaremos en detalle el uso y la implementación de la validación de reglas basada en Map.

1. Descripción general del Validador

Validator es una biblioteca de código abierto que proporciona varias funciones de validación de datos, que pueden ayudar a los usuarios a realizar rápidamente la validación de datos y devolver resultados relevantes. La biblioteca admite una variedad de tipos de datos comunes (como cadenas, números, hora, etc.) y tipos personalizados de verificación, y admite llamadas en cadena.

1. Conversión mutua entre estructura y Mapa

Al usar Validator, generalmente es necesario verificar diferentes tipos de datos. Para los datos del tipo de estructura, normalmente es necesario convertirlos al tipo de Mapa antes de la verificación, de modo que el método proporcionado por el Validador pueda usarse para la verificación convenientemente. Echemos un vistazo a cómo convertir entre estructuras y mapas:

Supongamos que tiene la siguiente estructura:

type User struct {
    Name     string    `json:"name"`
    Age      int       `json:"age"`
    Gender   string    `json:"gender"`
}

Se puede convertir en un formulario de mapa escribiendo el siguiente código:

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]

En el código anterior, primero definimos una estructura de usuario e inicializamos sus variables miembro. Luego, obtenemos la información de valor y tipo de la estructura a través de la reflexión, y la convertimos en un tipo Map.

Además, si necesita convertir el tipo de mapa al tipo de estructura correspondiente, puede utilizar el método proporcionado por Validator:

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}

En el código anterior, primero definimos una estructura de usuario y pasamos un mapa que contiene los campos de la estructura como parámetro a la función MapToStruct. Finalmente, podemos obtener el objeto Usuario correspondiente a los datos originales.

2. Verificación basada en las reglas del Mapa

La validación basada en reglas de mapa es uno de los métodos de validación de datos más utilizados en la biblioteca Validator. Su idea principal es convertir los datos a validar en un tipo de mapa y definir las reglas correspondientes en el mapa. Echemos un vistazo a cómo usar la validación de reglas basada en mapas.

1. Definir reglas de validación

Al realizar la verificación de reglas basadas en mapas, primero debe definir las reglas de verificación correspondientes. Estas reglas suelen incluir información como nombres de campo, tipos de datos y métodos de validación específicos. Aquí hay un ejemplo:

rules := map[string]interface{}{
    "name": map[string]interface{}{
        "type":  "string",
        "rules": []string{"required", "alpha"},
    },
    "age": map[string]interface{}{
        "type":  "int",
        "rules": []string{"min:18"},
    },
}

En el código anterior, definimos dos campos (nombre y edad) y las reglas de validación correspondientes. Entre ellos, el campo de nombre debe ser de tipo cadena y no puede estar vacío y solo puede contener caracteres alfabéticos; el campo de edad debe ser un número entero y su valor no puede ser menor a 18.

1. Realizar operación de verificación

Después de definir las reglas de verificación correspondientes, se puede realizar la operación de verificación. Aquí hay un ejemplo:

v := validator.New()

data := map[string]interface{}{
    "name":   "",
    "age":    16,
}

err := v.ValidateWithRules(data, rules)
if err != nil {
   fmt.Printf("error: %v", err)
}

En el código anterior, primero creamos una instancia del objeto Validator y pasamos los datos que se validarán y las reglas de validación como parámetros a la función ValidateWithRules. Finalmente, si falla la validación de datos, se devuelve un mensaje de error apropiado.

1. método de autenticación personalizado

Además de los métodos de validación predeterminados proporcionados por la biblioteca Validator, los usuarios también pueden escribir los métodos de validación personalizados correspondientes según sus propias necesidades. Aquí hay un ejemplo:

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

En el código anterior, primero definimos un método de verificación personalizado HasUsername y lo registramos en el objeto Validator. Luego, agregue el método personalizado en la regla (nota: el método personalizado agregado en la regla debe ser coherente con la definición real) y realice operaciones de verificación de datos. Cuando se encuentre que el campo de nombre no contiene el símbolo "@", se activará el método de verificación personalizado y se devolverá el mensaje de error correspondiente.

Resumir

A través de la introducción anterior, podemos ver que la verificación basada en reglas de mapa es un método de verificación de datos muy común y flexible en la biblioteca de Validator. Al usar este método, primero debe aclarar el tipo de datos que se verificarán y las reglas que se deben verificar. Luego, puede usar el método proporcionado por el Validador para verificar los datos y escribir un método de verificación personalizado correspondiente de acuerdo con la situación real.

Al mismo tiempo, también presentamos cómo convertir entre estructuras y mapas. Este método es muy importante cuando se utiliza la biblioteca Validator, ya que puede ayudar a los usuarios a convertir datos de estructuras complejas en un formato de mapa fácil de manejar y realizar operaciones de validación de datos de manera conveniente.

En una palabra, mediante el uso racional de varias funciones proporcionadas en la biblioteca Validator, podemos realizar de manera rápida y eficiente la verificación de datos y el manejo de errores, mejorando así la eficiencia del desarrollo y la calidad del código.