In einem aktuellen Projekt erforderte die Formularvalidierung die Beurteilung des Start- und Endzeitbereichs: Die Endzeit muss größer oder gleich der Startzeit sein. Das heißt: Das Endjahr muss größer sein als das Startjahr. Wenn sie gleich sind, vergleichen Sie den Startmonat und den Endmonat. Wenn Start- und Endmonat ebenfalls gleich sind, vergleichen Sie die Daten. Anschließend können Sie für jede Überprüfung die folgende Funktion zum Vergleich verwenden.
Funktion vergleichen(begin,end,error){
var begin = parseInt(begin,10);
var end = parseInt(end,10);
var diff = end – begin;
if(diff < 0){
Warnung(Fehler);
}anders{
return true;
}
}
Auf diese Weise bedeutet während der Überprüfung, dass das Ergebnis bestanden wird, solange es „true“ zurückgibt. wie:
var Jahr = vergleichen(2001,2003,'Jahr');
var Monat = vergleichen(1,2,'Monat');
var Tag = vergleichen(12,13,'Tag');
Alert(Jahr && Monat && Tag); //Das Ergebnis ist wahr------"wahr"
Ändern Sie oben die Start- und Endmonate sowie das Start- und Enddatum. wie:
var Jahr = vergleichen(2001,2003,'Jahr');
var Monat = vergleichen(3,2,'Monat');
var Tag = vergleichen(24,13,'Tag');
Alert(Jahr && Monat && Tag); /Das Ergebnis ist falsch------"false"
Das Ausführungsergebnis zeigt nacheinander „Monat“, „Tag“ und „falsch“ an. Wenn der Anfangs- und Endmonat falsch ist, müssen wir das Datum nicht überprüfen besteht die Voraussetzung für die Tagesverifizierung. Der Monat ist verifiziert. Nach sorgfältiger Analyse habe ich beschlossen, die drei Parameter der obigen Funktion im Singleton-Modus zu speichern, nämlich:
{
Beginn:2001,
Ende:2003,
Fehler: „Das Endjahr muss größer sein als das Startjahr“
}
Ich möchte jedoch nicht die Parameter der Funktion definieren. Kann die Funktion automatisch anhand der übergebenen Parameter überprüfen? Die Antwort ist ja. Bestimmen Sie zu Beginn der Funktion zunächst die Anzahl der Parameter. Wenn sie größer als 1 ist, enthält sie eine rekursive Verarbeitung. Wie führt man eine rekursive Verarbeitung durch? Ich habe in der Funktion Folgendes getan:
var len = arguments.length;
if(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Entferne den ersten Parameter und verwende die restlichen Parameter für die rekursive Verarbeitung
}
Für Argumente können wir die Methode Array.shift() nicht direkt aufrufen. Obwohl arguments über ein Längenattribut verfügt, handelt es sich letztlich nicht um ein Array. Verwenden Sie daher die Methode Array.slice(), um es in ein Array umzuwandeln. Zu den Argumenten können Sie sich online näher informieren und werden hier nicht näher darauf eingehen. Warum wird es nur verarbeitet, wenn len größer als 1 ist? Denn wenn der Parameter 1 ist, ist es nicht erforderlich, den nächsten Schritt der Überprüfung durchzuführen. Wann findet eine rekursive Verarbeitung statt? Wenn Sie sorgfältig darüber nachdenken, ist dies nur erforderlich, wenn der Anfangswert und der Endwert gleich sind. Wenn wir dies verstehen, können wir unsere Verifizierungsfunktion problemlos erstellen.
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
if(diff <0 ){
alarm(arguments[0].error);
return false;
}else if(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}anders{
return true;
}
Im obigen Code ist arguments.callee die Funktion selbst. Zur Verwendung von apply finden Sie relevante Informationen im Internet.
Zu diesem Zeitpunkt ist die Verifizierungsfunktion abgeschlossen, Sie müssen jedoch Folgendes beachten:
Das war’s fürs Erste, schauen wir uns die Beispiele an. Manchmal möchten wir Fehlerinformationen nicht in Form einer Warnung anzeigen. Wir können die Verarbeitungsfunktion anpassen und sie als letzten Parameter übergeben. Rufen Sie dann am Anfang der Funktion die Verarbeitungsfunktion ab, z. B.:
var func = arguments[len - 1];
if(typeof func == 'function'){
func(arguments[0]);
}
Die endgültige Verarbeitungsfunktion sieht also wie folgt aus:
Funktion vergleichen(){
var len = arguments.length;
var func = arguments[len - 1];
if(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Entferne den ersten Parameter und verwende die restlichen Parameter für die rekursive Verarbeitung
}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
if(diff <0 ){
(typeof func == 'function') ? func(arguments[0].error) : Alert(arguments[0].error);
return false;
}else if(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}anders{
return true;
}
}
Funktion vergleichen(){
var len = arguments.length;
if(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Entferne den ersten Parameter und verwende die restlichen Parameter für die rekursive Verarbeitung
}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
if(diff <0 ){
alarm(arguments[0].error);
return false;
}else if(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}anders{
return true;
}
}