javascript 实现的Date格式化 js格式化Date

最近在js中使用js操作Date对象的，所以实现类，与大家分享

      更新说明(2013-04-09)：

     1、 最近在项目中使用此方式格式化和转换日期时发现以下问题:

                   月份加减时出现错误，如 2013-01-31 月份加1应该为：2013-02-28，但计算后的为 2013-03-01。在银行方面计算是是按整月加减的。先修改为按整月加减，

                 如 2013-01-31 月份加1后为 2013-02-28。

     2、添加判断当前年份是否为闰年的方法isLeapYear(year)  和 获取当前年份某个月份的总天数方法 getMonthDays(year, mouth);

1. /** 
2.  * 此JS文件是格式化JS中日期时间的工具类，其中包含了传入日期对象Date，格式化成想要的格式，<br> 
3.  * 或者传入字符串格式的时间个，次字符串日期对应的格式可以转换为相应的日期对象，<br> 
4.  * 可以计算两个日期之间的差值 
5.  *  
6.  * y: 表示年 
7.  * M：表示一年中的月份 1~12 
8.  * d: 表示月份中的天数 1~31 
9.  * H：表示一天中的小时数 00~23 
10.  * m: 表示小时中的分钟数 00~59 
11.  * s: 表示分钟中的秒数   00~59 
12.  */  
13.    
14.   var DateFormat = function(){  
15.    this.initialize();  
16.   }  
17.    
18.  DateFormat.prototype = {  
19.     //定义一些常用的日期格式的常量  
20.     DEFAULT_DATE_FORMAT: 'yyyy-MM-dd',  
21.     DEFAULT_MONTH_FORMAT: 'yyyy-MM',  
22.     DEFAULT_YEAR_FORMAT: 'yyyy',  
23.     DEFAULT_TIME_FORMAT: 'HH:mm:ss',  
24.     DEFAULT_DATETIME_FORMAT: 'yyyy-MM-dd HH:mm:ss',  
25.     DEFAULT_YEAR: 'YEAR',  
26.     DEFAULT_MONTH: 'MONTH',  
27.     DEFAULT_DATE: 'DATE',  
28.       
29.       
30.     //初始化当前日期  
31.     initialize: function(){  
32.      this.curDate = new Date();  
33.     },  
34.       
35.     /** 
36.      * 根据给定的日期时间格式，格式化当前日期 
37.      * @params strFormat 格式化字符串， 如："yyyy-MM-dd" ,默认：yyyy-MM-dd HH:mm:ss 
38.      * @return 返回根据给定格式的字符串表示的时间日期格式<br> 
39.      *         若给定的格式不符合规定则返回原字符串格式 
40.      */  
41.      formatCurrentDate: function(strFormat){  
42.        try{  
43.           var tempFormat = strFormat === undefined? this.DEFAULT_DATETIME_FORMAT: strFormat;  
44.           var dates = this.getDateObject(this.curDate);  
45.           if(/(y+)/.test(tempFormat)){  
46.              var fullYear = this.curDate.getFullYear() + "";  
47.              var year = RegExp.$1.length == 4? fullYear: fullYear.substr(4 - RegExp.$1.length);  
48.              tempFormat = tempFormat.replace(RegExp.$1, year);  
49.           }  
50.           for(var i in dates){  
51.              if(new RegExp("(" + i + ")").test(tempFormat)){  
52.                 var target = RegExp.$1.length == 1? dates[i]: ("0" + dates[i]).substr(("" + dates[i]).length - 1);  
53.                 tempFormat = tempFormat.replace(RegExp.$1, target);  
54.              }  
55.           }  
56.           return tempFormat;  
57.        }catch(e){  
58.           this.debug('格式化日期出现异常：' + e.message);  
59.        }  
60.     },  
61.       
62.       
63.     /** 
64.      * 根据给定的格式，把给定的时间进行格式化 
65.      * @params date 要格式化的日期 
66.      * @params strFormat 要得到的日期的格式的格式化字符串，如：'yyyy-MM-dd'，默认：yyyy-MM-dd HH:mm:ss 
67.      * @return 根据规定格式的时间格式 
68.      *   
69.      * @updateDate 2011-09-15 
70.      */  
71.     format: function(date, strFormat){  
72.      try{  
73.         if(typeof date === 'undefined'){  
74.            this.curDate = new Date();  
75.         }else if(!(date instanceof Date)){  
76.            this.debug(date + '你输入的不是日期类型');  
77.            return date;  
78.         }else{  
79.            this.curDate = date;  
80.         }  
81.         return this.formatCurrentDate(strFormat);  
82.      }catch(e){  
83.      }  
84.     },  
85.       
86.     /** 
87.      * 根据给定的格式对给定的字符串日期时间进行解析， 
88.      * @params strDate 要解析的日期的字符串表示,此参数只能是字符串形式的日期，否则返回当前系统日期 
89.      * @params strFormat 解析给定日期的顺序, 如果输入的strDate的格式为{Date.parse()}方法支持的格式，<br> 
90.      *         则可以不传入，否则一定要传入与strDate对应的格式, 若不传入格式则返回当期系统日期。 
91.      * @return 返回解析后的Date类型的时间<br> 
92.      *        若不能解析则返回当前日期<br> 
93.      *        若给定为时间格式 则返回的日期为 1970年1月1日的日期 
94.      * 
95.      * bug: 此方法目前只能实现类似'yyyy-MM-dd'格式的日期的转换，<br> 
96.      *       而'yyyyMMdd'形式的日期，则不能实现 
97.      */  
98.        
99.     parseDate: function(strDate, strFormat){  
100.        if(typeof strDate != "string"){  
101.             return new Date();  
102.        }  
103.       var longTime = Date.parse(strDate);  
104.       if(isNaN(longTime)){  
105.           if(typeof strFormat === 'undefined'){  
106.               this.debug('请输入日期的格式');  
107.              return new Date();  
108.           }  
109.           var tmpDate = new Date();  
110.           var regFormat = /(\w{4})|(\w{2})|(\w{1})/g;  
111.           var regDate = /(\d{4})|(\d{2})|(\d{1})/g;  
112.           var formats = strFormat.match(regFormat);  
113.           var dates = strDate.match(regDate);  
114.           if(typeof formats !== 'undefined' && typeof dates !== 'undefined' && formats.length == dates.length){  
115.             for(var i = 0; i < formats.length; i++){  
116.               var format = formats[i];  
117.               if(format === "yyyy"){  
118.                 tmpDate.setFullYear(parseInt(dates[i], 10));  
119.               }else if(format == "yy"){  
120.                 var prefix = (tmpDate.getFullYear() + "").substring(0, 2);  
121.                 var year = (parseInt(dates[i], 10) + "").length == 4? parseInt(dates[i], 10): prefix + (parseInt(dates[i], 10) + "00").substring(0, 2);  
122.                 var tmpYear = parseInt(year, 10);  
123.                 tmpDate.setFullYear(tmpYear);  
124.               }else if(format == "MM" || format == "M"){  
125.                 tmpDate.setMonth(parseInt(dates[i], 10) - 1);  
126.               }else if(format == "dd" || format == "d"){  
127.                 tmpDate.setDate(parseInt(dates[i], 10));  
128.               }else if(format == "HH" || format == "H"){  
129.                 tmpDate.setHours(parseInt(dates[i], 10));  
130.               }else if(format == "mm" || format == "m"){  
131.                 tmpDate.setMinutes(parseInt(dates[i], 10));  
132.               }else if(format == "ss" || format == "s"){  
133.                 tmpDate.setSeconds(parseInt(dates[i], 10));  
134.               }  
135.             }  
136.            return tmpDate;  
137.          }  
138.           return tmpDate;  
139.         }else{  
140.           return new Date(longTime);  
141.         }  
142.     },  
143.       
144.       
145.     /** 
146.      * 根据给定的时间间隔类型及间隔值，以给定的格式对给定的时间进行计算并格式化返回 
147.      * @params date 给定的时间 
148.      * @params interval 时间间隔类型如："YEAR"、"MONTH"、 "DATE", 不区分大小写 
149.      * @params amount 时间间隔值，可以正数和负数 
150.      * @params strFormat 时间格式 
151.      * @return 返回计算并格式化后的时间的字符串 
152.      */  
153.     changeDate: function(date, interval, amount, strFormat){  
154.         var tmpdate = new Date();  
155.         if(typeof date == "string"){  
156.             tmpdate = this.parseDate(date, strFormat);  
157.         }else if(date instanceof Date){  
158.           tmpdate = date;  
159.         }  
160.         var field  =  (typeof interval == "string")? interval.toUpperCase(): "DATE";  
161.         if(!(typeof amount == "number")){  
162.           amount = 0;  
163.         }  
164.         if(field == this.DEFAULT_YEAR){  
165.           tmpdate.setFullYear(tmpdate.getFullYear() + amount);  
166.         }else if(field == this.DEFAULT_MONTH){  
167.           //tmpdate.setMonth(tmpdate.getMonth() + amount);  
168.           tempdate = this.calculateMonth(tmpdate, amount);  
169.         }else if(field == this.DEFAULT_DATE){  
170.           tmpdate.setDate(tmpdate.getDate() + amount);  
171.         }  
172.         this.curDate = tmpdate;  
173.         return this.formatCurrentDate(strFormat);  
174.     },  
175.       
176.     /** 
177.      * 比较两个日期的差距 
178.      * @param date1 Date类型的时间 
179.      * @param date2 Dete 类型的时间 
180.      * @param isFormat boolean 是否对得出的时间进行格式化,<br>  
181.      *       false:返回毫秒数，true：返回格式化后的数据 
182.      * @return 返回两个日期之间的毫秒数 或者是格式化后的结果 
183.      */  
184.     compareTo: function(date1, date2, isFormat){  
185.       try{  
186.             var len = arguments.length;  
187.             var tmpdate1 = new Date();  
188.             var tmpdate2 = new Date();  
189.             if(len == 1){  
190.                tmpdate1 = date1;  
191.             }else if(len >= 2){  
192.               tmpdate1 = date1;  
193.               tmpdate2 = date2;  
194.             }  
195.         if(!(tmpdate1 instanceof Date) || !(tmpdate2 instanceof Date)){  
196.            //alert("请输入正确的参数！");  
197.            return 0;  
198.         }else{  
199.             var time1 = tmpdate1.getTime();   
200.             var time2 = tmpdate2.getTime();  
201.             var time = Math.max(time1, time2) - Math.min(time1, time2);  
202.             if(!isNaN(time) && time > 0){  
203.                if(isFormat){  
204.                   var date = new Date(time);  
205.                   var result = {};  
206.                   /*result += (date.getFullYear() - 1970) > 0? (date.getFullYear() - 1970) + "年":""; 
207.                   result += (date.getMonth() - 1) > 0? (date.getMonth() - 1) + "月": ""; 
208.                   result += (date.getDate() - 1) > 0? (date.getDate() - 1) + "日": ""; 
209.                   result += (date.getHours() - 8) > 0? (date.getHours() - 1) + "小时": ""; 
210.                   result += date.getMinutes() > 0? date.getMinutes() + "分钟": ""; 
211.                   result += date.getSeconds() > 0? date.getSeconds() + "秒": "";*/  
212.                   result['year']   = (date.getFullYear() - 1970) > 0? (date.getFullYear() - 1970): "0";  
213.                   result['month']  = (date.getMonth() - 1) > 0? (date.getMonth() - 1): "0";  
214.                   result['day']    = (date.getDate() - 1) > 0? (date.getDate() - 1): "0";  
215.                   result['hour']   = (date.getHours() - 8) > 0? (date.getHours() - 1): "0";  
216.                   result['minute'] = date.getMinutes() > 0? date.getMinutes(): "0";  
217.                   result['second'] = date.getSeconds() > 0? date.getSeconds(): "0";  
218.                   return result;  
219.                 }else {  
220.                  return time;  
221.                 }  
222.             }else{  
223.               return 0;  
224.             }  
225.         }  
226.       }catch(e){  
227.         //alert(e.message);  
228.       }  
229.     },  
230.       
231.     /** 
232.      * 按月份进行加减 计算规则如下：<br> 
233.      *   1、如果传入的日期的日数值小于对应月份总天数且小于计算的新的月份的总天数，则日为当前日数值，月份为新计算的月份<br> 
234.      *   2、如果传入的日期的月份总天数大于等于新计算得到的月份的总天数，则日为新计算月份的最后一天，月份为新计算的月份<br> 
235.      *   3、如果传入的日期的月份总天数小于新计算得到的月份的总天数，则日为新计算月份的最后一天，月份为新计算的月份<br> 
236.      * @date 日期 
237.      * @params amount 月份加减的数值 负值代表减月，正值代表加月 
238.      * @returns 返回计算后的日期 
239.      */  
240.     calculateMonth: function(date, amount){  
241.         if(undefined == date || !(date instanceof Date) ){  
242.             return date;  
243.         }  
244.         if(!(typeof amount == "number")){  
245.              return date;  
246.         }  
247.         var _month = date.getMonth();  
248.         var _day = date.getDate();  
249.         var _newMonth = parseInt((_month + amount) % 12); //根据传入的数值和日期月份计算出新的月份  
250.         var _newYear = date.getFullYear() + parseInt((_month + amount) / 12); //根据传入的数值和日期计算出新的年份  
251.         //START 当传入的数值为负值时重新计算新的月份和年份  
252.         if(amount < 0){  
253.             _newYear = date.getFullYear() - parseInt((12 - amount) / 12);  
254.             _newMonth = parseInt((12 + (_month + amount)));  
255.         }  
256.         //END  
257.         var _oldMonthDay = this.getMonthDays(date.getFullYear(), _month); //根据传入的日期年份和月份获取对应月份的总天数  
258.         var mouthDays = this.getMonthDays(_newYear, _newMonth);  //根据计算出的新的年份和月份获取对应月份的总天数  
259.         date.setFullYear(_newYear);  
260.         if((_day < _oldMonthDay && _day < mouthDays)){  
261.             date.setDate(_day);  
262.             date.setMonth(_newMonth);  
263.         }else if(mouthDays <= _oldMonthDay){  
264.             date.setDate(mouthDays);  
265.             date.setMonth(_newMonth);  
266.         }else{  
267.             date.setMonth(_newMonth);  
268.             date.setDate(mouthDays);  
269.         }  
270.         return date;  
271.     },  
272.       
273.     /** 
274.      * 判断是否为闰年 
275.      * @params year 要判断的年份 
276.      * @return  是：true, 否：false 
277.      */  
278.     isLeapYear: function(year){  
279.         var _year = year + '';  
280.          if(!(/^\d{4}$/.test(_year))){  
281.              return false;  
282.          }  
283.        _year = _year * 1;  
284.        var is4 = (_year % 4 == 0) && (_year % 100 != 0); //能被4整除，且不能被100整除  
285.        var is400 = _year % 400 == 0; //能被400整除  
286.        return is4 || is400;  
287.     },  
288.       
289.     /** 
290.      * 获取当期月份的天数,JS中获取的月份是从0开始计算 
291.      * @param year 要判断的月份所在年份 
292.      * @param month 当前月份 
293.      */  
294.     getMonthDays: function(year, month){  
295.         var _newMonth = month;  
296.         //1,3,5,7,8,10,12月份为31天  
297.         if(0 == _newMonth || 2 == _newMonth || 4 == _newMonth || 6 == _newMonth || 7 == _newMonth || 9 == _newMonth || 11 == _newMonth){  
298.             return 31;  
299.         }else if(3 == _newMonth || 5 == _newMonth || 8 == _newMonth || 10 == _newMonth){//4,6,9,11月份为30天  
300.             return 30;  
301.         }else{  
302.             return (this.isLeapYear(year)? 29: 28); //2月份闰年29天,平年28天  
303.         }  
304.     },  
305.       
306.     /** 
307.      * 根据给定的日期得到日期的月，日，时，分和秒的对象 
308.      * @params date 给定的日期 date为非Date类型， 则获取当前日期 
309.      * @return 有给定日期的月、日、时、分和秒组成的对象 
310.      */  
311.     getDateObject: function(date){  
312.          if(!(date instanceof Date)){  
313.            date = new Date();  
314.          }  
315.         return {  
316.             "M+" : date.getMonth() + 1,   
317.             "d+" : date.getDate(),     
318.             "H+" : date.getHours(),     
319.             "m+" : date.getMinutes(),   
320.             "s+" : date.getSeconds()  
321.          };  
322.     },  
323.       
324.     /** 
325.      *在控制台输出日志 
326.      *@params message 要输出的日志信息 
327.      */  
328.     debug: function(message){  
329.         if(!window.console){  
330.            window.console = {};  
331.            window.console.log = function(){  
332.               return;  
333.            }  
334.         }  
335.         window.console.log(message + ' ');  
336.     }  
337. }  

          

    最新代码，对以前代码的bug修复，

      更新日期：2011-09-15

        

[javascript]  view plain  copy

1. /** 
2.  * 此JS文件是格式化JS中日期时间的工具类，其中包含了传入日期对象Date，格式化成想要的格式，<br> 
3.  * 或者传入字符串格式的时间个，次字符串日期对应的格式可以转换为相应的日期对象，<br> 
4.  * 可以计算两个日期之间的差值 
5.  *  
6.  * y: 表示年 
7.  * M：表示一年中的月份 1~12 
8.  * d: 表示月份中的天数 1~31 
9.  * H：表示一天中的小时数 00~23 
10.  * m: 表示小时中的分钟数 00~59 
11.  * s: 表示分钟中的秒数   00~59 
12.  */  
13.     
14.   var DateFormat = function(bDebug){  
15.       this.isDebug = bDebug || false;  
16.       this.curDate = new Date();  
17.   }  
18.    
19.  DateFormat.prototype = {  
20.     //定义一些常用的日期格式的常量  
21.     DEFAULT_DATE_FORMAT: 'yyyy-MM-dd',  
22.     DEFAULT_MONTH_FORMAT: 'yyyy-MM',  
23.     DEFAULT_YEAR_FORMAT: 'yyyy',  
24.     DEFAULT_TIME_FORMAT: 'HH:mm:ss',  
25.     DEFAULT_DATETIME_FORMAT: 'yyyy-MM-dd HH:mm:ss',  
26.     DEFAULT_YEAR: 'YEAR',  
27.     DEFAULT_MONTH: 'MONTH',  
28.     DEFAULT_DATE: 'DATE',  
29.     DEFAULT_HOUR: 'HOUR',  
30.     DEFAULT_MINUTE: 'MINUTE',  
31.     DEFAULT_SECOND: 'SECOND',  
32.       
33.     /** 
34.      * 根据给定的日期时间格式，格式化当前日期 
35.      * @params strFormat 格式化字符串， 如："yyyy-MM-dd" 默认格式为：“yyyy-MM-dd HH:mm:ss” 
36.      * @return 返回根据给定格式的字符串表示的时间日期格式<br> 
37.      *         如果传入不合法的格式，则返回日期的字符串格式{@see Date#toLocaleString()} 
38.      */  
39.      formatCurrentDate: function(strFormat){  
40.        try{  
41.           var tempFormat = strFormat == undefined? this.DEFAULT_DATETIME_FORMAT: strFormat;  
42.           var dates = this.getDateObject(this.curDate);  
43.           if(/(y+)/.test(tempFormat)){  
44.              var fullYear = this.curDate.getFullYear() + '';  
45.              var year = RegExp.$1.length == 4? fullYear: fullYear.substr(4 - RegExp.$1.length);  
46.              tempFormat = tempFormat.replace(RegExp.$1, year);  
47.           }  
48.           for(var i in dates){  
49.              if(new RegExp('(' + i + ')').test(tempFormat)){  
50.                 var target = RegExp.$1.length == 1? dates[i]: ('0' + dates[i]).substr(('' + dates[i]).length - 1);  
51.                 tempFormat = tempFormat.replace(RegExp.$1, target);  
52.              }  
53.           }  
54.           return tempFormat === strFormat? this.curDate.toLocaleString(): tempFormat;  
55.        }catch(e){  
56.           this.debug('格式化日期出现异常：' + e.message);  
57.        }  
58.     },  
59.       
60.       
61.     /** 
62.      * 根据给定的格式，把给定的时间进行格式化 
63.      * @params date 要格式化的日期 
64.      * @params strFormat 要得到的日期的格式的格式化字符串，如：'yyyy-MM-dd'，默认：yyyy-MM-dd HH:mm:ss 
65.      * @return 根据规定格式的时间格式 
66.      *   
67.      * @updateDate 2011-09-15 
68.      */  
69.     format: function(date, strFormat){  
70.      try{  
71.         if(date == undefined){  
72.            this.curDate = new Date();  
73.         }else if(!(date instanceof Date)){  
74.            this.debug('你输入的date:' + date + '不是日期类型');  
75.            return date;  
76.         }else{  
77.            this.curDate = date;  
78.         }  
79.         return this.formatCurrentDate(strFormat);  
80.      }catch(e){  
81.         this.debug('格式化日期出现异常：' + e.message);  
82.      }  
83.     },  
84.       
85.     /** 
86.      * 根据给定的格式对给定的字符串日期时间进行解析， 
87.      * @params strDate 要解析的日期的字符串表示,此参数只能是字符串形式的日期，否则返回当期系统日期 
88.      * @params strFormat 解析给定日期的顺序, 如果输入的strDate的格式为{Date.parse()}方法支持的格式，<br> 
89.      *         则可以不传入，否则一定要传入与strDate对应的格式, 若不传入格式则返回当期系统日期。 
90.      * @return 返回解析后的Date类型的时间<br> 
91.      *        若不能解析则返回当前日期<br> 
92.      *        若给定为时间格式 则返回的日期为 1970年1月1日的日期 
93.      * 
94.      * bug: 此方法目前只能实现类似'yyyy-MM-dd'格式的日期的转换，<br> 
95.      *       而'yyyyMMdd'形式的日期，则不能实现 
96.      */  
97.        
98.     parseDate: function(strDate, strFormat){  
99.        if(typeof strDate != 'string'){  
100.             return new Date();  
101.        }  
102.       var longTime = Date.parse(strDate);  
103.       if(isNaN(longTime)){  
104.           if(strFormat == undefined){  
105.               this.debug('请输入日期的格式');  
106.              return new Date();  
107.           }  
108.           var tmpDate = new Date();  
109.           var regFormat = /(\w{4})|(\w{2})|(\w{1})/g;  
110.           var regDate = /(\d{4})|(\d{2})|(\d{1})/g;  
111.           var formats = strFormat.match(regFormat);  
112.           var dates = strDate.match(regDate);  
113.           if( formats != undefined &&  dates != undefined && formats.length == dates.length){  
114.             for(var i = 0; i < formats.length; i++){  
115.               var format = formats[i];  
116.               if(format === 'yyyy'){  
117.                 tmpDate.setFullYear(parseInt(dates[i], 10));  
118.               }else if(format == 'yy'){  
119.                 var prefix = (tmpDate.getFullYear() + '').substring(0, 2);  
120.                 var year = (parseInt(dates[i], 10) + '').length == 4? parseInt(dates[i], 10): prefix + (parseInt(dates[i], 10) + '00').substring(0, 2);  
121.                 var tmpYear = parseInt(year, 10);  
122.                 tmpDate.setFullYear(tmpYear);  
123.               }else if(format == 'MM' || format == 'M'){  
124.                 tmpDate.setMonth(parseInt(dates[i], 10) - 1);  
125.               }else if(format == 'dd' || format == 'd'){  
126.                 tmpDate.setDate(parseInt(dates[i], 10));  
127.               }else if(format == 'HH' || format == 'H'){  
128.                 tmpDate.setHours(parseInt(dates[i], 10));  
129.               }else if(format == 'mm' || format == 'm'){  
130.                 tmpDate.setMinutes(parseInt(dates[i], 10));  
131.               }else if(format == 'ss' || format == 's'){  
132.                 tmpDate.setSeconds(parseInt(dates[i], 10));  
133.               }  
134.             }  
135.            return tmpDate;  
136.          }  
137.           return tmpDate;  
138.         }else{  
139.           return new Date(longTime);  
140.         }  
141.     },  
142.       
143.       
144.     /** 
145.      * 根据给定的时间间隔类型及间隔值，以给定的格式对给定的时间进行计算并格式化返回 
146.      * @params date 要操作的日期时间可以为时间的字符串或者{@see Date}类似的时间对象， 
147.      * @params interval 时间间隔类型如："YEAR"、"MONTH"、 "DATE", 不区分大小写 
148.      * @params amount 时间间隔值，可以正数和负数, 负数为在date的日期减去相应的数值，正数为在date的日期上加上相应的数值 
149.      * @params strFormat 当输入端的date的格式为字符串是，此项必须输入。若date参数为{@see Date}类型是此项会作为最终输出的格式。 
150.      * @params targetFormat 最终输出的日期时间的格式，若没有输入则使用strFormat或者默认格式'yyyy-MM-dd HH:mm:ss' 
151.      * @return 返回计算并格式化后的时间的字符串 
152.      */  
153.     changeDate: function(date, interval, amount, strFormat, targetFormat){  
154.         var tmpdate = new Date();  
155.         if(date == undefined){  
156.            this.debug('输入的时间不能为空!');  
157.            return new Date();  
158.         }else if(typeof date == 'string'){  
159.             tmpdate = this.parseDate(date, strFormat);  
160.         }else if(date instanceof Date){  
161.           tmpdate = date;  
162.         }  
163.         var field  =  (typeof interval == 'string')? interval.toUpperCase(): 'DATE';  
164.           
165.         try{  
166.           amount = parseInt(amount + '', 10);  
167.           if(isNaN(amount)){  
168.              amount = 0;  
169.           }  
170.         }catch(e){  
171.            this.debug('你输入的[amount=' + amount + ']不能转换为整数');  
172.            amount = 0;  
173.         }  
174.         switch(field){  
175.            case this.DEFAULT_YEAR:  
176.              tmpdate.setFullYear(tmpdate.getFullYear() + amount);  
177.              break;  
178.            case this.DEFAULT_MONTH:  
179.              tmpdate.setMonth(tmpdate.getMonth() + amount);  
180.              break;  
181.            case this.DEFAULT_DATE:  
182.              tmpdate.setDate(tmpdate.getDate() + amount);  
183.              break;  
184.            case this.DEFAULT_HOUR:  
185.              tmpdate.setHours(tmpdate.getHours() + amount);  
186.              break;  
187.            case this.DEFAULT_MINUTE:  
188.              tmpdate.setMinutes(tmpdate.getMinutes() + amount);  
189.              break;  
190.            case this.DEFAULT_SECOND:  
191.               tmpdate.setSeconds(tmpdate.getSeconds() + amount);  
192.              break;  
193.            default:  
194.               this.debug('你输入的[interval:' + field + '] 不符合条件!');          
195.         }  
196.           
197.         this.curDate = tmpdate;  
198.         return this.formatCurrentDate(targetFormat == undefined? strFormat: targetFormat);  
199.     },  
200.       
201.     /** 
202.      * 比较两个日期的差距 
203.      * @param date1 Date类型的时间 
204.      * @param date2 Dete 类型的时间 
205.      * @param isFormat boolean 是否对得出的时间进行格式化,<br>  
206.      *       false:返回毫秒数，true：返回格式化后的数据 
207.      * @return 返回两个日期之间的毫秒数 或者是格式化后的结果 
208.      */  
209.     compareTo: function(date1, date2, isFormat){  
210.       try{  
211.             var len = arguments.length;  
212.             var tmpdate1 = new Date();  
213.             var tmpdate2 = new Date();  
214.             if(len == 1){  
215.                tmpdate1 = date1;  
216.             }else if(len >= 2){  
217.               tmpdate1 = date1;  
218.               tmpdate2 = date2;  
219.             }  
220.         if(!(tmpdate1 instanceof Date) || !(tmpdate2 instanceof Date)){  
221.            return 0;  
222.         }else{  
223.             var time1 = tmpdate1.getTime();   
224.             var time2 = tmpdate2.getTime();  
225.             var time = Math.max(time1, time2) - Math.min(time1, time2);  
226.             if(!isNaN(time) && time > 0){  
227.                if(isFormat){  
228.                   var date = new Date(time);  
229.                   var result = {};  
230.                   result['year']   = (date.getFullYear() - 1970) > 0? (date.getFullYear() - 1970): '0';  
231.                   result['month']  = (date.getMonth() - 1) > 0? (date.getMonth() - 1): '0';  
232.                   result['day']    = (date.getDate() - 1) > 0? (date.getDate() - 1): '0';  
233.                   result['hour']   = (date.getHours() - 8) > 0? (date.getHours() - 1): '0';  
234.                   result['minute'] = date.getMinutes() > 0? date.getMinutes(): '0';  
235.                   result['second'] = date.getSeconds() > 0? date.getSeconds(): '0';  
236.                   return result;  
237.                 }else {  
238.                  return time;  
239.                 }  
240.             }else{  
241.               return 0;  
242.             }  
243.         }  
244.       }catch(e){  
245.         this.debug('比较时间出现异常' + e.message);  
246.       }  
247.     },  
248.       
249.     /** 
250.      * 根据给定的日期得到日期的月，日，时，分和秒的对象 
251.      * @params date 给定的日期 date为非Date类型， 则获取当前日期 
252.      * @return 有给定日期的月、日、时、分和秒组成的对象 
253.      */  
254.     getDateObject: function(date){  
255.          if(!(date instanceof Date)){  
256.            date = new Date();  
257.          }  
258.         return {  
259.             'M+' : date.getMonth() + 1,   
260.             'd+' : date.getDate(),     
261.             'H+' : date.getHours(),     
262.             'm+' : date.getMinutes(),   
263.             's+' : date.getSeconds()  
264.          };  
265.     },  
266.       
267.     /** 
268.      *在控制台输出日志 
269.      *@params message 要输出的日志信息 
270.      */  
271.     debug: function(message){  
272.        try{  
273.            if(!this.isDebug){  
274.              return;  
275.            }  
276.            if(!window.console){  
277.                window.console = {};  
278.                window.console.log = function(){  
279.                   return;  
280.                }  
281.            }  
282.            window.console.log(message + ' ');  
283.        }catch(e){  
284.        }  
285.     }  
286. }