In einem kürzlich durchgeführten Projekt erfordert die Formüberprüfung ein Urteil über den Zeit- und Endbereich der Zeit: Die Endzeit muss größer oder gleich der Startzeit sein. Das heißt: Das Endjahr muss größer sein als das Anfangsjahr; Für jede Überprüfung können Sie dann die folgende Funktion zum Vergleich verwenden.
Funktion vergleich (begin, enden, error) {
var begin = parsesint (begin, 10);
var end = parseInt (Ende, 10);
var diff = Ende - Beginnen Sie;
if (diff <0) {
alarm (Fehler);
}anders{
zurückkehren;
}
}
Auf diese Weise bedeutet es, dass es bei der Überprüfung besteht, sofern das Ergebnis wahr ist, dass es vergeht. wie:
var Jahr = vergleichen (2001.2003, 'Jahr');
var monat = compare (1,2, 'monat');
var tag = compare (12,13, 'tag');
Alert (Jahr && Montal && Tag);
Ändern Sie die Start- und Endmonate und die oben genannten Start- und Enddaten. wie:
var Jahr = vergleichen (2001.2003, 'Jahr');
var monat = compare (3,2, 'monat');
var tag = compare (24,13, 'tag');
ALERT (Jahr && Monat); /das Ergebnis ist falsch ------ "Falsch"
Die Ausführungsergebnisse werden in Sequenz, "Monat", "Tag", "Falsch" angezeigt. wird verabschiedet; die Voraussetzung für die Tagesüberprüfung ist, dass die Monatsüberprüfung verabschiedet wird. Nach sorgfältiger Analyse entschied ich mich, die drei Parameter der obigen Funktion in einem monolithischen Modus zu speichern, nämlich:
{
Beginnen Sie: 2001,
Ende: 2003,
Fehler: "Die Endzeit muss größer sein als die Startperiode"
}
Ich möchte jedoch nicht die Parameter der Funktion definieren. Die Antwort lautet ja. Bestimmen Sie zuerst die Anzahl der Parameter. Wie mache ich eine rekursive Verarbeitung? Ich habe Folgendes in der Funktion gemacht:
var len = argumente.length;
if (len> 1) {
var args = array.prototype.slice.call (Argumente);
args.shift (); // den ersten Parameter entfernen, und der Rest wird als rekursive Verarbeitungsparameter verwendet
}
Für Argumente können wir die Methode array.shift () nicht direkt aufrufen. Obwohl Argumente ein Längenattribut haben, sind sie doch kein Array. Verwenden Sie also die Methode Array.lice (), um es in ein Array umzuwandeln. In Bezug auf Argumente können Sie online mehr darüber erfahren, damit ich hier nicht auf Details eingehen werde. Warum wird es nur verarbeitet, wenn Len größer als 1 ist? Denn wenn der Parameter 1 ist, muss der nächste Überprüfungsschritt nicht durchgeführt werden. Wann wird eine rekursive Verarbeitung durchgeführt? Wenn Sie sorgfältig darüber nachdenken, ist es nur notwendig, wenn der Anfangswert dem Endwert entspricht.
var diff = parseInt (Argumente [0] .end, 10) - ParseInt (Argumente [0] .Begin, 10);
if (diff <0) {
alarm (Argumente [0] .Error);
false zurückgeben;
} else if (diff == 0) {
Len> 1 zurückgeben?
}anders{
zurückkehren;
}
Im obigen Code sind Argumente. Callee ist die Funktion selbst.
Die Überprüfungsfunktion wurde abgeschlossen, aber es sollte beachtet werden, dass:
Obwohl die Anzahl der Parameter nicht bestimmt wird, ist die Reihenfolge der Parameter immer noch wichtig, da das Überprüfungsergebnis des vorherigen Parameters bestimmt, ob die Überprüfung des nächsten Parameters fortgesetzt wird.
Der zweite Parameter 10 der ParseInt () -Funktion sollte nicht ignoriert werden. Wenn ignoriert, wenn ein Wert mit 0 (z. B. 07, 08) auftritt, wird er in Oktal verarbeitet.
Es ist hier drüben, sieh dir die Beispiele an. Manchmal möchten wir keine Fehlermeldungen im Alarmmodus anzeigen. Wir können den Handler so anpassen, dass er als letzter Parameter in ihn weitergegeben wird. Erhalten Sie dann zu Beginn der Funktion die Verarbeitungsfunktion, wie z. B.:
var func = argumente [len - 1];
if (typeof func == 'Funktion') {
Func (Argumente [0]);
}
Die endgültige Verarbeitungsfunktion ist also wie folgt:
Funktion Compare () {
var len = argumente.length;
var func = argumente [len - 1];
if (len> 1) {
var args = array.prototype.slice.call (Argumente);
args.shift (); // den ersten Parameter entfernen, und der Rest wird als rekursive Verarbeitungsparameter verwendet
}
var diff = parseInt (Argumente [0] .end, 10) - ParseInt (Argumente [0] .Begin, 10);
if (diff <0) {
(typeof func == 'Funktion')?
false zurückgeben;
} else if (diff == 0) {
Len> 1 zurückgeben?
}anders{
zurückkehren;
}
}
Funktion Compare () {
var len = argumente.length;
if (len> 1) {
var args = array.prototype.slice.call (Argumente);
args.shift (); // den ersten Parameter entfernen, und der Rest wird als rekursive Verarbeitungsparameter verwendet
}
var diff = parseInt (Argumente [0] .end, 10) - ParseInt (Argumente [0] .Begin, 10);
if (diff <0) {
alarm (Argumente [0] .Error);
false zurückgeben;
} else if (diff == 0) {
Len> 1 zurückgeben?
}anders{
zurückkehren;
}
}