類似于Java日期格式化的JavaScript實(shí)現(xiàn)
		
          
		
            1/**
          
            2@author:Pancras
          
            3@version:1.01
          
            4@date:2008-03-02
          
            5@methods:
          
            6    DateUtil.getDate(year,month,day)        輸入?yún)?shù)為年、月、日，返回一個(gè)JS的Date型對象
          
            7    DateUtil.formateDate(pattern,date)        輸入?yún)?shù)一個(gè)是格式化字符串，比如"yyyy-MM-dd"，和JS日期對象，輸出格式化后的日期字符串（基本上和Java的格式化類似）
          
            8    DateUtil.formateDateTime(pattern,date)    參數(shù)類型同上，但是該方法是在要格式化包含時(shí)間的時(shí)候使用，如"yyyy-MM-dd HH-mm-ss"
          
            9    DateUtil.isLeapYear(date)                輸入一個(gè)JS日期型參數(shù)，判斷該日期所在的年是不是閏年
          
           10**/              
          
           11    
          
           12    function DateUtil(){
          
           13        alert("請不要new這個(gè)對象，所有方法都是可以通過DateUtil.方法名來調(diào)用");
          
           14    }
          
           15//-------------------------------------------
          
           16    //定義類方法getDate(year,month,day)創(chuàng)建對應(yīng)的日期對象
          
           17    function getDate(year,month,day)
          
           18    {
          
           19        var date = new Date();
          
           20        if(year)
          
           21        {
          
           22            date.setYear(year);
          
           23        }
          
           24        if(month)
          
           25        {
          
           26            date.setMonth(month-1);
          
           27        }
          
           28        if(day)
          
           29        {
          
           30            date.setDate(day);
          
           31        }
          
           32        return date;
          
           33    }
          
           34    DateUtil.getDate=getDate;
          
           35//-------------------------------------------
          
           36    //定義日期時(shí)間格式化
          
           37    DateUtil.yearPattern = [new RegExp("y{4}","g"),new RegExp("y{3}","g"),new RegExp("y{2}","g")];
          
           38    DateUtil.monthPattern = [new RegExp("M{2}","g"),new RegExp("M{1}","g")];
          
           39    DateUtil.datePattern = [new RegExp("d{2}","g"),new RegExp("d{1}","g")];
          
           40    DateUtil.hourPattern=[new RegExp("H{2}","g"),new RegExp("H{1}","g"),new RegExp("h{2}","g"),new RegExp("h{1}","g")];
          
           41    DateUtil.minutePattern=[new RegExp("m{2}","g"),new RegExp("m{1}","g")];
          
           42    DateUtil.secondPattern=[new RegExp("s{2}","g"),new RegExp("s{1}","g")];
          
           43    //格式化年
          
           44    function formatYear(pattern,year)
          
           45    {            
          
           46        var result = pattern.match(DateUtil.yearPattern[0]);
          
           47        if(result!=null){
          
           48            pattern = pattern.replace(DateUtil.yearPattern[0],year);
          
           49            return pattern;
          
           50        }          else {
          
           51    
          
           52            //不允許匹配成yyy
          
           53            result = pattern.match(DateUtil.yearPattern[1]);
          
           54            if(result!=null){
          
           55                throw "Unknown pattern:"+pattern;
          
           56                
          
           57            }          else {
          
           58                result = pattern.match(DateUtil.yearPattern[2]);
          
           59                if(result!=null)
          
           60                {
          
           61                    pattern = pattern.replace(DateUtil.yearPattern[2],(""+year).substring(2,4));
          
           62                    return pattern;
          
           63                }
          
           64            }
          
           65        }
          
           66    }
          
           67    //格式化月
          
           68    function formatMonth(pattern,month)
          
           69    {
          
           70        
          
           71        var result = pattern.match(DateUtil.monthPattern[0]);
          
           72        if(result!=null){
          
           73            if(month<10)
          
           74            {
          
           75                month = "0"+month;
          
           76            }
          
           77            pattern = pattern.replace(DateUtil.monthPattern[0],month);
          
           78            return pattern;
          
           79        }          else
          
           80        {
          
           81            result = pattern.match(DateUtil.monthPattern[1]);
          
           82            if(result!=null){
          
           83                pattern = pattern.replace(DateUtil.monthPattern[1],month);
          
           84                return pattern;
          
           85            }
          
           86            else{
          
           87                throw "Unknown pattern:"+pattern;
          
           88            }
          
           89            
          
           90        }
          
           91    }
          
           92    //格式化日期
          
           93    function formatDay(pattern,day)
          
           94    {
          
           95            
          
           96        var result = pattern.match(DateUtil.datePattern[0]);
          
           97        if(result!=null){
          
           98            if(day<10)
          
           99            {
          
          100                day = "0"+day;
          
          101            }
          
          102            pattern = pattern.replace(DateUtil.datePattern[0],day);
          
          103            return pattern;
          
          104        }          else
          
          105        {
          
          106            result = pattern.match(DateUtil.datePattern[1]);
          
          107            if(result!=null){
          
          108                pattern = pattern.replace(DateUtil.datePattern[1],day);
          
          109                return pattern;
          
          110            }
          
          111            else{
          
          112                throw "Unknown pattern:"+pattern;
          
          113            }
          
          114            
          
          115        }
          
          116    }
          
          117    //格式化小時(shí)
          
          118    function formatHour(pattern,hour)
          
          119    {        
          
          120            var result = pattern.match(DateUtil.hourPattern[0]);
          
          121            if(result!=null){
          
          122                if(hour<10)
          
          123                {
          
          124                    hour = "0"+hour;
          
          125                }
          
          126                pattern = pattern.replace(DateUtil.hourPattern[0],hour);
          
          127                return pattern;
          
          128            }          else
          
          129            {
          
          130                result = pattern.match(DateUtil.hourPattern[1]);
          
          131                if(result!=null){
          
          132                    pattern = pattern.replace(DateUtil.hourPattern[1],hour);
          
          133                    return pattern;
          
          134                }
          
          135                else{
          
          136                        result = pattern.match(DateUtil.hourPattern[2]);
          
          137                        if(result!=null){
          
          138                            if(hour<10)
          
          139                            {
          
          140                                hour = "0"+hour;
          
          141                            }
          
          142                            if(hour>12)
          
          143                            {
          
          144                                 hour = hour-12;
          
          145                            }
          
          146                            pattern = pattern.replace(DateUtil.hourPattern[2],hour);
          
          147                            return pattern;
          
          148                        }          else{
          
          149                            result = pattern.match(DateUtil.hourPattern[3]);
          
          150                            if(result!=null){
          
          151                                if(hour>12)
          
          152                                {
          
          153                                     hour = hour-12;
          
          154                                }
          
          155                                pattern = pattern.replace(DateUtil.hourPattern[3],hour);
          
          156                                return pattern;
          
          157                            }          else{
          
          158                                throw "Unknown pattern:"+pattern;
          
          159                            }
          
          160                        }
          
          161                
          
          162                }
          
          163            }
          
          164    }
          
          165    //格式化分鐘
          
          166    function formatMinute(pattern,minute)
          
          167    {
          
          168            
          
          169        var result = pattern.match(DateUtil.minutePattern[0]);
          
          170        if(result!=null){
          
          171            if(minute<10)
          
          172            {
          
          173                minute = "0"+minute;
          
          174            }
          
          175            pattern = pattern.replace(DateUtil.minutePattern[0],minute);
          
          176            return pattern;
          
          177        }          else
          
          178        {
          
          179            result = pattern.match(DateUtil.minutePattern[1]);
          
          180            if(result!=null){
          
          181                pattern = pattern.replace(DateUtil.minutePattern[1],minute);
          
          182                return pattern;
          
          183            }
          
          184            else{
          
          185                throw "Unknown pattern:"+pattern;
          
          186            }
          
          187            
          
          188        }
          
          189    }
          
          190    //格式化秒
          
          191    function formatSecond(pattern,second)
          
          192    {
          
          193            
          
          194        var result = pattern.match(DateUtil.secondPattern[0]);
          
          195        if(result!=null){
          
          196            if(second<10)
          
          197            {
          
          198                second = "0"+second;
          
          199            }
          
          200            pattern = pattern.replace(DateUtil.secondPattern[0],second);
          
          201            return pattern;
          
          202        }          else
          
          203        {
          
          204            result = pattern.match(DateUtil.secondPattern[1]);
          
          205            if(result!=null){
          
          206                pattern = pattern.replace(DateUtil.secondPattern[1],second);
          
          207                return pattern;
          
          208            }
          
          209            else{
          
          210                throw "Unknown pattern:"+pattern;
          
          211            }
          
          212            
          
          213        }
          
          214    }
          
          215    function formateDate(pattern,date)
          
          216    {
          
          217        var oldpattern = pattern;
          
          218        try{
          
          219            pattern = formatYear(pattern,DateUtil.getYear(date));
          
          220            pattern = formatMonth(pattern,DateUtil.getMonth(date));
          
          221            pattern = formatDay(pattern,DateUtil.getDay(date));
          
          222            return pattern;
          
          223        }          catch(err){
          
          224            if(err.match("Unknown pattern")){
          
          225                alert("Unknown pattern:"+oldpattern);
          
          226            }          else{
          
          227                alert(err);
          
          228            }
          
          229            
          
          230        }              
          
          231    }
          
          232    function formateDateTime(pattern,date)
          
          233    {
          
          234        var oldpattern = pattern;
          
          235        try{
          
          236            pattern = DateUtil.formateDate(pattern,date);
          
          237            pattern = formatHour(pattern,date.getHours());
          
          238            pattern = formatMinute(pattern,date.getMinutes());
          
          239            pattern = formatSecond(pattern,date.getSeconds());
          
          240            return pattern;
          
          241        }          catch(err){
          
          242            if(err.match("Unknown pattern")){
          
          243                alert("Unknown pattern:"+oldpattern);
          
          244            }          else{
          
          245                alert(err);
          
          246            }
          
          247            
          
          248        }              
          
          249    }
          
          250
          
          251    DateUtil.formateDate = formateDate;
          
          252    DateUtil.formateDateTime = formateDateTime;
          
          253//-------------------------------------------
          
          254    //是不是閏年
          
          255    function isLeapYear(date)
          
          256    {
          
          257        var year = DateUtil.getYear();
          
          258        if(year%100==0)
          
          259        {
          
          260            if(year%400==0)
          
          261            {
          
          262                return true;
          
          263            }
          
          264        }              
          
          265        if(year%100!=0)
          
          266        {
          
          267            if(year%4==0)
          
          268            {
          
          269                return true;
          
          270            }
          
          271        }              
          
          272        return false;
          
          273    }
          
          274
          
          275    DateUtil.isLeapYear = isLeapYear;
          

		
          
			posted on 2008-03-02 13:49 pancras 閱讀(2918) 評論(3)  編輯  收藏  
		
          
	
          
	
	


	


          
	    
    


          

          評論
          
	
	
			
          
				# re: 類似于Java日期格式化的JavaScript實(shí)現(xiàn)
					
						2008-03-02 14:31
					
				xifu
			
          
			
          
				不錯(cuò)，多了一條路子  回復(fù)  更多評論
				  
			
          
		
			
          
				# re: 類似于Java日期格式化的JavaScript實(shí)現(xiàn)
					
						2008-03-02 15:04
					
				pancras
			
          
			
          
				哎，英語單詞敲錯(cuò)了，抱歉啊！

          format是格式化

          我寫成了formate

          

          使用的時(shí)候可以直接這樣

          DateUtil.formateDate("yyyy-MM-dd",new Date())    回復(fù)  更多評論
				  
			
          
		
			
          
				# re: 類似于Java日期格式化的JavaScript實(shí)現(xiàn)
					
						2008-03-03 10:14
					
				jeasonzhao
			
          
			
          
				不錯(cuò)，學(xué)習(xí)了，受教了  回復(fù)  更多評論
				  
			
          
		

          




          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發(fā)表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		


          

		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網(wǎng)站導(dǎo)航:
		
		
          
		
          
			
		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				
				

			
          
			
          
				
					
          
	
          
		
          <2008年3月>
          
	
          日一二三四五六
          2425262728291
          2345678
          9101112131415
          16171819202122
          23242526272829
          303112345
          

          

					

          導(dǎo)航
          

					

          統(tǒng)計(jì)
          
	
					
					

          常用鏈接
          


          留言簿(1)
          


		
          隨筆檔案
          
		
				
			
	



          搜索
          



          最新評論
	
          

          
	
			
		

          

				
			
          
			
			
			
			
			 

	

    







          
        
	




主站蜘蛛池模板：
青岛市|
宁德市|
乐昌市|
乌鲁木齐市|
北海市|
余江县|
新建县|
黔西县|
尉犁县|
绍兴市|
邻水|
夏河县|
芷江|
罗平县|
宜城市|
平度市|
中阳县|
米林县|
罗定市|
石门县|
辽源市|
台东县|
孝感市|
内丘县|
肥乡县|
安龙县|
呼和浩特市|
武宣县|
台州市|
彭州市|
清徐县|
福安市|
资源县|
景宁|
鱼台县|
天全县|
昭通市|
晋州市|
开原市|
拜泉县|
枞阳县|