introducir
El modelo de estrategia define a la familia de algoritmo y los encapsula por separado para que puedan reemplazarse entre sí. Este modelo permite que los cambios en el algoritmo no afecten a los clientes que usan el algoritmo.
texto
Antes de comprender el modelo de política, primero tomemos un ejemplo. En términos generales, si queremos verificar la legitimidad de los datos, a menudo juzgamos de acuerdo con la declaración de barrido, pero esto trae varios problemas. En primer lugar, si aumentamos la demanda, tenemos que modificar este código nuevamente para aumentar la lógica, y se volverá cada vez más complicado al realizar pruebas unitarias. El código es el siguiente:
La copia del código es la siguiente:
validador = {
validar: función (valor, tipo) {
Switch (tipo) {
caso 'isnonempty':
{
devolver verdadero; // Resultado de verificación no vacío
}
caso 'isnumber':
{
devolver verdadero; // Resultado de verificación de números
romper;
}
caso 'isalphanum':
{
devolver verdadero; // Resultado de verificación de alfánum
}
por defecto:
{
devolver verdadero;
}
}
}
};
// prueba
alerta (validator.validate ("123", "isnonempty"));
Entonces, ¿cómo evitar los problemas en el código anterior? Según el patrón de política, podemos encapsular el mismo código de trabajo en diferentes clases por separado, y luego manejarlo a través de una clase de procesamiento de políticas unificadas. Ok, primero definimos la clase de procesamiento de políticas, el código es el siguiente:
La copia del código es la siguiente:
Validador de var = {
// Todos los lugares donde se pueden almacenar todas las clases de procesamiento de reglas de validación se definirán por separado más tarde.
Tipos: {},
// Mensaje de error correspondiente al tipo de verificación
Mensajes: [],
// Por supuesto, el tipo de verificación que debe usarse
config: {},
// Método de verificación pública expuesta
// El parámetro aprobado es Key => Valor Par
validar: function (data) {
var i, msg, type, verificador, resultado_ok;
// Borrar todos los mensajes de error
this.messages = [];
para (i en datos) {
if (data.hasownproperty (i)) {
type = this.config [i]; // Verifique si hay una regla de validación basada en la clave
checker = this.types [type]; // Obtener la clase de verificación para la regla de verificación
if (! type) {
continuar; // Si la regla de verificación no existe, no se procesará
}
if (! checker) {// Si la clase de regla de verificación no existe, se lanza una excepción
tirar {
Nombre: "ValidationError",
Mensaje: "Sin controlador para validar el tipo" + Tipo
};
}
result_ok = checker.validate (datos [i]); // Verificar usando una sola clase de verificación encontrada
if (! result_ok) {
msg = "valor inválido para *" + i + " *," + checker.instructions;
this.messages.push (msg);
}
}
}
devolver esto.haserrors ();
},
// ayudante
Haserrors: functer () {
devuelve this.messages.length! == 0;
}
};
Luego, el resto es definir las diversas clases de verificación almacenadas en los tipos. Vamos a darle algunos ejemplos aquí:
La copia del código es la siguiente:
// Verifique que el valor dado no esté vacío
validator.types.isnonempty = {
validar: function (valor) {
Valor de retorno! == "";
},
Instrucciones: "El valor pasado no puede estar vacío"
};
// Verifique que el valor dado sea un número
validator.types.isnumber = {
validar: function (valor) {
Return! Isnan (valor);
},
Instrucciones: "El valor aprobado solo puede ser un número legal, por ejemplo: 1, 3.14 o 2010"
};
// Verifique que el valor dado sea solo una letra o un número
validator.types.isalphanum = {
validar: function (valor) {
return!/[^a-z0-9] /i.test (valor);
},
Instrucciones: "El valor aprobado solo puede proteger letras y números y no puede contener caracteres especiales"
};
Al usarlo, primero debemos definir el conjunto de datos que necesita ser verificado, y luego debemos definir el tipo de regla que debe verificarse para cada datos. El código es el siguiente:
La copia del código es la siguiente:
var data = {
First_Name: "Tom",
Last_Name: "Xu",
Edad: "Desconocido",
Nombre de usuario: "Tomxu"
};
validator.config = {
First_Name: 'isNonempty',
Edad: 'isnumber',
Nombre de usuario: 'Isalphanum'
};
Finalmente, el código para obtener el resultado de verificación es simple:
La copia del código es la siguiente:
validator.validate (datos);
if (validator.haserrors ()) {
console.log (validator.messages.Join ("/n"));
}
Resumir
El patrón de estrategia define una serie de algoritmos. Conceptualmente, todos estos algoritmos hacen lo mismo, pero la implementación es diferente. Pueden llamar a todos los métodos de la misma manera, reduciendo el acoplamiento entre varias clases de algoritmo y las clases de algoritmo utilizadas.
Desde otro nivel, definir la clase de algoritmo por separado también facilita las pruebas unitarias, ya que se puede probar por separado a través de su propio algoritmo.
En la práctica, no solo se pueden encapsular los algoritmos, sino también casi cualquier tipo de reglas. Es necesario aplicar diferentes reglas comerciales en diferentes momentos durante el proceso de análisis, por lo que puede considerar que el modelo de política es necesario para manejar diversos cambios.