introduzir
O modelo de estratégia define a família do algoritmo e os encapsula separadamente para que eles possam se substituir. Esse modelo permite que as alterações no algoritmo não afetem os clientes usando o algoritmo.
texto
Antes de entender o modelo de política, vamos primeiro dar um exemplo. De um modo geral, se queremos verificar a legitimidade dos dados, muitas vezes julgamos de acordo com a declaração de varredura, mas isso traz vários problemas. Antes de tudo, se aumentarmos a demanda, precisamos modificar esse código novamente para aumentar a lógica e ela se tornará cada vez mais complicada ao realizar testes de unidade. O código é o seguinte:
A cópia do código é a seguinte:
validator = {
Validar: function (valor, tipo) {
switch (tipo) {
Caso 'isNoMepty':
{
retornar true; // resultado de verificação não vazia
}
case 'isNumber':
{
retornar true; // Resultado da verificação do número
quebrar;
}
Caso 'Isalphanum':
{
retornar true; // resultado de verificação de alfano
}
padrão:
{
retornar true;
}
}
}
};
// teste
alert (validator.validate ("123", "isNonEmpty"));
Então, como evitar os problemas no código acima? De acordo com o padrão de política, podemos encapsular o mesmo código de trabalho em diferentes classes separadamente e, em seguida, lidar com uma classe unificada de processamento de políticas. OK, primeiro definimos a classe de processamento de políticas, o código é o seguinte:
A cópia do código é a seguinte:
var validator = {
// Todos os lugares onde todas as regras de validação classes podem ser armazenadas serão definidas separadamente mais tarde
Tipos: {},
// Mensagem de erro correspondente ao tipo de verificação
mensagens: [],
// é claro, o tipo de verificação que precisa ser usado
Config: {},
// Método de verificação pública exposta
// O parâmetro passado é chave => par de valores
Validar: function (dados) {
var i, msg, tipo, verificador, resultado_ok;
// Limpe todas as mensagens de erro
this.Messages = [];
para (i em dados) {
if (data.hasownProperty (i)) {
tipo = this.config [i]; // Verifique se existe uma regra de validação com base na chave
verificador = this.types [type]; // Obtenha a classe de verificação para a regra de verificação
if (! type) {
continuar; // Se a regra de verificação não existir, ela não será processada
}
if (! verificador) {// Se a classe de regra de verificação não existir, uma exceção será lançada
lançar {
Nome: "ValidationError",
Mensagem: "Nenhum manipulador para validar o tipo" + tipo
};
}
resultado_ok = checker.validate (dados [i]); // Verifique usando uma única classe de verificação encontrada
if (! result_ok) {
msg = "Valor inválido para *" + i + " *," + checker.instructions;
this.messages.push (msg);
}
}
}
retornar this.haserrors ();
},
// ajudante
Haserrors: function () {
Retorne this.Messages.Length! == 0;
}
};
Então o resto é definir as várias classes de verificação armazenadas nos tipos. Vamos dar -lhe alguns exemplos aqui:
A cópia do código é a seguinte:
// Verifique se o valor fornecido não está vazio
validator.types.isNonEmpty = {
Validar: function (valor) {
Valor de retorno! == "";
},
Instruções: "O valor passado não pode estar vazio"
};
// Verifique se o valor fornecido é um número
validator.types.isNumber = {
Validar: function (valor) {
retornar! isnan (valor);
},
Instruções: "O valor aprovado pode ser apenas um número legal, por exemplo: 1, 3.14 ou 2010"
};
// Verifique se o valor fornecido é apenas uma carta ou um número
validator.types.isalphanum = {
Validar: function (valor) {
retornar!/[^a-z0-9] /i.test (valor);
},
Instruções: "O valor passado pode proteger apenas letras e números e não pode conter caracteres especiais"
};
Ao usá -lo, primeiro precisamos definir o conjunto de dados que precisa ser verificado e, em seguida, precisamos definir o tipo de regra que precisa ser verificado para cada dados. O código é o seguinte:
A cópia do código é a seguinte:
var dados = {
First_name: "Tom",
Último nome: "xu",
idade: "desconhecido",
Nome de usuário: "Tomxu"
};
validator.config = {
primeiro_name: 'isNonEmpty',
idade: 'isNumber',
Nome de usuário: 'Isalphanum'
};
Finalmente, o código para obter o resultado da verificação é simples:
A cópia do código é a seguinte:
validator.validate (dados);
if (validator.haserrors ()) {
console.log (validator.messages.join ("/n"));
}
Resumir
O padrão de estratégia define uma série de algoritmos. Conceitualmente, todos esses algoritmos fazem a mesma coisa, mas a implementação é diferente. Eles podem chamar todos os métodos da mesma maneira, reduzindo o acoplamento entre várias classes de algoritmo e as classes de algoritmo utilizadas.
De outro nível, definir a classe de algoritmo separadamente também facilita o teste de unidade, porque pode ser testado separadamente através do seu próprio algoritmo.
Na prática, não apenas os algoritmos podem ser encapsulados, mas também quase qualquer tipo de regras. É necessário aplicar regras de negócios diferentes em momentos diferentes durante o processo de análise, para que você possa considerar que o modelo de política é necessário para lidar com várias alterações.