Dans un projet récent, la validation du formulaire nécessitait de juger de la plage horaire de début et de fin : l'heure de fin doit être supérieure ou égale à l'heure de début. Autrement dit : l'année de fin doit être supérieure à l'année de début ; si elles sont égales, comparez le mois de début et le mois de fin ; si les mois de début et de fin sont également égaux, comparez les dates ; Ensuite, pour chaque vérification, vous pouvez utiliser la fonction suivante pour comparer.
fonction comparer (début, fin, erreur) {
var commencer = parseInt(début,10);
var end = parseInt(end,10);
var diff = fin - début ;
si(diff < 0){
alerte (erreur);
}autre{
renvoie vrai ;
}
}
De cette façon, lors de la vérification, tant que le résultat renvoie vrai, cela signifie qu'il est réussi. comme:
var année = comparer(2001,2003,'année');
var mois = comparer(1,2,'mois');
var jour = comparer(12,13,'jour');
alert(année && mois && jour); //Le résultat est vrai------"vrai"
Modifiez les mois de début et de fin ainsi que les dates de début et de fin ci-dessus. comme:
var année = comparer(2001,2003,'année');
var mois = comparer(3,2,'mois');
var jour = comparer(24,13,'jour');
alert(année && mois && jour); /Le résultat est faux------"faux"
Le résultat de l'exécution affiche « mois », « jour » et « faux » dans l'ordre ; en fait, lorsque les mois de début et de fin sont incorrects, nous n'avons pas besoin de vérifier la date, la condition préalable à la vérification du mois est la vérification de l'année ; réussit; la condition préalable à la vérification du jour Le mois est vérifié. Après une analyse minutieuse, j'ai décidé de stocker les trois paramètres de la fonction ci-dessus en mode singleton, à savoir :
{
début : 2001,
fin : 2003,
erreur : "L'année de fin doit être supérieure à l'année de début"
}
Cependant, je ne souhaite pas définir les paramètres de la fonction. La fonction peut-elle vérifier automatiquement en fonction des paramètres transmis ? La réponse est oui. Au début de la fonction, déterminez d'abord le nombre de paramètres. S'il est supérieur à 1, elle contient un traitement récursif. Comment faire un traitement récursif ? J'ai fait ce qui suit dans la fonction :
var len = arguments.longueur;
si(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Supprimez le premier paramètre et utilisez les paramètres restants pour le traitement récursif
}
Pour les arguments, nous ne pouvons pas appeler directement la méthode Array.shift(). Bien que les arguments aient un attribut de longueur, ce n'est pas un tableau après tout, utilisez donc la méthode Array.slice() pour le convertir en tableau. Concernant les arguments, vous pouvez obtenir plus d’informations en ligne et n’entrerez pas dans les détails ici. Pourquoi n'est-il traité que lorsque len est supérieur à 1 ? Car lorsque le paramètre est 1, il n’est pas nécessaire d’effectuer l’étape suivante de vérification. Quand le traitement récursif a-t-il lieu ? Si vous y réfléchissez bien, cela n'est nécessaire que lorsque la valeur initiale et la valeur finale sont égales. En comprenant cela, nous pouvons facilement construire notre fonction de vérification.
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
si(diff <0 ){
alerte(arguments[0].erreur);
renvoie faux ;
}sinon si(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}autre{
renvoie vrai ;
}
Dans le code ci-dessus, arguments.callee est la fonction elle-même. Concernant l'utilisation de apply, vous pouvez trouver des informations pertinentes sur le Web.
À ce stade, la fonction de vérification est terminée, mais vous devez faire attention aux points suivants :
C'est tout pour l'instant, regardons les exemples . Parfois, nous ne souhaitons pas afficher les informations d'erreur sous forme d'alerte. Nous pouvons personnaliser la fonction de traitement et la transmettre comme dernier paramètre. Puis au début de la fonction, récupérez la fonction de traitement, telle que :
var func = arguments[len - 1];
if(typeof func == 'fonction'){
fonction(arguments[0]);
}
Ainsi, la fonction de traitement finale ressemble à ceci :
fonction comparer(){
var len = arguments.longueur;
var func = arguments[len - 1];
si(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Supprimez le premier paramètre et utilisez les paramètres restants pour le traitement récursif
}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
si(diff <0 ){
(type de fonction == 'fonction') ? func(arguments[0].error) : alert(arguments[0].error);
renvoie faux ;
}sinon si(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}autre{
renvoie vrai ;
}
}
fonction comparer(){
var len = arguments.longueur;
si(len > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); //Supprimez le premier paramètre et utilisez les paramètres restants pour le traitement récursif
}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
si(diff <0 ){
alerte(arguments[0].erreur);
renvoie faux ;
}sinon si(diff == 0){
return len > 1 ? arguments.callee.apply(this,args) : true;
}autre{
renvoie vrai ;
}
}