自己编写的一些好用的jquery方法（部分方法仅适用于我的项目）

/**
 * 引用地址
 * <script type="text/javascript" src="urp/urp/people/media/js/jquery-utils.js"></script>
 * @param $
 * @author 张荣波
 */
(function(factory){
	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.
		define([ "jquery" ], factory );
	} else {

		// Browser globals
		factory( jQuery );
	}
})(function($){
	function onlyNum(event) {
	    if(!(event.keyCode==46)&&!(event.keyCode==8)&&!(event.keyCode==37)&&!(event.keyCode==39))
	    	if(!((event.keyCode>=48&&event.keyCode<=57)||(event.keyCode>=96&&event.keyCode<=105)))
	    	return false;
	}
	/**
	 * 数组的添加方法，如果参数是一个数组，则连接两个数组。否则将参数放入数组中。最后返回自身
	 * @param arg
	 */
	Array.prototype.puts = function(arg){
		if(this.push){
			if($.isArray(arg)){
				var _this = this;
				$.each(arg, function(i, x){
					_this.push(x);
				});
			}else{
				this.push(arg);
			}
		}
		return this;
	};
	/**
	 * 随机生成UUID的方法
	 * 参数len为生成字符串的长度,radix表示字符位数，例如10代表十位，生成字符范围从0到1，
	 * 16代表十六位，生成字符从0到F
	 */
	var CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
	Math.uuid = function (len, radix) {
	    var chars = CHARS, uuid = [], i;
	    radix = radix || chars.length;
	    if (len) {
	    	// Compact form
	    	for (i = 0; i < len; i++) 
	    		uuid[i] = chars[0 | Math.random() * radix];
	 	} else {
	 		// rfc4122, version 4 form
	 		var r;
	 		// rfc4122 requires these characters
	 		uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
	 		uuid[14] = '4';
	 		// Fill in random data.  At i==19 set the high bits of clock sequence as
	 		// per rfc4122, sec. 4.1.5
	 		for (i = 0; i < 36; i++) {
	 			if (!uuid[i]) {
	 				r = 0 | Math.random()*16;
	 				uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
	 			}
	 		}
	 	}
		return uuid.join('');
	};
	$.extend({
		/**
		 * 将get方式跳转转换成post方式跳转链接的方式
		 * 参数url的形式与get方式的url形式相同，
		 * 以第一个问号分割跳转的url和参数
		 * 多个参数之间用&符号分割，参数名和值可以使用post方式允许的任意字符（除&符号）
		 */
		goPage			: function(url, flag){
			var sepIndex = url.indexOf("?"),
				hasSep = sepIndex >= 0,
				url1 = hasSep ? url.slice(0, sepIndex) : url,
				params = hasSep ? url.slice(sepIndex + 1) : "",
				regex = /(\w+)=([^&]*)/g,
				form = $("<form>")
						.attr("method", "post")
						.attr("action",url1)
			;
			while(true && hasSep){
				var param = regex.exec(params);
				if(param != null){
					var name = param[1],
					    value = param[2]
					    ;
					form.append(
						$("<input>")
							.attr("type","hidden")
							.attr("name",name)
							.val(value)
					);
				}else{
					break;
				}
			}
			if(flag == true){
				form.submit(function(e){
					e.stopImmediatePropagation();
				});
			}
			$("body:first").append(form);
			form.submit();
		},
		/**
		 * 将一个纯粹的对象转换以key=value的形式构造get方法请求参数字符串
		 * 所有的value都已经经过二次编码
		 */
		toGetParams		: function(obj){
			var ret = "";
			if($.isPlainObject(obj)){
				for(var key in obj){
					if($.isArray(obj[key])){
						$.each(obj[key], function(i, x){
							ret += key + "=" + $.dblEncode(x) + "&";
						});
					}else{
						ret += key + "=" + $.dblEncode(obj[key]) + "&";
					}
				}
				ret =  $.trims(ret, "&");
			}
			return ret;
		},
		/**
		 * 用于可以直接将对象进行提交并跳转链接的方法
		 * form用于复制form内的表单信息
		 * action表示要提交的目标uri，params是一个纯对象，里面的key和value代表要提交数据
		 */
		submit			: function(action, params, form){
			var newForm = 
					$("<form>")
						.attr("action", action || form.attr(form) || "")
						.attr("method", "post")
						.hide()
						.append(form ? $(":input", form) : null)
						.appendTo(!form ? $("body:first") : form.parent())
						;
			for(var key in params || {}){
				if($.isArray(params[key])){
					for(var i = 0; i < params[key].length; i++){
						newForm.append(
							$("<input>")
								.attr("name", key)
								.val(params[key][i])
						);
					}
				}else{
					newForm.append(
							$("<input>")
							.attr("name", key)
							.val(params[key])
					)
					;
				}
			}
			newForm.submit();
		},
		/**
		 * 判断是否是undefined
		 */
		isUndefined		: function(obj){
			return $.type(obj) == "undefined";
		},
		/**
		 * 判断是否是string类型的数据
		 */
		isString		: function(obj){
			return $.type(obj) == "string"; 
		},
		/**
		 * 判断是否是object类型的数据
		 */
		isObject		: function(obj){
			return $.type(obj) == "object";
		},
		/**
		 * 判断obj是HTML Dom对象
		 */
		isDOM 			: function(obj){
			return ( typeof HTMLElement === 'object' ) ?
				(obj instanceof HTMLElement) :
				(obj && typeof obj === 'object' && obj.nodeType === 1 && typeof obj.nodeName === 'string')
		},
		/**
		 * 判断是否是string类型数据并且判断字符串内是否有内容
		 */
		hasText			: function(obj){
			return $.isString(obj) && obj != "";
		},
		/**
		 * 将两个对象内的属性看做是两个map,根据map的键值取两个map的差集
		 * 也就是结果对象中的属性只含有对象1中有的，但是对象2中没有的属性
		 * 并且属性值就是对象1中的对应属性
		 */
		substract		: function(obj1, obj2){
			var ret = {};
			if($.type(obj1) != "object" || obj == null){
				return ret;
			}
			for(var key in obj1){
				if($.isUndefined(obj2[key])){
					ret[key] = obj1[key];
				}
			}
			return ret;
		},
		/**
		 * 有限制的数据继承。
		 * 生成的对象包含obj1的所有属性，
		 * 但是属性值以obj2为高优先级
		 */
		extendLimited	: function(obj1, obj2){
			var ret = obj1 ? {} : undefined;
			for(var key in obj1){
				ret[key] = obj2[key] || obj1[key];
			}
			return ret;
		},
		/**
		 * 将某个对象放到另一个对象当中
		 * 必须传入对象作为属性的名称
		 * 如果不传入作为容器的对象，则生成一个空对象并放入这个属性
		 */
		wrapToObject	: function(name, value, obj){
			var ret = $.isObject(obj) ? $.extend({}, obj) : {};
			if(name && value){
				ret[name] = value;
			}else{
				throw $.error("the argument name[" + name + "] or value[" + value + "] maybe is undefined");
			}
			return ret;
		},
		/**
		 * 清除字符串首末段特殊字符串，如果不传入regex，则就是直接调用$.trim
		 */
		trims			: function(str, regex){
			if($.isUndefined(regex)){
				return $.trim(str);
			}else if($.hasText(regex)){
				var s = new String(str);
				while(s.indexOf(regex) == 0){
					s = s.substring(regex.length);
				}
				while(s.lastIndexOf(regex) == (s.length - regex.length) && s.length > regex.length){
					s = s.substr(0, s.length - regex.length);
				}
				return s;
			}else if($.type(regex) == "regexp"){
				var s = new String(regex);
				
			}
			return str;
		},
		/**
		 * 二次编码
		 */
		dblEncode			: function(str){
			return encodeURI(encodeURI(str));
		},
		/**
		 * 根据一个纯对象和form的参数构造一个form的jquery对象
		 */
		formBuild		: function(data, action, method, target){
			var form = $("<form>")
							.attr("action", action || "")
							.attr("method", method || "")
							.attr("target", target || "")
					;
			if($.isPlainObject){
				//当传入的对象是纯对象的时候才进行构造数据
				for(var key in data){
					form.append(
							$("<input>")
							.attr("type", "hidden")
							.attr("name", key)
							.val(data[key])
					);
				}
			}
			return form;
		},
		/**
		 * 用post的方式打开layer弹出层
		 * action是要打开的url,data是要传送的键值对,layerOpt代表打开layer弹出框的参数对象
		 */
		openLayer	: function(action, data, openWindow, layerOpt){
			layerOpt = layerOpt || {};
			openWindow = openWindow || window;
			//参数传入的回调函数，应在成功打开窗口之后并且跳转到指定url再执行
			var success = layerOpt.success || $.noop;
			//基础参数，不能被layerOpt覆盖的参数
			var baseOpt = {
				type: 2,
				iframe: {
				    src: 'about:blank'
				 },
				 success: function(layero){
					//获得弹出框的iframe
				 	var iframe = $("iframe", layero);
				 	//获得弹出框的window
				    var win =  iframe.get(0).contentWindow;
				    //添加跳转页面后的自定义回调，只执行一次
				    iframe.one("load",function(e){
				    	success(layero);
				    });
				    //构造用于post跳转的form表单
				    var form = $.formBuild(data,action, "post", win.name);
				    //将form表单放入弹出框内的body内并执行提交
				    $("body:eq(0)").append(form);
				    form.submit();
				    form.remove();
				 }
			};
			//可以被覆盖的参数
			var extendOpt = {
				area: [($(openWindow).width() * (4/5)) + "px" , ($(openWindow).height() - 200) +'px']
			};
			var opt = $.extend(extendOpt, layerOpt, baseOpt);
			return openWindow.$.layer(opt);
		},
		/**
		 * 重新封装openDialog的函数，用于显示弹出框用于选择人口
		 * 当前限定只能打开一个弹出框
		 * 参数对象只有一个，
		 * 如果不传入参数，就认为传入一个空对象，使用默认参数打开弹出框
		 * 如果参数为HTML DOM对象或者jquery对象，那么就直接调用该对象的openDialog方法
		 * 如果传其他对象，就进行解析字段作为参数，打开弹出框
		 * 
		 * 打开人口查询弹出框，可以传入参数
		 * 		window		：	window对象。表示要显示弹出框的window对象，默认是ROOT_PAGE，如果ROOT_PAGE不存在，则使用当前页面
		 * 		id			：	数组或字符串。表示要显示的人口的主键范围，与其他条件共同作用
		 * 		except		： 	数组或字符串。表示要排除的人口的主键范围，与其他条件共同作用，当相同主键放在id和except中，那么except优先级高
		 * 		queryMode	：	字符串。查询模式，为“none”时不显示查询条件表单，默认为空，表示显示所有表单
		 * 		flag		：	字符串。查询范围，
		 * 								为“base”时查询人口基本表，
		 * 								为“temp”查询临时人口表，
		 * 								为“base-temp”时查询两个表，
		 * 								“noFamily”时查询没有家庭信息的基本表的人。
		 * 								“hasFamily”时查询又家庭信息的基本表的人。
		 * 								默认为“base”
		 * 		backdata	：	数组或字符串。表示要返回的数据，为“simplist”时只返回身份证号以及人口类别，传入数据字段名可以返回相应数据
		 * 		areaCode	：	字符串。表示行政区域范围
		 * 		mode		：	字符串。表示选择模式，为“single”时单选，“multi”时多选，默认多选
		 * 		callback	：	函数。表示数据回调时的函数
		 * 		openDialog弹出框相关参数
		 * 			该函数的参数均可以传入使用，详见dialog.js
		 */
		layerPeopleList	: function(dom){
			if($.fn.openDialog){
				if($.isObject(dom)){
					//获得要打开弹出框的父窗口
					var openWindow = dom.window || ROOT_PAGE || window;
					//获得当前已经打开的人口选择弹出框
					var curOpenLayer = openWindow.$("[src^='PeopleInfoAction.dialogSelectPeople.act'].xubox_iframe")
						;
					//将所有已打开的人口选择弹出框全部关掉
					curOpenLayer.each(function(){
						//获得弹出框的索引
						var openedIndex = openWindow.layer.getFrameIndex(this.name);
						//关闭弹出框
						openWindow.layer.close(openedIndex);
					});
					//当传入了一个对象才会执行弹出
					if($.isDOM(dom) || dom instanceof jQuery){
						//如果传入了dom对象或者jquery对象，那么就调用$.fn.layerPeopleList()
						//这个方式可以直接用在html标签上的绑定事件，例如οnclick="$.layerPeopleList(this)"
						$(dom).layerPeopleList();
					}else{
						//用于发送到后台的默认请求参数
						var requestObj =
							//限制继承
							$.extendLimited(
								{
									"id"		: [],
									"except"	: [],
									"queryMode" : "nornal",
									"flag"		: "base",
									backdata	: "",
									areaCode	: "",
									mode		: "single"
								}
							, dom);
						//将请求对象转换成get方式传输的键值对
						var requestParams = $.toGetParams(requestObj);
						//构造要放入的success函数
						var success = function(layero){
							//默认执行将回调函数放入页面中
							//获取弹出框的window
							var iframe = $("iframe", layero).get(0); 
							//如果callback存在，那么就把callback放到弹出框内，函数名为layer_callback
							if(dom.callback){
								$(iframe).load(function(){
									var win = iframe.contentWindow;
									win["layer_callback"] = dom.callback;
									$(iframe).removeClass("xubox_load");
								});
/*								iframe.onload = function(){
								};*/
							}
							//如果dom对象有传入success参数，那么执行
							if(dom.success){
								dom.success(layero);
							}
						};
						//用于控制弹出框的参数
						var defaultObj = {
								url			: "PeopleInfoAction.dialogSelectPeople.act?" + requestParams,
								title 		: "人口查找", 
								width 		: "1000px", 
								height 		: "600px",
								shade		: [0.5]
						};
						//获取其他传入的参数
						var option = $.extend(defaultObj, dom);
						//默认使用success函数作为参数
						option.success = success;
						//打开弹出框
						$(openWindow).openDialog(option);
					}
				}else if($.isUndefined(dom)){
					//如果没有传入参数，那么就执行传入空对象，
					//使用默认参数打开弹出框
					this.layerPeopleList({});
				}
			}
		},
		/**
		 * 根据一个日期字符串，以及日期格式，获得对应的日期对象
		 * 如果不传入参数，则返回当前系统时间，
		 * 如果传入一个参数，则以“yyyy-MM-dd”为格式获得对应日期对象
		 */
		date	: function(dateStr, format){
			//定义返回的日期对象
			var ret = new Date();
			//如果没有传入参数，则直接把当前的日期对象返回
			if($.isUndefined(dateStr)){
				return ret;
			}
			//传入日期格式，并定义默认格式
			format = format || "yyyy-MM-dd";
			//获取日期格式中年份、时间、日期的位置
			var indexYear = format.indexOf("yyyy"),
				indexMonth = format.indexOf("MM"),
				indexDay = format.indexOf("dd"),
				indexHour = format.indexOf("hh"),
				indexMinute = format.indexOf("mm"),
				indexSecond = format.indexOf("ss")
			;
			//接下去方法是获取格式中年份、时间、日期的出现次序
			//定义一个对象，属性键值对应年份、月份、日期的位置
			var sort = {
				y	: indexYear,
				M	: indexMonth,
				d	: indexDay,
				h	: indexHour,
				m	: indexMinute,
				s	: indexSecond
			};
			//将键值放到一个要用于排序的数组中
			var keySet = [];
			for(var key in sort){
				if(sort[key] >= 0){
					keySet.push(key);
				}
			}
			//根据数组元素值对应信息位置，对数组进行排序
			for(var i = 0 ; i < keySet.length; i ++){
				for(var j = i + 1; j < keySet.length ; j++){
					if(sort[keySet[j]] < sort[keySet[i]]){
						var t = keySet[j];
						keySet[j] = keySet[i];
						keySet[i] = t;
					}
				}
			}
			//排序后将对应信息放入，如果格式中没有此信息，那么对应的位置为undefined
			indexYear = 	$.inArray("y", keySet)< 0 ? undefined : $.inArray("y", keySet);
			indexMonth = 	$.inArray("M", keySet)< 0 ? undefined : $.inArray("M", keySet);
			indexDay = 		$.inArray("d", keySet)< 0 ? undefined : $.inArray("d", keySet);
			indexHour = 	$.inArray("h", keySet)< 0 ? undefined : $.inArray("h", keySet);
			indexMinute = 	$.inArray("m", keySet)< 0 ? undefined : $.inArray("m", keySet);
			indexSecond = 	$.inArray("s", keySet)< 0 ? undefined : $.inArray("s", keySet);
			//根据日期格式字符串生成正则表达式
			var reg = format
						.replace("yyyy", "(\\d{1,4})")
						.replace("MM", "(\\d{1,2})")
						.replace("dd", "(\\d{1,2})")
						.replace("hh", "(\\d{1,2})")
						.replace("mm", "(\\d{1,2})")
						.replace("ss", "(\\d{1,2})")
					;
			reg = "^" + reg + "$";
			var regex = new RegExp(reg);
			//根据正则表达式对原日期字符串进行解析
			var exec = regex.exec(dateStr);
			//如果解析成功，就将日期信息放到要返回的对象中
			if(exec != null){
				var year 	= exec[indexYear + 1],
					month 	= exec[indexMonth + 1] || ret.getMonth() + 1,
					day		= exec[indexDay + 1] || ret.getDay(),
					hour	= exec[indexHour + 1] || ret.getHours(),
					minute	= exec[indexMinute + 1] || ret.getMinutes(),
					second	= exec[indexSecond + 1] || ret.getSeconds()
				;
				ret.setFullYear(year, month - 1, day);
				ret.setHours(hour, minute, second);
			}
			return ret;
		},
		/**
		 * 如果传入一个数字，则将其当做是出生年份，如果传入两个数字，则直接获得差值
		 * 如果传入一个日期对象，则将其当做是出生日期，直接计算年龄。
		 * 如果传入一个字符串，则根据格式yyyy-MM-dd将其转成日期对象后计算年龄
		 * 如果传入两个字符串，则第二个参数为日期格式
		 */
		age		: function(){
			var arg0 = arguments[0],
				arg1 = arguments[1],
				year = $.date().getFullYear(),
				year1 = year,
				ret = 0
			;
			if($.type(arg0) == "number"){
				//如果参数是数字的情况下
				year = arg0;
				year1 = $.type(arg1) == "number" ? arg1 : year1;
			}else if($.type(arg0) == "date"){
				year = arg0.getFullYear();
				//如果参数是日期对象的 情况下
				year1 = $.type(arg1) == "date" ? arg1.getFullYear() : $.date().getFullYear();
			}else if($.type(arg0) == "string"){
				var format = /^\d+$/.test(arg0) ? "yyyy" : "yyyy-MM-dd";
				format = $.type(arg1) == "string" ? arg1 : format;
				year = $.date(arg0, format).getFullYear();
				year1 = $.date().getFullYear();
			}
			ret = Math.abs(year1 - year);
			return ret;
		},
		/**
		 * 通过参数获取人口信息，并执行回调函数
		 * args参数对象内的id属性是要获取的人口的身份证号（临时人口就是主键）数组
		 * property属性是要获取的人口的字段名，字段名格式为(关联名.字段名)，
		 * 例如人口姓名字段(__self__.name)，房屋主键字段(residenceRoom.id)
		 * 
		 * 查询后调用回调函数，并将查询结果对象作为参数给回调函数。
		 * 查询结果对象是一个以身份证号（主键）为key，请求字段数据对象为value的Object
		 * 
		 * 函数返回值返回jQuery自身
		 */
		ajaxPeopleInfo	: function(args, callback){
			//默认参数
			var default_ = {
				//默认id为空，此时返回页为空
				id		: [],
				//默认返回字段为默认字段（身份证号，姓名，人口数据类型），
				property: [],
				//默认回调为空，优先级args.callback大于arguments的callback
				callback: callback || $.noop,
				//表示执行callback的页面，默认为当前页面
				window	: window,
				//默认异步加载时显示遮罩层，如果不显示遮罩层
				delay	: "shade",
				//默认获取数据的后台uri
				uri		: "PeopleInfoAction.ajaxGetPeopleInfo.act",
				//表示要获取的人口信息的人口数据类型，base代表人口基本表的数据，temp代表临时人口表的数据
				t_p		: "base"
			};
			//传入参数覆盖默认参数
			var param = $.extend({}, default_, args);
			param.id = $.isArray(param.id) ? param.id : [];
			param.property = $.isArray(param.property) ? param.property : [];
			//当延迟参数为默认值时，显示遮罩层表示等待
			if(param.delay === default_.delay){
				try{
					ROOT_PAGE.showLoad();
				}catch(e){}
			}
			//执行ajax
			$.post(
				param.uri,
				{
					id		: param.id.join(),
					property: param.property.join(),
					t_p		: param.t_p
				},
				function(data){
					try{
						//回调数据
						data = $.trims(data || "");
						//回调数据转换成对象
						var json = $.hasText(data) ?  $.parseJSON(data) : {};
						if(typeof(console) != "undefined"){
							console.log(json);
						}
						//执行回调函数
						param.callback.call(param.window, json);
					}catch(e){
						throw $.error(e);
					}finally{
						try{
							ROOT_PAGE.closeLoad();
						}catch(e){}
					}
				}
			);
			return this;
		},
		alert		: function(param, callback){
			var type = "alert";
			try{
				ROOT_PAGE.layer[type](param);
			}catch(e){
				try{
					layer[type](param);
				}catch(e){
					try{
						ROOT_PAGE[type](param);
					}catch(e){
						try{
							window[type](param);
						}catch(e){
							$.error("no any method of " + type);
						}
					}
				}
			}
			
		}
	});
	$.fn.extend({
		/**
		 * 覆盖class
		 */
		replaceClass	: function(originalClass, newClass){
			return $(this).each(function(){
				$(this)
					.removeClass(originalClass)
					.addClass(newClass)
				;
			});
		},
		/**
		 * 限制只能输入数字
		 */
		onlyNumber		: function(){
			return $(this).each(function(){
				$(this)
					.css("imeMode","disabled")
					.off("keydown",onlyNum)
					.on("keydown",onlyNum)
					;
			});
		},
		/**
		 * 切换当前对象的某个prop属性
		 * 属性名propName和参考属性值1propVal1是必传的，参考属性值2可不传
		 * 当不传参考属性值2时，属性值要么为propVal1，要么被移除
		 * 当传入参考属性值2时，属性值要么为propVal1，要么为propVal2
		 * 当第一次应用该函数时，初始属性值不是这两个中的任意一个，那么就会默认切换成propVal1
		 */
		toggleProp 		: function(propName, propVal1, propVal2){
			var val = $(this).prop(propName);
			if(val == propVal1){
				if($.type(propVal2) == "undefined"){
					$(this).removeAttr(propName);
				}else{
					$(this).prop(propName,propVal2);
				}
			}else{
				$(this).prop(propName,propVal1);
			}
			return $(this);
		},
		/**
		 * 全选文本框内的文字
		 */
		selectAll		: function(){
			this.focus();
			this.select();
		},
		/**
		 * 获取当前列
		 */
		column			: function(){
			var ret = $();
			var belongTd = $(this).closest("td,th");
			if(belongTd.length > 0){
			  var index = belongTd.index();
			  var table = $(this).closest("table");
			  var tr = table.find("tr");
			  tr.each(function(){
			    var td = $(this).find("td,th").eq(index);
			    ret.push(td);
			  });
			}
			return ret;
		},
		/**
		 * 初始化的非规则要求icheck_init函数存在
		 * 如果没有传入参数，则初始化icheck，此时如果input和label的id和for不统一，则执行以下规则
		 * ++++++以id的值为主；如果id不存在，就以for为共同值；如果都不存在，那么用uuid(10,32)生成十位随机码来生成共同值+++++
		 * 如果传入了一个字符串参数，则以这个字符串为input的id和label的for，并初始化icheck
		 * 如果传入一个布尔值，则以这个布尔值作为是否勾选的依据进行勾选或取消
		 * 如果传入非数NaN，则切换勾选
		 */
		icheck			: function(checked){
			return $(this).each(function(){
				var current 	= $(this).is(":checkbox") ? "checkbox" : $(this).is(":radio") ? "radio" : $(this).is("label") ? "label" : undefined,
					input 		= current == "label" ? $(this).prev(":checkbox,:radio") : (current == "checkbox" || current == "radio") ? $(this) : undefined,
					label 		= input.next("label"), 
					flag 		= input.prop("checked")
				;
				if(input && label){
					var id			= input.attr("id"),
						for_		= label.attr("for")
					;
					if($.isString(checked)){
						id = checked;
					}else if($.isUndefined(checked)){
						id = (id == for_ && !$.hasText(id)) ? Math.uuid(10, 32) :  $.hasText(id) ? id : for_;
					}
					input.attr("id", id);
					label.attr("for", id);
					
					if($.isUndefined(checked) || $.isString(checked)){
						input.icheck_init();
					}else if($.type(checked) == "boolean"){
						//执行勾选
						input.prop("checked", checked);
						label.toggleClass("checked", checked);
					}else if($.type(checked) == "number"){
						//如果传入了NaN,则切换勾选
						input.prop("checked", !flag);
						label.toggleClass("checked", !flag);
					}
				}
			});
		},
		/**
		 * 根据选项的内容勾选select
		 */
		checkOption 	: function(value){
			if($(this).is("select")){
				var val = $("option:contains(" + value + "):first", this).val();
				$(this).val(val);
			}
			return this;
		},
		/**
		 * 获得外围HTML代码
		 */
		outerHTML		: function(){
			return $(this).prop("outerHTML");
		},
		layerPeopleList	: function(){
			$.layerPeopleList({
				maxmin: $(this).attr("maxmin"),
				title : $(this).attr("title"), 
				url : $(this).attr("url"),
				width : "1000px", 
				height : "600px",
				source : $(this).get(0)
			});
		}
	});
});