表单验证中时间起止判断的递归处理

在最近一个项目中，表单验证需要对时间的起止范围进行判断：结束时间需大于或等于开始时间。即：结束年须大于起始年；如果相等，则比较起始月与结束月；如果起止月也相等，则比较日期。那么，对于每一次验证，可以用下面这个函数来进行比较。

1. function compare(begin,end,error){
   
2.   var begin = parseInt(begin,10);
   
3.   var end = parseInt(end,10);
   
4.   var diff = end - begin;
   
5.   if(diff < 0){
   
6.       alert(error);
   
7.   }else{
   
8.       return true;
   
9.   }
   
10. }

这样，在验证的时候，只要结果返回真就表示通过。如：

1. var year = compare(2001,2003,'年');
   
2. var month = compare(1,2,'月');
   
3. var day = compare(12,13,'天');
   
4. alert(year && month && day); //结果为真------"true"

将上面的起止月份和起止日期修改一下。如：

1. var year = compare(2001,2003,'年');
   
2. var month = compare(3,2,'月');
   
3. var day = compare(24,13,'天');
   
4. alert(year && month && day); /结果为假------"false"

执行结果，依次显示”月”，”天”，”false”；实际上，当起止月份不正确的时候，我们没必要对日期进行验证；月份验证的前提条件是年验证通过；天验证的前提是月份验证通过。仔细分析之后，我决定将上面函数的三个参数用单体模式存储起来，即：

1. {
   
2.   begin:2001,
   
3.   end:2003,
   
4.   error:"结束年限须大于起始年限"
   
5. }

但是，我又不想定义函数的参数，函数能否根据传递的参数自动进行验证了？答案是肯定的。在函数的开始，先判断参数的个数，如果大于1，则含有递归处理。如何做到递归处理呢？我在函数内部作了如下处理：

1. var len = arguments.length;
   
2. if(len > 1){
   
3.   var args = Array.prototype.slice.call(arguments);
   
4.   args.shift(); //将第一个参数移除，余下的用作递归处理的参数
   
5. }

对于arguments，我们不能直接调用Array.shift()方法。虽然 arguments有length属性，但毕竟不是数组，所以用Array.slice()方法将其转换成数组。关于arguments，在网上可以了解到更多的信息，这里不在赘述。为什么只有在len大于1时才进行处理呢？因为参数为1时，就不需要进行下一步验证了。递归处理在什么时候进行呢？仔细想想，只有在初始值与结束值相等时才需要，明白了这些，我们就很容易构建我们的验证函数了。

1. var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
   
2. if(diff <0 ){
   
3.   alert(arguments[0].error);
   
4.   return false;
   
5. }else if(diff == 0){
   
6.   return len > 1 ? arguments.callee.apply(this,args) : true;
   
7. }else{
   
8.   return true;
   
9. }

复制代码

上面的代码中，arguments.callee是函数自身，关于apply的用法可以在web查找相关资料。

1. function compare(){
   
2.   var len = arguments.length;
   
3.   if(len > 1){
   
4.       var args = Array.prototype.slice.call(arguments);
   
5.       args.shift(); //将第一个参数移除，余下的用作递归处理的参数
   
6. 
   
7.   }
   
8.   var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
   
9.   if(diff <0 ){
   
10.       alert(arguments[0].error);
    
11.       return false;
    
12.   }else if(diff == 0){
    
13.       return len > 1 ? arguments.callee.apply(this,args) : true;
    
14.   }else{
    
15.       return true;
    
16.   }
    
17. }

复制代码

到此验证函数已经完成，但需要注意的是：

 1. 虽然没有确定参数的个数，但参数的顺序还是重要的，因为前一个参数的验证结果决定了下一个参数的验证是否继续；
 2. parseInt()函数的第二个参数10不要忽略。如果忽略，当遇到以0开始的数值（如07、08）时将会按八进制进行处理。

到此已经结束，看看 示例 。有时候，我们不想以alert的方式显示错误信息，我们可以自定义处理函数将其作为最后一个参数传入其中。那么在函数的开始，取得处理函数，如：

1. var func = arguments[len - 1];
   
2. if(typeof func  ==  'function'){
   
3. func(arguments[0]);
   
4. }

复制代码

所以，最终的处理函数是这样的：

1. function compare(){
   
2.   var len = arguments.length;
   
3.   var func = arguments[len - 1];
   
4.   if(len > 1){
   
5.       var args = Array.prototype.slice.call(arguments);
   
6.       args.shift(); //将第一个参数移除，余下的用作递归处理的参数
   
7.   }
   
8.   var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
   
9.   if(diff <0 ){
   
10.       (typeof  func  ==  'function') ? func(arguments[0].error) : alert(arguments[0].error);
    
11.       return false;
    
12.   }else if(diff == 0){
    
13.       return len > 1 ? arguments.callee.apply(this,args) : true;
    
14.   }else{
    
15.       return true;
    
16.   }
    
17. }