Dans un projet récent, la vérification du formulaire nécessite un jugement sur le temps de départ et de fin: l'heure de fin doit être supérieure ou égale à l'heure de début. C'est-à-dire: l'année de fin doit être supérieure à l'année de départ; Ensuite, pour chaque vérification, vous pouvez utiliser la fonction suivante pour comparer.
fonction compare (begin, end, error) {
var begin = parseInt (begin, 10);
var end = paSeInt (end, 10);
var diff = end - begin;
if (diff <0) {
alert (erreur);
}autre{
Retour Vrai;
}
}
De cette façon, lorsque la vérification, tant que le résultat revient vrai, cela signifie qu'il passe. comme:
Var Year = Compare (2001 2003, «année»);
var mois = comparer (1,2, «mois»);
var day = comparer (12,13, «jour»);
alerte (an && mois et jour); // le résultat est vrai ------- "true"
Changez les mois de départ et de fin et de démarrer et de terminer les dates ci-dessus. comme:
Var Year = Compare (2001 2003, «année»);
var mois = comparer (3,2, «mois»);
var day = comparer (24,13, «jour»);
alerte (an && mois && day); / le résultat est faux ------ "false"
Les résultats de l'exécution sont affichés en séquence, "mois", "jour", "faux"; en fait, lorsque les mois de début et de fin sont incorrects, nous n'avons pas besoin de vérifier la date est adopté; la condition préalable à la vérification du jour est que la vérification du mois est adoptée. Après une analyse minutieuse, j'ai décidé de stocker les trois paramètres de la fonction ci-dessus en mode monolithique, à savoir:
{
Begin: 2001,
Fin: 2003,
Erreur: "La période de fin doit être supérieure à la période de départ"
}
Cependant, je ne veux pas définir les paramètres de la fonction. La réponse est oui. Au début de la fonction, déterminez d'abord le nombre de paramètres. Comment faire un traitement récursif? J'ai fait ce qui suit à l'intérieur de la fonction:
var len = arguments.length;
if (len> 1) {
var args = array.prototype.slice.call (arguments);
args.shift ();
}
Pour les arguments, nous ne pouvons pas appeler directement la méthode array.shift (). Bien que les arguments aient un attribut de longueur, ils ne sont pas un tableau après tout, utilisez donc la méthode array.slice () pour le convertir en tableau. En ce qui concerne les arguments, vous pouvez en savoir plus à ce sujet en ligne, donc je n'entrerai pas dans les détails ici. Pourquoi est-il traité que si Len est supérieur à 1? Parce que lorsque le paramètre est 1, il n'est pas nécessaire d'effectuer l'étape de vérification suivante. Quand le traitement récursif sera-t-il effectué? Si vous y pensez soigneusement, il est nécessaire que la valeur initiale soit égale à la valeur finale.
var diff = parseInt (arguments [0] .end, 10) - parseInt (arguments [0] .begin, 10);
if (diff <0) {
alerte (arguments [0] .Error);
retourne false;
} else if (diff == 0) {
retourner len> 1?
}autre{
Retour Vrai;
}
Dans le code ci-dessus, les arguments.Callee sont la fonction elle-même.
La fonction de vérification est terminée, mais il convient de noter que:
Bien que le nombre de paramètres ne soit pas déterminé, l'ordre des paramètres est toujours important, car le résultat de vérification du paramètre précédent détermine si la vérification du paramètre suivant se poursuit;
Le deuxième paramètre 10 de la fonction parseInt () ne doit pas être ignoré. S'il est ignoré, lorsqu'une valeur commençant par 0 (comme 07, 08) est rencontrée, elle sera traitée en octal.
C'est ici, regardez les exemples . Parfois, nous ne voulons pas afficher des messages d'erreur en mode alerte, nous pouvons personnaliser le gestionnaire pour le passer en tant que dernier paramètre. Ensuite, au début de la fonction, obtenez la fonction de traitement, comme:
var func = arguments [len - 1];
if (typeof func == 'function') {
func (arguments [0]);
}
Ainsi, la fonction de traitement finale est comme ceci:
fonction compare () {
var len = arguments.length;
var func = arguments [len - 1];
if (len> 1) {
var args = array.prototype.slice.call (arguments);
args.shift ();
}
var diff = parseInt (arguments [0] .end, 10) - parseInt (arguments [0] .begin, 10);
if (diff <0) {
(typeof func == 'fonction')?
retourne false;
} else if (diff == 0) {
retourner len> 1?
}autre{
Retour Vrai;
}
}
fonction compare () {
var len = arguments.length;
if (len> 1) {
var args = array.prototype.slice.call (arguments);
args.shift ();
}
var diff = parseInt (arguments [0] .end, 10) - parseInt (arguments [0] .begin, 10);
if (diff <0) {
alerte (arguments [0] .Error);
retourne false;
} else if (diff == 0) {
retourner len> 1?
}autre{
Retour Vrai;
}
}