einführen
Das Strategiemodell definiert die Algorithmusfamilie und fördert sie separat, damit sie sich gegenseitig ersetzen können. Dieses Modell ermöglicht Änderungen im Algorithmus, um Kunden nicht mit dem Algorithmus zu betreffen.
Text
Bevor Sie das politische Modell verstehen, nehmen wir zunächst ein Beispiel. Im Allgemeinen beurteilen wir häufig nach der Sweep -Erklärung, wenn wir die Datenlegitimität verifizieren möchten, dies bringt jedoch mehrere Probleme mit sich. Wenn wir die Nachfrage erhöhen, müssen wir diesen Code zunächst erneut ändern, um die Logik zu erhöhen, und er wird bei der Durchführung von Unit -Tests immer komplizierter. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
validator = {
Validate: Funktion (Wert, Typ) {
Switch (Typ) {
Fall 'isnoneMpty':
{
zurückkehren; // Nicht leerer Überprüfungsergebnis
}
Fall 'isNumber':
{
zurückkehren; // Nummernüberprüfungsergebnis
brechen;
}
Fall 'Isalphanum':
{
zurückkehren; // Alphanum -Überprüfungsergebnis
}
Standard:
{
zurückkehren;
}
}
}
};
// prüfen
alert (validator.Validate ("123", "isnoneMpty"));
Wie vermeiden Sie die Probleme im obigen Code? Gemäß dem Richtlinienmuster können wir denselben Arbeitscode separat in verschiedene Klassen einschränken und ihn dann über eine einheitliche Richtlinienverarbeitungsklasse verarbeiten. OK, wir definieren zunächst die Richtlinienverarbeitungsklasse, der Code lautet wie folgt:
Die Codekopie lautet wie folgt:
var validator = {
// Alle Orte, an denen alle Verarbeitungsklassen der Validierungsregeln gespeichert werden können, werden später separat definiert
Typen: {},
// Fehlermeldung, die dem Verifizierungstyp entspricht
Nachrichten: [],
// Natürlich der Verifizierungstyp, der verwendet werden muss
Konfiguration: {},
// freigelegte öffentliche Überprüfungsmethode
// Der übergebene Parameter ist Key => Wertpaar
Validat: Funktion (Daten) {
var i, msg, Typ, Checker, result_ok;
// Alle Fehlermeldungen löschen
this.messages = [];
für (i in Daten) {
if (data.hasownProperty (i)) {
type = this.config [i]; // Überprüfen Sie, ob auf dem Schlüssel eine Validierungsregel vorhanden ist
Checker = this.types [Typ]; // Erhalten Sie die Überprüfungsklasse für die Verifizierungsregel
if (! Typ) {
weitermachen; // Wenn die Überprüfungsregel nicht existiert, wird sie nicht verarbeitet
}
if (! Checker) {// Wenn die Verifizierungsregelklasse nicht vorhanden ist, wird eine Ausnahme ausgelöst
werfen {
Name: "ValidationError",
Nachricht: "Kein Handler zum Validieren von Typ" + Typ
};
}
result_ok = Checker.Validate (Daten [i]); // Überprüfen Sie mithilfe einer einzigen Bestätigungsklasse, die gefunden wurde
if (! result_ok) {
msg = "Ungültiger Wert für *" + i + " *," + Checker.Instructions;
this.messages.push (msg);
}
}
}
kehre dies zurück. Haserrors ();
},
// Helfer
Haserrors: function () {
return this.messages.length! == 0;
}
};
Dann besteht der Rest darin, die verschiedenen in Typen gespeicherten Verifizierungsklassen zu definieren. Lassen Sie uns hier ein paar Beispiele geben:
Die Codekopie lautet wie folgt:
// Überprüfen Sie, ob der angegebene Wert nicht leer ist
validator.types.isnoneMpty = {{
Validat: Funktion (Wert) {
Rückgabewert! == "";
},
Anweisungen: "Der übergebene Wert kann nicht leer sein"
};
// Überprüfen Sie, ob der angegebene Wert eine Zahl ist
validator.types.isNumber = {
Validat: Funktion (Wert) {
return! isnan (Wert);
},
Anweisungen: "Der in übergebene Wert kann nur eine gesetzliche Nummer sein, zum Beispiel: 1, 3.14 oder 2010"
};
// Überprüfen Sie, ob der angegebene Wert nur ein Buchstaben oder eine Nummer ist
validator.types.isalphanum = {
Validat: Funktion (Wert) {
return!/[^a-z0-9] /i.test (Wert);
},
Anweisungen: "Der übergebene Wert kann nur Buchstaben und Zahlen schützen und keine Sonderzeichen enthalten."
};
Bei der Verwendung müssen wir zunächst den Datensatz definieren, der überprüft werden muss, und dann müssen wir den Regeltyp definieren, der für jede Daten überprüft werden muss. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
var data = {
First_Name: "Tom",
last_name: "xu",
Alter: "unbekannt",
Benutzername: "Tomxu"
};
validator.config = {
First_Name: 'isnoneMpty',,
Alter: 'IsNumber',
Benutzername: 'Isalphanum'
};
Schließlich ist der Code, um das Verifizierungsergebnis zu erhalten, einfach:
Die Codekopie lautet wie folgt:
validator.Validate (Daten);
if (validator.haserrors ()) {
console.log (validator.messages.join ("/n"));
}
Zusammenfassen
Das Strategiemuster definiert eine Reihe von Algorithmen. Konzeptionell tun all diese Algorithmen dasselbe, aber die Implementierung ist unterschiedlich. Sie können alle Methoden auf die gleiche Weise aufrufen und die Kopplung zwischen verschiedenen Algorithmusklassen und den verwendeten Algorithmusklassen verringern.
Aus einer anderen Ebene erleichtert das Definieren der Algorithmusklasse auch die Testen der Units, da sie separat über Ihren eigenen Algorithmus getestet werden kann.
In der Praxis können nicht nur Algorithmen eingekapselt werden, sondern auch fast jede Art von Regeln. Während des Analyseprozesses müssen verschiedene Geschäftsregeln zu unterschiedlichen Zeiten angewendet werden, damit Sie berücksichtigen können, dass das Richtlinienmodell erforderlich ist, um verschiedene Änderungen zu bearbeiten.