/**
 * @fileOverview JRJ网站使用jQuery作为javascript基础库，jrjbase.js是对jQuery的补充。
 * @copyright (c) 2009 (jrj.com)
 * @author jianjun.wang@jrj.com.cn
 * @version 0.6
 */

if(typeof JRJ=="undefined" || !JRJ){
	/**
	 * JRJ为脚本库的全局命名空间
	 * @namespace JRJ为脚本库的全局命名空间
	 */
	var JRJ = {};
}

try {
	document.execCommand("BackgroundImageCache", false, true);
}catch(e){}

/**
 * HTMLElement对象
 * @class HTMLElement对象
 * @static
 * @name HTMLElement
 */
/**#@+
 * 扩展HTMLElement对象，
 * @method
 */
if(typeof(HTMLElement)!="undefined"){ 
	/**
	 * 判断obj是否为其子元素
	 * @param {element} obj 子元素
	 * @return boolen 
	 */  
	HTMLElement.prototype.contains = function(obj) {   
		while(obj!=null && typeof(obj.tagName)!="undefind"){
		 	if(obj==this){    
		 	   return true;
		 	}
		 	obj=obj.parentNode;
		}
		return false;   
	};
}
/**#@-*/

 /**
  * JRJ bom对象
  * @class JRJ bom对象
  * @static
  * @name JRJ.bom
  */
(function(){
	var userAgent = navigator.userAgent.toLowerCase();
	var isIE = /*@cc_on!@*/false;
	var isWebkit = /applewebkit/.test( userAgent );
	var isOpera = /opera/.test( userAgent );
	var isChrome = isWebkit && /chrome/.test( userAgent );
	JRJ.bom = {
		/** 
 		 * 判断浏览器是否为IE 
 		 * @final 
 		 * @type boolean 
 		 */
		isIE		: isIE,
		/** 
 		 * 判断浏览器是否为IE8 
 		 * @final 
 		 * @type boolean 
 		 */
		isIE8		: isIE && ( parseInt( userAgent.match( /msie (\d+)/ )[1], 10 ) >= 8 ),
		/** 
 		 * 判断浏览器是否为IE7 
 		 * @final 
 		 * @type boolean 
 		 */
		isIE7		: isIE && ( parseInt( userAgent.match( /msie (\d+)/ )[1], 10 ) >= 7 ),
		/** 
 		 * 判断浏览器是否为IE6
 		 * @final 
 		 * @type boolean 
 		 */
		isIE6		: isIE && ( parseInt( userAgent.match( /msie (\d+)/ )[1], 10 ) >= 6 ),
		/** 
 		 * 判断浏览器是否为Mozilla
 		 * @final 
 		 * @type boolean 
 		 */
		isMozilla		: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent ),
		/** 
 		 * 判断浏览器是否为Safari
 		 * @final 
 		 * @type boolean 
 		 */
		isSafari	: isWebkit && !isChrome,
		/** 
 		 * 判断浏览器是否为Opera
 		 * @final 
 		 * @type boolean 
 		 */
		isOpera		: isOpera,
		/** 
 		 * 判断浏览器是否为Chrome
 		 * @final 
 		 * @type boolean 
 		 */
		isChrome : isChrome,
		/** 
 		 * 判断浏览器内核是否为Gecko
 		 * @final 
 		 * @type boolean 
 		 */
		isGecko : /gecko/.test( userAgent ) && !isWebkit && !isOpera,
		/**
 		 * 获取cname的cookie
 		 * @param {string} obj cookie名称
     * @return boolean 默认返回空字符串
 		 */
		getCookie : function(cname){
      var cookieStr = document.cookie.match("(?:^|;)\\s*" + cname + "=([^;]*)");
      return cookieStr ? unescape(cookieStr[1]) : "";
    },
    /**
 		 * 设置Cookie
 		 * @param {string} name cookie名称
 		 * @param {string} value cookie值
 		 * @param {date} expires 失效时间
 		 * @param {string} path path
 		 * @param {string} domain 域
 		 * @param {int} secure 表示这个Cookie是否通过加密的HTTPS协议在网络上传输
     * @description name、value为必选参数
     * @example 
     *  var exp = new Date();   	
exp.setTime(exp.getTime() + 10*60*1000);
JRJ.bom.setCookie("JRJ","金融界",exp);
     */
    setCookie : function(name, value, expires, path, domain, secure){
    	document.cookie= name + "=" + escape(value) +
		    ((expires) ? "; expires=" + expires.toGMTString() : "") +
		    ((path) ? "; path=" + path : "") +
		    ((domain) ? "; domain=" + domain : "") +
		    ((secure) ? "; secure" : "");
    },
    /**
 		 * 删除Cookie
 		 * @param {string} name cookie名称
 		 * @param {string} path 可选;删除某路径下的cookie需要设置，根路径为"/"
 		 * @param {string} domain 可选;删除某域下的cookie需要设置
 		 */
    delCookie : function(name, path, domain){
    	if(this.getCookie(name)){
		    document.cookie = name + "=" +
		        ((path) ? "; path=" + path : "") +
		        ((domain) ? "; domain=" + domain : "") +
		        "; expires=Thu, 01-Jan-70 00:00:01 GMT";
			}
    },
    /**
 		 * 添加收藏夹，chrome,opera,safari浏览器不支持
 		 * @param {string} sURL 页面url
 		 * @param {string} sTitle 收藏页面标题 
 		 */
    addBookmark : function(sURL, sTitle){
    	try{
        window.sidebar.addPanel(sTitle, sURL, "");
      }catch(e){
        try{
          window.external.AddFavorite(sURL, sTitle);
        }catch(e){
        	alert("加入收藏失败，请使用Ctrl+D进行添加");
        }
      }
		},
    /**
 		 * 设为主页，chrome,opera,safari浏览器不支持
 		 * @param {string} sURL 页面url
 		 */		
		setHomePage : function(url){
			try{
				document.body.style.behavior='url(#default#homepage)';
				document.body.setHomePage(url);
			}catch(e){
				if(window.netscape){
					try{ 
						netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect"); 
						var prefs = Components.classes['@mozilla.org/preferences-service;1'].getService(Components.interfaces.nsIPrefBranch);
						prefs.setCharPref('browser.startup.homepage',url);
					}catch (e){ 
						alert("请在浏览器地址栏输入“about:config”并回车，\r\n然后将[signed.applets.codebase_principal_support]设置为'true'。"); 
					}  
				}else{
					alert("抱歉，您所使用的浏览器无法完成操作。\r\n您需要手动将'"+url+"'设为首页。");
				}
			}
		}
    
	};
})();

/**
 * JRJ dom对象
 * @class JRJ dom对象
 * @static
 * @name JRJ.dom
 */
JRJ.dom = {
	/**
 	 * 在页面head添加样式表	 
 	 * @param {string} css 样式表字符串 
 	 * @param {document} doc 可选;目标document对象，默认为当前document对象
 	 */
	addCSS : function(css,doc){
    var doc = doc || document;
    var style = doc.createElement("style");
    style.type="text/css";
    doc.getElementsByTagName("head")[0].appendChild(style);
    if(style.styleSheet)
    {
      style.styleSheet.cssText=css;
    }
    else
    {
      style.appendChild(doc.createTextNode(css));
    }
	},
	/**
 	 * 获取iframe的docuemnt对象
 	 * @param {string} id iframe的id
 	 * @return {document} iframe页面的docuemnt对象
 	 */
	getIframeDocument:function(id){
    var win = this.getIframeWindow(id);
    return win?win.document:win.contentDocument;
  },
  /**
 	 * 获取iframe的window对象
 	 * @param {string} id iframe的id
 	 * @return {window} iframe页面的window对象
 	 */
  getIframeWindow : function (id){
		if(id==""){
			return null;
		}
		var iframeObj = document.getElementById(id);
		if(!iframeObj){
			return  null;
		}else {
			return iframeObj.contentWindow;
		}
	},
	/**
 	 * 获取element的outHTML
 	 * @param {element} element元素
 	 * @return {string} element的outHTML字符串
 	 */
	getOuterHTML : function(element){
		var attrs = element.attributes;
		var str = "<" + element.tagName.toLowerCase();
		for (var i = 0; i < attrs.length; i++){
		  if(attrs[i].value!="null"&&attrs[i].value!="")
		    str += " " + attrs[i].name + "=\"" + attrs[i].value + "\"";
		}
		
		return str + ">" + element.innerHTML + "</" + element.tagName.toLowerCase() + ">";
	}
}
/**
 * JRJ util 工具类
 * @class JRJ util 工具类
 * @static
 * @name JRJ.util
 */
JRJ.util = {
	/**
 	 * 扩展Array Number String等原生javascript对象
 	 */
	$native:function(){
		for (var i = 0, l = arguments.length; i < l; i++){
			/**			 
			 * @ignore
			 * @inner
			 */  
		  arguments[i].extend = function(props){
				for (var prop in props){
					if (!this.prototype[prop]) this.prototype[prop] = props[prop];
					if (!this[prop]) this[prop] = function(prop){
						return function(bind){
							return this.prototype[prop].apply(bind, Array.prototype.slice.call(arguments, 1));
						};
					};
				}
		  };
	  }
	},
	/**
 	 * 判断obj是否定义且初始化
 	 * @param {object} obj
 	 * @return {boolean}
 	 */
	defined : function(obj){
		return (obj != undefined);
	},
	/**
 	 * 判断str是否为整数字符串，可以用于输入验证
 	 * @param {string} str 
 	 * @return {boolean}
 	 */
	isInt : function(str){
		if(str=='0'){
			return true;	
		}
		return str.test(/^-?[1-9]\d*$/);
	},
	/**
 	 * 判断str是否为正整数字符串，可以用于输入验证
 	 * @param {string} str 
 	 * @return {boolean}
 	 */
	isPositiveInt : function(str){
		return str.test(/^[1-9]\d*$/);
	},
	/**
 	 * 判断str是否为非负整数字符串，可以用于输入验证
 	 * @param {string} str 
 	 * @return {boolean}
 	 */
	isNonnegativeInt : function(str){
		return str=='0'||this.isPositiveInt(str);
	},
	/**
 	 * 判断n是否数字或数字字符串
 	 * @param {string/number} str 
 	 * @return {boolean}
 	 */
	isNumberStr : function(n){
		if(!n){return false;}
		return !isNaN(n);
	},
	/**
 	 * 判断n是否为Number类型 
 	 * @param {string/number} n 
 	 * @return {boolean}
 	 */
	isNumber : function(n){
		return typeof(n)=="number"?true:false ;
	},
	/**
 	 * 产生min,max之间的随机数
 	 * @param {int} min 
 	 * @param {int} max 
 	 * @return {int}
 	 */
	random : function(min, max){
		return Math.floor(Math.random() * (max - min + 1) + min);
	},
	/**
 	 * 获取当前客户端系统时间
 	 * @return {int}
 	 */
	time : function(){
		return new Date().getTime();
	},
	/**
 	 * 把html中的& " ' < >字符编码
 	 * @param {string} html 
 	 * @return {string}
 	 */
	encodeHtml : function(html){
		if ( typeof( html ) != "string" ){
			html = html.toString() ;
	  }
		html = html.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#039;").replace(/</g, "&lt;").replace(/>/g, "&gt;") ;
	
		return html ;		
	},
	/**
 	 * 把str中的&amp; &quot; &#039; &lt; &gt;转成& " ' < >
 	 * @param {string} str 
 	 * @return {string}
 	 */
	decodeHtml : function(str){
		return str.replace(/&amp;/g, "&").replace(/&quot;/g, "\"").replace(/&#039;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
	},
	/**
 	 * 根据JRJ.SSOUser判断用户是否登录
 	 * @return {boolean}
 	 */
	isLogin : function(){
		var userCookie = JRJ.bom.getCookie("JRJ.SSOUser");	
		if(userCookie==""){
	     return false;
		}else{
		   return true;	
		}		
	}

};

/**
 * JavaScript基本类型和内置对象检测
 * @param {object} o 要检测的变量
 * @return {string} 数据类型 undefined/number/boolean/string/regexp/array/date/error
 */
JRJ.util.type = function(o) {
	var _toS = Object.prototype.toString, 
	_types = {
	    'undefined' : 'undefined',
	    'number' : 'number',
	    'boolean' : 'boolean',
	    'string' : 'string',
	    '[object Function]' : 'function',
	    '[object RegExp]' : 'regexp',
	    '[object Array]' : 'array',
	    '[object Date]' : 'date',
	    '[object Error]' : 'error'
	};
  return _types[typeof o] || _types[_toS.call(o)] || (o ? 'object' : 'null');
};
/**
 * 将数字转换成三位逗号分隔的字符串
 * @param {number} num 要转换的数字
 * @return {string} 13,356
 */
JRJ.util.formatNum = function(num){	
	if(!/^(\+|-)?(\d+)(\.\d+)?$/.test(num)){
		return num;
	}
	var a = RegExp.$1, b = RegExp.$2, c = RegExp.$3;	
	var re = new RegExp("(\\d)(\\d{3})(,|$)");
	while(re.test(b)){		
		b = b.replace(re, "$1,$2$3");
	}
	
	return a +""+ b +""+ c;
};
/**
 * 获取数字的小数位数
 * @param {number} num
 * @return {int} 该数的小数位数
 */
JRJ.util.getDecimalDigits = function(num){
	var reg = /\.\d*$/;
  var str = reg.exec(num);
  if(str != null) {
    return str.toString().length - 1;
  } else {
    return 0;
  }
};
/**  
 * 四舍五入，小数位不够则补0
 * @param {number} val 转换的数字
 * @param {int} num 保留的小数位数
 * @return {string} 
 */
JRJ.util.roundAndPolish = function(val, num){
	if (!JRJ.util.isNumberStr(val)) {
      return val;
  }
  var addZero = function(num, str){
	    if (num > 0) {
	        return addZero(--num, str + "0");
	    } else {
	        return str;
	    }
  }
  var p = Math.pow(10, num);
  val = (parseInt(Math.round(val * p)) / p).toString();
  var l = JRJ.util.getDecimalDigits(val);
  if (l == num) {
      return val;
  } else if (l < num) {
      if (l == 0) {
          val += '.';
      }
      return addZero(num - l, val);
  }
  return val;
};
	
JRJ.util.$native(Array, String, Number);
/**
 * Array对象
 * @class Array对象
 * @static
 * @name Array
 */
 
/**#@+
 * 扩展Array对象，
 * @memberOf Array
 * @method
 */
Array.extend({
	/**  
   * 迭代一个数组
   * @param {function} fn 迭代函数 
   * @param {object} bind 回调函数中this所要引用的对象 
   */
	each : function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++) fn.call(bind, this[i], i, this);
	},
	/**  
   * 查找给出项在数组中的索引
   * @param {string,int,object} item 查找的数组元素
   * @param {int} from 可选;查找的起始位置，默认为0
   * @return {int} 返回item在数组中的序号，不存在该元素返回-1
   */
	indexOf : function(item, from){
		var len = this.length;
		for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++){
			if (this[i] === item) return i;
		}
		return -1;
	},
  /**  
   * 查找给出项在数组中的索引
   * @param {string,int,object} item 查找的数组元素
   * @param {int} from 可选;查找的起始位置，默认为0
   * @return {boolean}
   */
	contains: function(item, from){
		return this.indexOf(item, from) != -1;
	},
	/**  
   * 获取数组最后一个元素
   * @return {object} 数组为空则返回null
   */
	getLast : function(){
		return this[this.length - 1] || null;	
	},
	/**  
   * 清空数组
   * @return {array} 返回清空后的数组
   */
	empty : function(){
		this.length = 0;
		return this;
	},
	/**  
   * 删除数组元素 
   * @param {string,int,object} item 
   * @return {array} 返回删除后的数组
   */
	remove : function(item){
		var i = 0;
		var len = this.length;
		while (i < len){
			if (this[i] === item){
				this.splice(i, 1);
				len--;
			} else {
				i++;
			}
		}
		return this;
	}	
});
/**#@-*/

/**
 * String对象
 * @class String对象
 * @static
 * @name String
 */
 
/**#@+
 * 扩展String对象，
 * @memberOf String
 * @method
 */
String.extend({
	/**  
   * Regex实例方法test的快捷方式
   * @param {string,RegExp} regex 正则表达式或正则字符转
   * @param {string} params 正则参数
   * @return {boolean} 
   * @example
   * "hello world".test("hello","ig");
   * @example
   * var reg = new RegExp("hello","g");
   * "hello world".test(reg);
   */
	test: function(regex, params){
		return ((typeof regex == 'string') ? new RegExp(regex, params) : regex).test(this);
	},
	/**  
   * parseInt的快捷方式
   * @param {int} base 可选;默认为10进制
   * @return {int} 
   * @example
   * "100".toInt(10);
   */
	toInt: function(base){
		return parseInt(this, base || 10);
	},
	
	/**  
   * toFloattoFloat的快捷方式
   * @return {float|NaN} 
   * @example
   * "100.98".toFloat();
   */
	toFloat: function(){
		return parseFloat(this);
	},
	/**  
    * 测试字符串中是否包含指定子串
    * @param {string} str 子字符串
    * @return {boolean} 
    * @example
    * 'jpg,gif,png'.contains('png')
    */
	contains: function(str){
		return this.indexOf(str) > -1;
	},
	/**  
   * 计算字符串的字节长度
   * @return {int} 
   * @example
   * 'abcdefg'.getBytesLength()
   */
	getBytesLength : function(){
		return this.replace(/[^\x00-\xff]/g, 'xx').length;
	},
	/**  
   * 取小于等于len长度的字符串
   * @param {int} len 截取的子串长度  
   * @return {string} 
   */
	subStringByCase : function(len){
		var str = this;
		if(!str || !len) { return ''; }
	  var a = 0;
	  var i = 0;      
	  var temp = '';      
	  for (i=0;i<str.length;i++){         
		   if (str.charCodeAt(i)>128){                         
		   		a+=2;         
		   } else {            
					a++;         
			 }
			 //如果增加计数后长度大于限定长度，就直接返回临时字符串         
			 if(a > len) { return temp; }          
			 //将当前内容加到临时字符串         
			 temp += str.charAt(i);     
		}
		return str;
	}
});
/**#@-*/
/**
 * Number对象
 * @class Number对象
 * @static
 * @name Number
 */
 
/**#@+
 * 扩展Number对象，
 * @memberOf Number
 * @method
 */
Number.extend({
	/**  
   * 四舍五入，本方法是为了解决JS的浮点运算问题<br/>
	先根据运算要求的精度放大，使小数点右移，使用Math.round之后再使小数点左移<br/>
	所以不直接使用Math.round,Math.round为取整的四舍五入<br/>
   * @param {int} precision 进制
   * @return {Number} 
   */
	round: function(precision){
		precision = Math.pow(10, precision || 0);
		return Math.round(this * precision) / precision;
	}
});
/**#@-*/
/**
 * JRJ event对象，提供jQuery未提供的事件处理方法
 * @class JRJ event对象
 * @static
 * @name JRJ.event
 */
JRJ.event = {
	/**
 	 * 常键盘键代码</br>
 	   回车：JRJ.Keys.enter ,</br>向上箭头:JRJ.Keys.up,</br>下箭头：JRJ.Keys.down,
 	   </br左箭头：JRJ.Keys.right,</br>esc：JRJ.Keys.esc,</br>space：JRJ.Keys.space,</br>backspace：JRJ.Keys.backspace,</br>tab：JRJ.Keys.tab,</br>delete：JRJ.Keys.delete
 	 * @final
 	 * @type object
 	 */
	Keys : {
		'enter': 13,
		'up': 38,
		'down': 40,
		'left': 37,
		'right': 39,
		'esc': 27,
		'space': 32,
		'backspace': 8,
		'tab': 9,
		'delete': 46		
	},
	/**  
   * 获取触发event的目标对象
   * @param {event} event event对象
   * @return {element} 
   */
	getTarget : function(event){
		if(!event)
			return null;
		if(typeof(event.srcElement) != "undefined")
			return event.srcElement;
		else
			return event.target;		
	},
	/**  
   * 获取触发键盘事件的键代码
   * @param {event} event event对象
   * @return {int} 
   */	
	getKeyCode : function(event){
		return event.which || event.keyCode;
	},
	/**  
   * 判断触发鼠标事件的是否为左键
   * @param {event} event event对象
   * @return {boolean} 
   */
	isLeftClick : function(event){
		var isLeftClick = (event.which && event.which == 1) || (event.button && event.button == 1);
		return isLeftClick;
	},
	/**  
   * 判断触发鼠标事件的是否为右键
   * @param {event} event event对象
   * @return {boolean} 
   */
	isRightClick : function(event){
		//var isLeftClick = (event.which && event.which == 1) || (event.button && event.button == 1);
		return !this.isLeftClick(event);
	},
	/**  
   * 获取触发鼠标事件的页面位置
   * @param {event} event event对象
   * @return {left:int,right:int} 
   */	
	pageXY : function(event){
		var l = event.pageX || (event.clientX +(document.documentElement.scrollLeft || document.body.scrollLeft));
		var t = event.pageY || (event.clientY +(document.documentElement.scrollTop || document.body.scrollTop));
		return {left:l,top:t};
	},
	/**  
   * 获取事件的关联对象
   * @param {event} event event对象
   * @param {window} win 可选; window对象，默认为window
   * @return {element} 
   */
	related : function(event,win){
		var win = win || window;
    var doc = win.document;
    var related = null;
    switch (event.type){
			case 'mouseover': 
				related = event.relatedTarget || event.fromElement; 
				break;
			case 'mouseout': 
			  related = event.relatedTarget || event.toElement;
    }
    return related;
	},
	/**  
   * 获取滚轮滚动方向
   * @param {event} event event对象
   * @return {1|-1} 1为向上滚动，-1为向下滚动 
   */	
	getWheel : function(event){
		var wheel = 0
		if (event.type.match(/DOMMouseScroll|mousewheel/)){
	    wheel = (event.wheelDelta) ? event.wheelDelta / 120 : -(event.detail || 0) / 3;
	  }
	  return wheel;
  },
	/**  
   * 阻止事件冒泡和事件返回
   * @param {event} event event对象
   */
	stop : function(event){
		if(!event){return;}
		if(event.cancelBubble)
		{
			event.cancelBubble=true;//不再派发事件，阻止冒泡
			event.returnValue=false;//取消事件的默认动作。
		}else if(event.stopPropagation){
			event.preventDefault();//取消事件的默认动作。
			event.stopPropagation();//不再派发事件
		}		
	}	
}
/**
 * JRJ date工具类
 * @class JRJ date工具类
 * @static
 * @name JRJ.date
 */
JRJ.date = {
	/**
 	 * 字符串转日期
 	 * @param {string} str 
 	 * @param {string} separtor 可选;日期分隔符，默认为"-"
 	 * @return {date} 
 	 */
	str2Date : function(str,separtor){
		var s = "-";
		if(typeof(separtor)!="undefined"){
			s = separtor;
		}
	
		var ymd = str.split(s);
		var year = parseInt(ymd[0],10);
		var month = parseInt(ymd[1],10);
		var day = parseInt(ymd[2],10);
		
		if(month<1||month>12||day<1||day>31){
			alert("错误时间字符串");
			return null;
		}
		var d = new Date(year,month-1,day);
		return d;
	},
	/**
 	 * 字符串转日期时间	 
 	 * @param {string} str 格式：2008-08-08 13:54:03
 	 * @param {string} separtor 可选;日期分隔符，默认为"-"
 	 * @return {date} 
 	 */
	str2DateTime : function(str,separtor){
	  var s = "-";
		if(typeof(separtor)!="undefined"){
			s = separtor;
		}
		var dt = str.split(" ");
		var ymd = dt[0].split(s);
		var year = parseInt(ymd[0],10);
		var month = parseInt(ymd[1],10);
		var day = parseInt(ymd[2],10);
		if(month<1||month>12||day<1||day>31){
			alert("错误时间字符串");
			return null;
		}
		var time = "";
		var hours = 0;
		var minutes = 0;
		var seconds = 0 ;
	
		if(dt[1]!==undefined&&dt[1]!=""){
	    time = dt[1].split(":");
	    hours = parseInt(time[0],10);
	    minutes = parseInt(time[1],10);
	    seconds = parseInt(time[2],10);
	  }
		if(hours<0||hours>23||minutes<0||minutes>59||seconds<0||seconds>59){
			alert("错误时间字符串");
			return null;
		}
		var d = new Date(year,month-1,day);
	  d.setHours(hours);
	  d.setMinutes(minutes);
	  d.setSeconds(seconds);
		return d;
	},
	/**
 	 * 日期转字符串
 	 * @param {date} date 
 	 * @param {string} separtor 可选;日期分隔符，默认为"-"
 	 * @return {string} 
 	 */
	date2Str : function(date,separtor){
		var s = "-";
		if(typeof(separtor)!="undefined"){
			s = separtor;
		}
		var d = date.getFullYear()+s+(date.getMonth()+1)+s+date.getDate();	
		return d;	
	},
	/**
 	 * 计算两个日期的天数差
 	 * @param {date} date1
 	 * @param {date} date2
 	 * @return {int} 
 	 */
  getDateDiff : function(date1,date2){   
	   var reg = /^(\d{4})\S(\d{1,2})\S(\d{1,2})$/;  
	   var dt1,dt2;  
	   if(reg.test(date1)){  
	     dt1 = new Date(RegExp.$1,RegExp.$2 - 1,RegExp.$3);
	   }   
	   if(reg.test(date2)){  
	     dt2 = new Date(RegExp.$1,RegExp.$2 - 1,RegExp.$3);
	   }
	   return Math.floor((dt2-dt1)/(1000 * 60 * 60 * 24));   
	},
	/**
 	 * 计算date日期n天后的日期
 	 * @param {date} date 日期
 	 * @param {int} n 天数
 	 * @return {date} 
 	 */
	dateAfter : function(date,n){
		var d = date;
		d.setDate(d.getDate() + n);
		return d;
	},
	/**
 	 * 格式化日期	 
 	 * @param {date} d 日期
 	 * @param {string} format 日期格式：yyyy-MM-dd w hh:mm:ss<br/>
 	  yyyy/yy 表示年份   <br/>
 		MM/M 月份   <br/>
 		w 星期   <br/>
 		dd/d 日  <br/>
 		hh/h 小时  <br/>
 		mm/m 分   <br/>
 		ss/s 秒  <br/>
 	 * @return {string} 
 	 */
	format : function(d,format){    
	  var str = format;
	  var Week = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];
	  var month = d.getMonth()+1;
	 
	  str=str.replace(/yyyy/,d.getFullYear());    
	  str=str.replace(/yy/,(d.getYear() % 100)>9?(d.getYear() % 100).toString():'0' + (d.getYear() % 100));    	   	    
	  str=str.replace(/MM/,month>9?month.toString():'0' +month);    
	  str=str.replace(/M/g,month);    	      	   
	  str=str.replace(/dd/,d.getDate()>9?d.getDate().toString():'0' + d.getDate());    
	  str=str.replace(/d/g,d.getDate());    
	
	  str=str.replace(/w/g,Week[d.getDay()]);
	
	  str=str.replace(/hh/,d.getHours()>9?d.getHours().toString():'0' + d.getHours());    
	  str=str.replace(/h/g,d.getHours());    
	  str=str.replace(/mm/,d.getMinutes()>9?d.getMinutes().toString():'0' + d.getMinutes());    
	  str=str.replace(/m/g,d.getMinutes());    	   
	  str=str.replace(/ss/,d.getSeconds()>9?d.getSeconds().toString():'0' + d.getSeconds());    
	  str=str.replace(/s/g,d.getSeconds());
	 
	  return str;
	}
}