introduire
Le modèle de stratégie définit la famille des algorithmes et les résume séparément afin qu'ils puissent se remplacer mutuellement. Ce modèle permet aux modifications de l'algorithme de ne pas affecter les clients à l'aide de l'algorithme.
texte
Avant de comprendre le modèle de politique, prenons d'abord un exemple. D'une manière générale, si nous voulons vérifier la légitimité des données, nous jugeons souvent selon la déclaration de balayage, mais cela apporte plusieurs problèmes. Tout d'abord, si nous augmentons la demande, nous devons modifier à nouveau ce code pour augmenter la logique, et il deviendra de plus en plus compliqué lors de la réalisation de tests unitaires. Le code est le suivant:
La copie de code est la suivante:
validator = {
valider: fonction (valeur, type) {
commutateur (type) {
Cas «ISNONEMPTY»:
{
Retour Vrai; // Résultat de vérification non vide
}
cas «isNumber»:
{
Retour Vrai; // Résultat de vérification du numéro
casser;
}
cas «Isalphanum»:
{
Retour Vrai; // Résultat de vérification de l'alphanum
}
défaut:
{
Retour Vrai;
}
}
}
};
// test
alert (validator.validate ("123", "isNonEmpty"));
Alors, comment éviter les problèmes dans le code ci-dessus? Selon le modèle de stratégie, nous pouvons encapsuler séparément le même code de travail dans différentes classes, puis le gérer via une classe de traitement de stratégie unifiée. OK, nous définissons d'abord la classe de traitement des politiques, le code est le suivant:
La copie de code est la suivante:
var validator = {
// Tous les endroits où toutes les classes de traitement des règles de validation peuvent être stockées seront définies séparément plus tard
types: {},
// Message d'erreur correspondant au type de vérification
messages: [],
// Bien sûr, le type de vérification qui doit être utilisé
config: {},
// Méthode de vérification publique exposée
// Le paramètre passé est clé => paire de valeurs
valider: fonction (données) {
var i, msg, type, checker, result_ok;
// effacer tous les messages d'erreur
this.messages = [];
pour (i en données) {
if (data.hasownproperty (i)) {
type = this.config [i]; // Vérifiez s'il existe une règle de validation basée sur la clé
checker = this.types [type]; // Obtenez la classe de vérification pour la règle de vérification
if (! type) {
continuer; // Si la règle de vérification n'existe pas, elle ne sera pas traitée
}
if (! checker) {// Si la classe de règles de vérification n'existe pas, une exception est jetée
lancer {
Nom: "ValidationError",
Message: "Pas de gestionnaire pour valider le type" + type
};
}
result_ok = checker.validate (data [i]); // Vérifiez l'utilisation d'une seule classe de vérification trouvée
if (! result_ok) {
msg = "valeur non valide pour *" + i + "*," + checker.instructions;
this.sessages.push (msg);
}
}
}
Renvoyez ceci.haserrors ();
},
// assistant
HasErrors: function () {
retourne this.messages.length! == 0;
}
};
Ensuite, le reste est de définir les différentes classes de vérification stockées en types. Nous donnons quelques exemples ici:
La copie de code est la suivante:
// Vérifiez que la valeur donnée n'est pas vide
validator.types.isNonEmpty = {
valider: fonction (valeur) {
Valeur de retour! == "";
},
Instructions: "La valeur passée ne peut pas être vide"
};
// Vérifiez que la valeur donnée est un nombre
validator.types.isnumber = {
valider: fonction (valeur) {
return! Isnan (valeur);
},
Instructions: "La valeur transmise ne peut être qu'un numéro légal, par exemple: 1, 3.14 ou 2010"
};
// Vérifiez que la valeur donnée n'est qu'une lettre ou un nombre
validator.types.isalphanum = {
valider: fonction (valeur) {
return! / [^ a-z0-9] /i.test (valeur);
},
Instructions: "La valeur passée ne peut protéger que des lettres et des chiffres et ne peut pas contenir de caractères spéciaux"
};
Lorsque vous l'utilisez, nous devons d'abord définir l'ensemble de données qui doit être vérifié, puis nous devons définir le type de règle qui doit être vérifié pour chaque données. Le code est le suivant:
La copie de code est la suivante:
var data = {
First_name: "Tom",
last_name: "xu",
Âge: "inconnu",
Nom d'utilisateur: "Tomxu"
};
validator.config = {
First_name: «IsNonEmpty»,
Âge: «Isnumber»,
Nom d'utilisateur: 'Isalphanum'
};
Enfin, le code pour obtenir le résultat de vérification est simple:
La copie de code est la suivante:
validator.validate (données);
if (validator.haserrors ()) {
console.log (validator.messages.join ("/ n"));
}
Résumer
Le modèle de stratégie définit une série d'algorithmes. Conceptuellement, tous ces algorithmes font la même chose, mais l'implémentation est différente. Ils peuvent appeler toutes les méthodes de la même manière, en réduisant le couplage entre les différentes classes d'algorithmes et les classes d'algorithmes utilisées.
À partir d'un autre niveau, définir séparément la classe d'algorithme facilite également les tests unitaires, car il peut être testé séparément via votre propre algorithme.
En pratique, non seulement les algorithmes peuvent être encapsulés, mais aussi presque tous les types de règles. Il est nécessaire d'appliquer différentes règles commerciales à différents moments du processus d'analyse, vous pouvez donc considérer que le modèle de politique est nécessaire pour gérer divers changements.