自己编写的一些好用的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标签上的绑定事件，例如onclick="$.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)
});
}
});
});