Ir a la herramienta de verificación de datos del validador de programación

Tabla de contenido

Validador

Validator es una biblioteca de terceros de Golang que se utiliza para verificar datos. A menudo se usa en el desarrollo de API para verificar estrictamente los datos de solicitud enviados por el cliente para evitar solicitudes maliciosas.

• Github: https: //github.com/go-playground/validator

instalación:

go get gopkg.in/go-playground/validator.v10

utilizar:

import "github.com/go-playground/validator/v10"

NOTA : La última versión del validador es la 10. Hay algunas diferencias entre las distintas versiones. Preste atención a la distinción cuando lo utilice.

Inicio rápido

El validador aplica el mecanismo Struct Tag y Reflect de Golang. La idea básica es: definir los respectivos tipos de restricciones para diferentes campos en la etiqueta Struct, y luego obtener la información del tipo de estas restricciones a través de Reflect y realizar la verificación de datos en el validador. El siguiente ejemplo:

package main

import (
  "fmt"

  "gopkg.in/go-playground/validator.v10"
)

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

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

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

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

En el ejemplo anterior, definimos la estructura Usuario, que tiene miembros Nombre y Edad. A través de las restricciones mínimas y máximas del validador, la longitud de la cadena de Nombre está restringida [6, 10], y el rango de números de Edad es [1100].

El primer paso para usar el validador es crear un nuevo "validador" y luego llamar a su método Struct para validar la instancia de estructura. Si se cumplen las restricciones, se devuelve nil; de lo contrario, se devuelve el mensaje de error correspondiente.

Tipo de restricción

Limitaciones especiales

• - : Omita este campo sin marcar;
• | : Utilice varias restricciones, solo una de ellas debe cumplirse, por ejemplo: rgb | rgba;
• required : restricción requerida, no puede ser el valor predeterminado;
• omitempty : si el campo no está configurado, ignórelo .

Restricciones de formato

• correo electrónico : el campo restringido debe estar en formato de correo electrónico.
• url : el campo restringido debe estar en formato URL.
• uri : el campo restringido debe estar en formato URI.
• ip, ipv4, ipv6 : el campo restringido debe estar en formato IP.
• uuid : el campo restringido debe estar en formato UUID.
• datetime : el campo restringido debe estar en formato Datatime.
• json : si el valor de la cadena es JSON válido.
• archivo : si el valor de la cadena contiene una ruta de archivo válida y si el archivo existe en la computadora.

Restricciones del tipo de estructura de datos

• structonly : solo verifica la estructura, no los campos de la estructura. Struct:validate:"structonly" .
• nostructlevel : no ejecuta ninguna verificación a nivel de estructura. Struct:validate:"nostructlevel" .
• inmersión : verificación descendente extendida, se requieren varias marcas de inmersión para descender múltiples. [][]string: validate:"gt=0,dive,len=1,dive,required".
• dive Keys & EndKeys : Se utilizan al mismo tiempo que la inmersión para verificar la suma de las claves del objeto Mapa. ​​Las claves son claves y las claves finales son valores. el Mapa [String] Cadena: validate:"gt=0,dive,keys,eq=1\|eq=2,endkeys,required".

Restricción de alcance

• restricción numérica : rango de valores de restricción;
• Restricción de cadena : restricción de longitud de cadena;
• Restricciones de sector , matriz y mapa : restrinja el número de elementos.

Etiquetas:

• len : la longitud es igual al valor del parámetro, por ejemplo: len = 10;
• eq : el valor es igual al valor del parámetro. A diferencia de len, para String: eq restringe el valor de la cadena en sí, mientras que len restringe la longitud de la cadena, por ejemplo: eq = 10;
• max : el valor es menor o igual que el valor del parámetro.
• min : el valor es mayor o igual que el valor del parámetro.
• ne : No igual al valor del parámetro.
• gt : mayor que el valor del parámetro.
• gte : mayor o igual que el valor del parámetro.
• lt : menor que el valor del parámetro.
• lte : menor o igual al valor del parámetro.
• oneof : Solo puede ser uno de los valores enumerados. Estos valores deben ser numéricos o de cadena, separados por espacios. Si hay espacios en la cadena, use comillas simples. Por ejemplo: oneof = red green.

Restricciones de cadena

A continuación, se enumeran las restricciones de cadenas de uso común:

• contiene = : contiene la subcadena del parámetro, por ejemplo: contiene = correo electrónico;
• containsany : contiene cualquier carácter UNICODE en el parámetro, por ejemplo: containsany = abcd;
• contiene runa: contiene el carácter rúnico representado por el parámetro, por ejemplo: contiene runa = ☻;
• excluye : no incluye subcadenas de parámetros, por ejemplo: excludes = email;
• excludesall : no incluya ningún carácter UNICODE en el parámetro, por ejemplo: excludesall = abcd;
• excludesrune : No incluye el carácter rúnico indicado por el parámetro, por ejemplo: excludesrune = ☻;
• startswith : prefijo con el parámetro subcadena, por ejemplo: startswith = hello;
• termina con : sufijo la subcadena del parámetro, por ejemplo: termina con = adiós.
• numérico : restringe los valores de cadena para que solo contengan valores numéricos básicos.

Restricción de unicidad

Restricciones únicas, el tratamiento de los diferentes tipos es el siguiente:

• Para Slice and Array, la restricción única no tiene elementos duplicados;
• Para Map, la restricción única no tiene valores duplicados;
• Para los sectores cuyo tipo de elemento es una estructura, unívoco restringe un determinado campo de la instancia de la estructura para que no se repita, y este nombre de campo se puede especificar mediante único = campo.

Restricciones entre campos

El validador le permite definir restricciones entre campos, es decir, restringir la relación entre un campo y otros campos. Esta restricción se divide en dos tipos:

1. Una es que el campo de parámetro es el campo de nivel en la misma estructura.
2. La otra es que el campo de parámetro es el campo de otros campos de la estructura.

La sintaxis de la restricción es muy simple: si está restringiendo campos en la misma estructura, agregue un sufijo de campo después de las etiquetas básicas, por ejemplo: eqfield define restricciones de igualdad (eq) entre campos. Si es un campo más profundo, debe agregar cs (Cross-Struct) antes del campo, y eq se convierte en eqcsfield.

Ejemplo:

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

Es decir: su composición es " símbolo de comparación + estructura cruzada (estructura cruzada) + campo ":

• eqfield = Field : Debe ser igual al valor de Field.
• nefield = Field : no debe ser igual al valor de Field.
• gtfield = Field : Debe ser mayor que el valor de Field.
• gtefield = Field : Debe ser mayor o igual que el valor de Field.
• ltfield = Field : Debe ser menor que el valor de Field.
• ltefield = Field : Debe ser menor o igual que el valor de Field.
• eqcsfield = Other.Field : Debe ser igual al valor de Field en la estructura Other.
• necsfield = Other.Field : No debe ser igual al valor de Field en la estructura Other.
• gtcsfield = Other.Field : Debe ser mayor que el valor de Field en la estructura Other;
• gtecsfield = Other.Field : Debe ser mayor o igual que el valor de Field en la estructura Other.
• ltcsfield = Other.Field : Debe ser menor que el valor de Field en la estructura Other.
• ltecsfield = Other.Field : Debe ser menor o igual que el valor de Field en la estructura Other.

También hay varias etiquetas muy útiles:

• required_with = Field1 Field2: Obligatorio cuando existe Field1 o Field2;
• required_with_all = Field1 Field2: Requerido cuando Field1 y Field2 existen;
• required_without = Field1 Field2: Obligatorio cuando Field1 o Field2 no existe;
• required_without_all = Field1 Field2: Requerido cuando Field1 y Field2 existen;

Restricción personalizada

Además de utilizar las restricciones integradas proporcionadas por el validador, también puede definir sus propias restricciones. Primero, defina una función de tipo func (validator.FieldLevel) bool para verificar si se cumple la restricción, y puede recuperar la información del campo que se va a verificar a través de FieldLevel. Luego, llame al método RegisterValidation () del validador para registrar la restricción en el nombre especificado. Finalmente, podemos usar la restricción en la estructura.

Ejemplo:

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() {
    
    
  validate := validator.New()
  validate.RegisterValidation("palindrome", CheckPalindrome)

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

  f2 := RegisterForm{
    
    
    Name: "dj",
    Age:  18,
  }
  err = validate.Struct(f2)
  if err != nil {
    
    
    fmt.Println(err)
  }
}

Manejo de errores

Hay dos tipos de errores devueltos por el validador, uno es error de parámetro y el otro es error de validación Todos implementan la interfaz de error.

• Cuando el parámetro es incorrecto, se devuelve el tipo de InvalidValidationError;
• En caso de errores de validación, se devuelve el tipo ValidationErrors. ValidationErrors es un segmento de error que guarda información sobre cada restricción violada por cada campo.

Por lo tanto, solo hay 3 casos en los que la verificación del validador devuelve:

• nulo: sin error;
• InvalidValidationError: error de parámetro de entrada;
• ValidationErrors: el campo viola las restricciones.

Cuando podemos juzgar err! = Nil en el programa, podemos convertir err en InvalidValidationError y ValidationErrors para obtener información más detallada:

func processErr(err error) {
    
    
  if err == nil {
    
    
    return
  }

  invalid, ok := err.(*validator.InvalidValidationError)
  if ok {
    
    
    fmt.Println("param error:", invalid)
    return
  }

  validationErrs := err.(validator.ValidationErrors)
  for _, validationErr := range validationErrs {
    
    
    fmt.Println(validationErr)
  }
}

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

  err := validate.Struct(1)
  processErr(err)

  err = validate.VarWithValue(1, 2, "eqfield")
  processErr(err)
}

Mensaje de error chino

Deben instalarse dos paquetes:

go get github.com/go-playground/universal-translator
go get github.com/go-playground/locales

Ejemplo:

package main

import (
	"fmt"
	"github.com/go-playground/locales/zh"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	zh_translations "github.com/go-playground/validator/v10/translations/zh"
)

type Users struct {
    
    
	Name	string `form:"name" json:"name" validate:"required"`
	Age		uint8  `form:"age" json:"age" validate:"required,gt=18"`
	Passwd  string `form:"passwd" json:"passwd" validate:"required,max=20,min=6"`
	Code    string `form:"code" json:"code" validate:"required,len=6"`
}

func main() {
    
    
	users := &Users{
    
    
		Name:      "admin",
		Age:        12,
		Passwd:     "123",
		Code:       "123456",
	}

	// 中文翻译器
	uni := ut.New(zh.New())
	trans, _ := uni.GetTranslator("zh")

	// 校验器
	validate := validator.New()

	// 注册翻译器到校验器
	err := zh_translations.RegisterDefaultTranslations(validate, trans)
	if err!=nil {
    
    
		fmt.Println(err)
	}
	err = validate.Struct(users)
	if err != nil {
    
    
		for _, err := range err.(validator.ValidationErrors) {
    
    
			fmt.Println(err.Translate(trans))
			return
		}
	}
	return
}

Documentos de referencia

https://blog.csdn.net/qq_26273559/article/details/107164846