|
/*!
* WADE JavaScript Library v2.0 for zepto
* http://www.wadecn.com/
* auth:xiedx@asiainfo-linkage.com
* Copyright 2014, WADE
*/
(function($){
window.Wade = $;
var rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
push=Array.prototype.push;
/**
* 数据总线相关
**/
var escapeRe=function (d){
return d.replace(/([-.*+?^${}()|[\]\/\\])/g,"\\$1");
};
var support = {
scriptEval: false
};
var toString = Object.prototype.toString;
$.Collection = function(allowFunctions, keyFn){
this.items = [];
this.map = {};
this.keys = [];
this.length = 0;
this.allowFunctions = allowFunctions === true;
if(keyFn){
this.getKey = keyFn;
}
};
$.Collection.prototype={
allowFunctions : false,
add : function(key, o){
if(arguments.length == 1){
o = arguments[0];
key = this.getKey(o);
}
if(typeof key != 'undefined' && key !== null){
var old = this.map[key];
if(typeof old != 'undefined'){
return this.replace(key, o);
}
this.map[key] = o;
}
this.length++;
this.items.push(o);
this.keys.push(key);
return o;
},
getKey : function(o){
return o.id;
},
replace : function(key, o){
if(arguments.length == 1){
o = arguments[0];
key = this.getKey(o);
}
var old = this.map[key];
if(typeof key == 'undefined' || key === null || typeof old == 'undefined'){
return this.add(key, o);
}
var index = this.indexOfKey(key);
this.items[index] = o;
this.map[key] = o;
return o;
},
addAll : function(objs){
if(arguments.length > 1 || $.isArray(objs)){
var args = arguments.length > 1 ? arguments : objs;
for(var i = 0, len = args.length; i < len; i++){
this.add(args[i]);
}
}else{
for(var key in objs){
if(this.allowFunctions || typeof objs[key] != 'function'){
this.add(key, objs[key]);
}
}
}
},
each : function(fn, scope){
var items = [].concat(this.items); // each safe for removal
for(var i = 0, len = items.length; i < len; i++){
if(fn.call(scope || items[i], items[i], i, len) === false){
break;
}
}
},
eachKey : function(fn, scope){
for(var i = 0, len = this.keys.length; i < len; i++){
fn.call(scope || window, this.keys[i], this.items[i], i, len);
}
},
find : function(fn, scope){
for(var i = 0, len = this.items.length; i < len; i++){
if(fn.call(scope || window, this.items[i], this.keys[i])){
return this.items[i];
}
}
return null;
},
insert : function(index, key, o){
if(arguments.length == 2){
o = arguments[1];
key = this.getKey(o);
}
if(this.containsKey(key)){
this.suspendEvents();
this.removeKey(key);
this.resumeEvents();
}
if(index >= this.length){
return this.add(key, o);
}
this.length++;
this.items.splice(index, 0, o);
if(typeof key != 'undefined' && key !== null){
this.map[key] = o;
}
this.keys.splice(index, 0, key);
return o;
},
remove : function(o){
return this.removeAt(this.indexOf(o));
},
removeAt : function(index){
if(index < this.length && index >= 0){
this.length--;
var o = this.items[index];
this.items.splice(index, 1);
var key = this.keys[index];
if(typeof key != 'undefined'){
delete this.map[key];
}
this.keys.splice(index, 1);
return o;
}
return false;
},
removeKey : function(key){
return this.removeAt(this.indexOfKey(key));
},
getCount : function(){
return this.length;
},
indexOf : function(o){
return $.inArray(o,this.items);
},
indexOfKey : function(key){
return $.inArray(key,this.keys);
},
item : function(key){
var mk = this.map[key],
item = mk !== undefined ? mk : (typeof key == 'number') ? this.items[key] : undefined;
return typeof item != 'function' || this.allowFunctions ? item : null; // for prototype!
},
itemAt : function(index){
return this.items[index];
},
key : function(key){
return this.map[key];
},
contains : function(o){
return this.indexOf(o) != -1;
},
containsKey : function(key){
return typeof this.map[key] != 'undefined';
},
clear : function(){
this.length = 0;
this.items = [];
this.keys = [];
this.map = {};
},
first : function(){
return this.items[0];
},
last : function(){
return this.items[this.length-1];
},
_sort : function(property, dir, fn){
var i, len,
dsc = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
//this is a temporary array used to apply the sorting function
c = [],
keys = this.keys,
items = this.items;
//default to a simple sorter function if one is not provided
fn = fn || function(a, b) {
return a - b;
};
//copy all the items into a temporary array, which we will sort
for(i = 0, len = items.length; i < len; i++){
c[c.length] = {
key : keys[i],
value: items[i],
index: i
};
}
//sort the temporary array
c.sort(function(a, b){
var v = fn(a[property], b[property]) * dsc;
if(v === 0){
v = (a.index < b.index ? -1 : 1);
}
return v;
});
//copy the temporary array back into the main this.items and this.keys objects
for(i = 0, len = c.length; i < len; i++){
items[i] = c[i].value;
keys[i] = c[i].key;
}
},
sort : function(dir, fn){
this._sort('value', dir, fn);
},
reorder: function(mapping) {
this.suspendEvents();
var items = this.items,
index = 0,
length = items.length,
order = [],
remaining = [];
//object of {oldPosition: newPosition} reversed to {newPosition: oldPosition}
for (oldIndex in mapping) {
order[mapping[oldIndex]] = items[oldIndex];
}
for (index = 0; index < length; index++) {
if (mapping[index] == undefined) {
remaining.push(items[index]);
}
}
for (index = 0; index < length; index++) {
if (order[index] == undefined) {
order[index] = remaining.shift();
}
}
this.clear();
this.addAll(order);
this.resumeEvents();
},
keySort : function(dir, fn){
this._sort('key', dir, fn || function(a, b){
var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
});
},
getRange : function(start, end){
var items = this.items;
if(items.length < 1){
return [];
}
start = start || 0;
end = Math.min(typeof end == 'undefined' ? this.length-1 : end, this.length-1);
var i, r = [];
if(start <= end){
for(i = start; i <= end; i++) {
r[r.length] = items[i];
}
}else{
for(i = start; i >= end; i--) {
r[r.length] = items[i];
}
}
return r;
},
filter : function(property, value, anyMatch, caseSensitive){
if(!value){
return this.clone();
}
value = this.createValueMatcher(value, anyMatch, caseSensitive);
return this.filterBy(function(o){
return o && value.test(o[property]);
});
},
filterBy : function(fn, scope){
var r = new $.Collection();
r.getKey = this.getKey;
var k = this.keys, it = this.items;
for(var i = 0, len = it.length; i < len; i++){
if(fn.call(scope||this, it[i], k[i])){
r.add(k[i], it[i]);
}
}
return r;
},
findIndex : function(property, value, start, anyMatch, caseSensitive){
if(!value){
return -1;
}
value = this.createValueMatcher(value, anyMatch, caseSensitive);
return this.findIndexBy(function(o){
return o && value.test(o[property]);
}, null, start);
},
findIndexBy : function(fn, scope, start){
var k = this.keys, it = this.items;
for(var i = (start||0), len = it.length; i < len; i++){
if(fn.call(scope||this, it[i], k[i])){
return i;
}
}
return -1;
},
createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
if (!value.exec) { // not a regex
value = String(value);
if (anyMatch === true) {
value = escapeRe(value);
} else {
value = '^' + escapeRe(value);
if (exactMatch === true) {
value += '$';
}
}
value = new RegExp(value, caseSensitive ? '' : 'i');
}
return value;
},
clone : function(){
var r = new $.Collection();
var k = this.keys, it = this.items;
for(var i = 0, len = it.length; i < len; i++){
r.add(k[i], it[i]);
}
r.getKey = this.getKey;
return r;
}
};
/*
* 扩展常用方法
* isArray|isPlainObject|isEmptyObject,三个方法zepto已经存在
*/
$.extend($,{
noop:function(){},
error:function( msg ) {
throw msg;
},
isNumber:function(value) {
return typeof value === 'number' && isFinite(value);
},
isNumeric: function(value) {
return !isNaN(parseFloat(value)) && isFinite(value);
},
isString: function(value) {
return typeof value === 'string';
},
isBoolean: function(value) {
return typeof value === 'boolean';
},
isFunction:function(obj){
return toString.call(obj) === "[object Function]";
},
/*isArray:function(obj) {
return toString.call(obj) === "[object Array]";
},*/
//判断是否为object类型的对象
isObject:function(obj){
return toString.call(obj) === "[object Object]";
},
//判断是否为JSON对象，而不是function的实例
/*isPlainObject:function(obj){
//先对数据类型进行判断，并排除DOM类型的对象
if (!obj || toString.call(obj)!=="[object Object]" || obj.nodeType || obj.setInterval){
return false;
}
//如果有构造方法的属性，那么则是function的实例
if (obj.constructor
&& !hasOwnProperty.call(obj, "constructor")
&& !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
return false;
}
//判断最后一个属性是否是OwnProperty，而不是prototype里的属性
var key;
for(key in obj){}
//返回判断结果
return key === undefined || hasOwnProperty.call(obj, key);
},*/
//判断是否为没有任何属性的对象
isEmptyObject:function(obj){
for (var name in obj) {
return false;
}
return true;
},
isElement: function(value) {
return value ? value.nodeType !== undefined : false;
},
isNodeName:function(elem,name){
return $.nodeName(elem,name);
},
//判定nodeName
nodeName:function(elem, name){
return elem.nodeName && elem.nodeName.toUpperCase()=== name.toUpperCase();
},
isWindow: function( obj ) {
return obj && typeof obj === "object" && "setInterval" in obj;
},
trim: function(text) {
return (text || "").replace(rtrim,"");
},
//判断item是否在数组array中
inArray: function(item, array){
if(array.indexOf){
return array.indexOf(item);
}
//遍历array进行判定
for(var i=0,length=array.length;i<length;i++){
if(array[i]===item){
return i;
}
}
return -1;
},
makeArray:function(array, results){
var ret = results || [];
if ( array != null ) {
//如果arry不是数组类型,则直接将array push到ret中
if(array.length == null || typeof array === "string" || $.isFunction(array) || (typeof array !== "function" && array.setInterval)){
push.call(ret, array);
}else{
$.merge(ret, array);
}
}
return ret;
},
//复制数组对象
merge:function(first, second) {
var i = first.length, j = 0;
if(typeof second.length === "number"){
for(var l = second.length; j<l; j++) {
first[i++]=second[j];
}
}else{
while(second[j]!==undefined){
first[i++]=second[j++];
}
}
first.length = i;
return first;
},
grep: function( elems, callback, inv ) {
var ret = [];
//遍历元素数组，在每个元素上执行callback，并返回执行结果有返回值不为false的结果集
for ( var i = 0, length = elems.length; i < length; i++ ) {
if ( !inv !== !callback( elems[ i ], i ) ) {
ret.push( elems[ i ] );
}
}
return ret;
},
map: function( elems, callback, arg) {
var ret = [], value;
//遍历元素数组， 在每个元素上执行callback，并返回所有的执行结果
for ( var i = 0, length = elems.length; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
return ret.concat.apply( [], ret );
},
each:function( object, callback, args ) {
var name, i = 0,
length = object.length,
isObj = length === undefined || $.isFunction(object);
if (args){
if (isObj) {
for (name in object){
if (callback.apply(object[name], args)===false){
break;
}
}
}else{
for(;i<length;){
if(callback.apply(object[i++],args)===false){
break;
}
}
}
}else{
if(isObj){
for(name in object){
if (callback.call(object[name],name,object[name])===false){
break;
}
}
}else{
for(var value=object[0];
i<length && callback.call(value,i,value)!==false;value=object[++i]){}
}
}
return object;
},
parseJSON: function( data ) {
if ( typeof data !== "string" || !data ) {
return null;
}
//去除首尾空格
data = $.trim(data);
//使用正则表达式确保传入的字符串是json
if ( /^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
.replace(/(?:^|:|,)(?:\s*\[)+/g, "")) ) {
//先尝试使用浏览器内部JSON解析器
return window.JSON && window.JSON.parse ?
window.JSON.parse( data ) :
(new Function("return " + data))();
} else {
$.error( "Invalid JSON: " + data );
}
},
globalEval: function(data){
if (data && rnotwhite.test(data)){
var head = document.getElementsByTagName("head")[0] || document.documentElement,
script = document.createElement("script");
script.type = "text/javascript";
if (support.scriptEval ) {
script.appendChild( document.createTextNode( data ) );
} else {
script.text = data;
}
head.insertBefore( script, head.firstChild );
head.removeChild( script );
}
},
//UserAgent检测
uaMatch: function(ua) {
ua = ua.toLowerCase();
var match = /(webkit)[ \/]([\w.]+)/.exec(ua) ||
/(opera)(?:.*version)?[ \/]([\w.]+)/.exec(ua) ||
/(msie) ([\w.]+)/.exec(ua) ||
!/compatible/.test(ua) && /(mozilla)(?:.*? rv:([\w.]+))?/.exec(ua) ||
/(gecko)[ \/]([^\s]*)/i.exec(ua) ||
[];
return {browser: match[1] || "", version: match[2] || "0" };
},
browser: {}
});
$.extend($,{
parseJsonString:function(str){ //过滤Json串中特殊字符以构造Json
if(!str || !typeof(str)=="string"){return "";}
str=str.replace(/([:{}\[\]\"])[\s|\u00A0]+/g,"$1"); //替换 :{}[]" 符号的右侧空格
str=str.replace(/[\s|\u00A0]+([:{}\[\]\"])/g,"$1"); //替换 :{}[]" 符号的左侧空格
//str=str.replace(/,([^\":{}\[\]]+):([\"{\[]{1})/g,",\"$1\":$2"); //把JSON串中无引号的键名加上双引号(1:处理,xxx:("|{|[))
//str=str.replace(/\{([^\":{}\[\]]+):([\"{\[]{1})/g,"{\"$1\":$2"); //把JSON串中无引号的键名加上双引号(2:处理{xxx:("|{|[))
str=str.replace(/,([^\":{}\[\]]+):\"/g,",\"$1\":\""); //把JSON串中无引号的键名加上双引号(1:处理 ,xxx:")
str=str.replace(/,([^\":{}\[\]]+):\{/g,",\"$1\":{"); //把JSON串中无引号的键名加上双引号(1:处理 ,xxx:{)
str=str.replace(/,([^\":{}\[\]]+):\[/g,",\"$1\":["); //把JSON串中无引号的键名加上双引号(1:处理 ,xxx:[)
str=str.replace(/\{([^\":{}\[\]]+):\"/g,"{\"$1\":\""); //把JSON串中无引号的键名加上双引号(1:处理 {xxx:")
str=str.replace(/\{([^\":{}\[\]]+):\{/g,"{\"$1\":{"); //把JSON串中无引号的键名加上双引号(1:处理 {xxx:{)
str=str.replace(/\{([^\":{}\[\]]+):\[/g,"{\"$1\":["); //把JSON串中无引号的键名加上双引号(1:处理 {xxx:[)
str=str.replace(/\\\":(null|undefined)(,|})/g,"\\\":\\\"\\\"$2"); //处理KEY值里放IData或IDataset的toString串里的空值
str=str.replace(/\\\":(true|false)(,|})/g,"\\\":\\\"$1\\\"$2"); //处理KEY值里放IData或IDataset的toString串里的布尔值
str=str.replace(/\\\":(-)?([0-9\.]+)(,|})/g,"\\\":\\\"$1$2\\\"$3"); //处理KEY值里放IData或IDataset的toString串里的数值
str=str.replace(/\\\"/g,"!~b~!"); //把字符串中原有的 \" 替换，处理KEY值里放IData或IDataset的toString串的情况
str=str.replace(/:(null|undefined)(,|})/g,":\"\"$2"); //将null或undefined替换为空字符
str=str.replace(/:(true|false)(,|})/g,":\"$1\"$2"); //将true|false替换为字符串
str=str.replace(/:(-)?([0-9\.]+)(,|})/g,":\"$1$2\"$3"); //将数字替换为字符串
//str=str.replace(datafilter,""); //过滤允许字符之外的字符
//str=str.replace(datareplacer,"$1:$3"); //处理bude串的=号替换为:号
/*
str=str.replace(/\r|\t|\n|\"/g,function(m){
switch(m){
case "\r":m="\u005Cr";break;
case "\t":m="\u005Ct";break;
case "\n":m="\u005Cn";break;
case "\"":m="!~a~!";break;
}return m;}); //处理回车换行制表符
*/
var out = "";
for(var i=0;i<str.length;i++){
var chr = str.charAt(i);
switch (chr){
case "\b":
out +="\u005Cb";
break;
case "\f":
out +="\u005Cf";
break;
case "\r":
out +="\u005Cr";
break;
case "\t":
out +="\u005Ct";
break;
case "\n":
out +="\u005Cn";
break;
case "\"":
out +="!~a~!";
break;
default:
out += chr;
break;
}
}
str = out;
//第一次替换处理JSON格式的双引号字符
str=str.replace(/{!~a~!/g,"{\""); //处理 {"
str=str.replace(/!~a~!}/g,"\"}"); //处理 "}
str=str.replace(/!~a~!,!~a~!/g,"\",\""); //处理 ","
str=str.replace(/!~a~!:!~a~!/g,"\":\""); //处理 ":"
str=str.replace(/!~a~!:\[!~a~!/g,"\":[\""); //处理 ":["
str=str.replace(/!~a~!:\[/g,"\":["); //处理 ":[
str=str.replace(/!~a~!\],!~a~!/g,"\"],\""); //处理 "],"
str=str.replace(/\],!~a~!/g,"],\""); //处理 ],"
str=str.replace(/!~a~!:{/g,"\":{"); //处理 ":{
str=str.replace(/},!~a~!/g,"},\""); //处理 },"
//第二次替换处理其它的双引号
str=str.replace(/\u005C!~a~!/g,"\u005C\""); //本身就有\的还原
str=str.replace(/!~a~!/g,"\u005C\""); //其它的加上\符号
str=str.replace(/!~b~!/g,"\u005C\""); //恢复 !~b~! 为 \"
//str=str.replace(/\r/g,"\u005Cr");
//str=str.replace(/\n/g,"\u005Cn");
//str=str.replace(/([^,:\{\[])(\")([^,:\}\]])/g,"$1\u005C$2$3"); //处理json串值中的双引号
//str=str.replace(/([^,\\:\{\[])(\")([^,\\:\}\]])/g,"$1\u005C$2$3"); //处理json串值中的双引号(两个双引号连一起的特殊情况)
//str=str.replace(/\"(\")([^,:\}\]])/g,"\"\u005C$1$2"); //xiedx 2010-7-14 //处理json串值中的双引号(多个双引号连一起的特殊情况)
//str=str.replace(/\"\,([^\"{\[])/g,"\u005C\"\,$1"); //处理字符串json值中有双引号和逗号在一起的情况(",)
//str=str.replace(/([^\"}:\]])\,\"/g,"$1\,\u005C\""); //处理字符串json值中有双引号和逗号在一起的情况(,")
//str=str.replace(/\":\u005C\",/g,"\":\","); //处理与值结束引号连在一起的双引号
//str=str.replace(/,\u005C\"([\}\]]|(,\"))/g,",\"$1"); //处理与值结束引号连在一起的双引号
return str;
},
parseJsonValue:function(str){ //替换json对象值中的特殊字符
if(!str || !typeof(str)=="string"){return str;}
var out = "";
for(var i=0;i<str.length;i++){
var chr = str.charAt(i);
switch (chr){
case "\b":
out +="\u005Cb";
break;
case "\f":
out +="\u005Cf";
break;
case "\r":
out +="\u005Cr";
break;
case "\t":
out +="\u005Ct";
break;
case "\n":
out +="\u005Cn";
break;
case "\"":
out +="\u005C\"";
break;
default:
out += chr;
break;
}
}
return out;
}
});
$.DataMap=function(data){
//支持不使用new来构造
if(!this.parseString) {
return new $.DataMap(data);
}
$.Collection.call(this);
if(data){
if($.isString(data)){
this.parseString(data);
}else if(typeof(data)=="object"){
this.parseObject(data);
}
}
};
$.DataMap.prototype=new $.Collection();
$.extend($.DataMap.prototype,{
get:function(key,defaultValue){
var r=this.item(key);
if(arguments.length>1 && (typeof(r)=="undefined" || r==null))
return arguments[1];
return r;
},
parseString:function(str){
str=$.parseJsonString(str);
(new Function("this.parseObject(" +str+")")).apply(this);
//if(typeof(o)=="object")this.parseObject(o);
},
parseObject:function(obj){
for(var p in obj){
if(obj[p] && $.isArray(obj[p])){
this.add(p,new $.DatasetList(obj[p]));
}else if(obj[p] && $.isObject(obj[p])){
this.add(p,new $.DataMap(obj[p]));
}else{
this.add(p,(obj[p]==undefined || obj[p]==null)?"":obj[p]);
}
}
}
});
$.DataMap.prototype.toString=function(){
var cl=[],is="";
for(var key in this.map){
is="\"" + key + "\":";
if(typeof(this.map[key])=="undefined" || this.map[key]==null){
is+="\"\"";
}else if(typeof(this.map[key])=="string" || !isNaN(this.map[key])){
is+="\"" + $.parseJsonValue("" + this.map[key]) + "\"";
}else{
is+=this.map[key].toString();
}
cl.push(is);
}
return "{" + cl.join(",") + "}";
};
$.DataMap.prototype.put=$.DataMap.prototype.add;
$.DatasetList=function(o){
//支持不使用new来构造
if(!this.parseString) {
return new $.DatasetList(o);
}
this.items = [];
this.length=0;
if(typeof(o)=="string" && o!="")this.parseString(o);
if(typeof(o)=="object" && (o instanceof Array) && o.length)this.parseArray(o);
};
$.extend($.DatasetList.prototype,{
add:function(o){
this.length=(this.length+1);
this.items.push(o);
},
item:function(index,key,defaultValue){
if(index < this.length && index >= 0){
var r= this.items[index];
if((typeof(r)!="undefined") && (r instanceof $.DataMap)
&& arguments.length>1 && typeof(arguments[1])=="string"
&& arguments[1]!="" ){return r.get(key,defaultValue);}
return r;
}return;
},
each:function(fn, scope){
var items = [].concat(this.items);
for(var i = 0, len = items.length; i < len; i=i+1){
if(fn.call(scope || items[i], items[i], i, len) === false){
break;
}
}
},
remove:function(o){
return this.removeAt(this.indexOf(o));
},
removeAt:function(index){
if(index < this.length && index >= 0){
this.length=(this.length-1);
this.items.splice(index, 1);
}
},
indexOf:function(o){
if(!this.items.indexOf){
for(var i = 0, len = this.items.length; i < len; i=i+1){
if(this.items[i] == o){ return i;}
}
return -1;
}else{
return this.items.indexOf(o);
}
},
getCount:function(){
return this.length;
},
parseString:function(str){
str=$.parseJsonString(str);
(new Function("this.parseArray(" +str+")")).apply(this);
},
parseArray:function(o){
for(var i=0;i<o.length;i++){
if(o[i] && $.isArray(o[i])){
this.add(new $.DatasetList(o[i]));
}else if(o[i] && $.isObject(o[i])){
this.add(new $.DataMap(o[i]));
}else{
if(o[i]!=undefined && o[i]!=null)this.add(o[i]);
}
}
},
clear:function(){
this.items =[];
this.length=0;
//System.CG();
}
});
$.DatasetList.prototype.toString=function(){
var cl=[],is="";
for(var i=0;i<this.items.length;i++){
is="";
if(typeof(this.items[i])=="undefined" || this.items[i]==null){
is+="\"\"";
}else if(typeof(this.items[i])=="string"){
is="\"" + $.parseJsonValue(this.items[i]) + "\"";
}else{
is=this.items[i].toString();
}
cl.push(is);
}
return "[" + cl.join(",") + "]";
};
$.DatasetList.prototype.get=$.DatasetList.prototype.item;
$.DatasetList.prototype.put=$.DatasetList.prototype.add;
//AJAX 事件的快速绑定
/*$.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function(i, o){
$[o] = function(f) {
return this.bind(o, f);
};
});*/
var r20 = /%20/g,
rurl = /^(\w+:)?\/\/([^\/?#]+)/;
//Ajax
$.extend($,{
//ajax活动请求数目计数器
active: 0,
//将object转换为URL参数字符串
param:function(a) {
var s = [];
if(!a || !$.isObject(a)) return "";
for (var prefix in a) {
buildParams(prefix, a[prefix]);
}
//返回序列化后的字符串
return s.join("&").replace(r20, "+");
function buildParams(prefix, obj){
if ($.isArray(obj)) {
//序列化数组项
$.each(obj, function(i, v){
if (/\[\]$/.test(prefix)) {
//处理子项中 例如 prefix[key]的 name，直接插入v
add(prefix, v);
} else {
//处理子数组
buildParams(prefix + "[" + (typeof v==="object" || $.isArray(v)? i : "") + "]", v);
}
});
} else if(obj != null && typeof obj === "object"){
//序列化Object对象
$.each(obj, function(k, v){
//递归处理Object对象
buildParams(prefix + "[" + k + "]", v);
});
}else{
//插入Array和Object之外的数据类型值
add(prefix, obj);
}
}
function add(key, value){
//如果value是一个function，那么执行它，返回它的值
value = $.isFunction(value) ? value() : value;
//拼入URI编码后的字符串
s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
}
},
//ajax get 调用
get:function(url, data, callback, type){
//当 data 参数是 Function 类型时，对参数进行互换
if($.isFunction(data)){
type = type || callback;
callback = data;
data = null;
}
return $.ajaxRequest({
type: "GET",
url: url,
data: data,
success: callback,
dataType: type
});
},
//ajax执行远端js
getScript:function(url, callback){
return $.get(url, null, callback, "script");
},
//ajax请求JSON数据
getJSON: function(url, data, callback){
return $.get(url, data, callback, "json");
},
//ajax post 调用
post:function(url, data, callback, type) {
//当 data 参数是 Function 类型时，对参数进行互换
if ($.isFunction(data)) {
type = type || callback;
callback = data;
data = {};
}
return $.ajaxRequest({
type: "POST",
url: url,
data: data,
success: callback,
dataType: type
});
},
//写入或覆盖默认的ajax参数
ajaxSetup:function(settings) {
$.extend($.ajaxSettings, settings);
},
//默认的ajax配置参数
ajaxSettings:{
//要请求的url地址
url: location.href,
//是否全局的ajax 请求
global: true,
//XHR 请求类型
type: "GET",
//发送的数据格式
contentType: "application/x-www-form-urlencoded",
//是否有数据
processData: true,
//是否异步的ajax请求
async: true,
/*
//编码
//encoding:"GBK",
//超时时间
timeout: 0,
//XHR请求中要发送的数据
data: null,
//HTTP请求需要的用户名
username: null,
//HTTP请求需要的密码
password: null,
traditional: false,
*/
//获取XMLHttpRequest对象 xhr();
xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
function() {
return new window.XMLHttpRequest();
} :
function() {
try {
return new window.ActiveXObject("Microsoft.XMLHTTP");
} catch(e) {}
},
//从服务器端响应返回的数据格式
accepts: {
xml: "application/xml, text/xml",
html: "text/html",
script: "text/javascript, application/javascript",
json: "application/json, text/javascript",
text: "text/plain",
_default: "*/" + "*"
}
},
//Last-Modified header cache for next request
lastModified:{},
etag:{},
//ajax调用方法
ajaxRequest:function(origSettings){
//将默认参数 ajaxSettings 和入参 origSettings应用到{}上，取得调用所需的ajax参数
var s = $.extend(true,{}, $.ajaxSettings, origSettings);
//定义变量
var jsonp, status, data,
callbackContext = origSettings && origSettings.context || s,
type = s.type.toUpperCase();
//将要发送的data数据转换为字符串
if (s.data && s.processData && typeof s.data !=="string") {
s.data = $.param(s.data, s.traditional);
}
//处理JSONP类型的回调
if (s.dataType === "jsonp"){
//如果请求的类型是GET
if (type === "GET"){
//jsonp 请求需要在url中加入 callback=? 其中?在后面用回调函数名替换
if (!jsre.test(s.url)){ //判断url中是否有 “=?”的字符串
s.url +=(rquery.test( s.url )?"&" : "?") + (s.jsonp || "callback") + "=?";
}
}else if(!s.data || !jsre.test(s.data)){
//jsonp 请求需要在post 数据中加入 callback=?
s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
}
//请求数据类型改为json
s.dataType = "json";
}
//创建临时性的jsonp回调函数
//如果请求的数据类型是json,且url或data中包含 "=?" 则判定为是 jsonp请求
if(s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url))){
jsonp = s.jsonpCallback || ("jsonp" + jsc++);
//将url和data中的 "=?"用 "=jsonpcallback" 替换
if(s.data){
s.data=(s.data + "").replace(jsre, "=" + jsonp + "$1");
}
s.url = s.url.replace(jsre, "=" + jsonp + "$1");
//使用script的数据类型
s.dataType = "script";
//处理jsonp的载入和执行
window[jsonp] = window[jsonp] || function(tmp){
data = tmp;
success();
complete();
//临时函数的内存回收
window[jsonp] = undefined;
try {
delete window[jsonp];
} catch(e) {}
//从head中移除临时创建的script元素
if (head){
head.removeChild(script);
}
};
}
//如果请求的数据类型是script，则默认的缓存模式为false
if(s.dataType === "script" && s.cache === null){
s.cache = false;
}
//如果缓存模式为false，则拼入随机参数
if (s.cache === false && type === "GET"){
var ts = now();
//尝试替换"_="，即原有的随机参数
var ret = s.url.replace(rts, "$1_=" + ts + "$2");
//如果替换失败，则拼入随机参数
s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
}
//如果有data数据且请求模式为GET，则将data拼入到url后面
if (s.data && type === "GET") {
s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
}
//如果是第一个全局的ajax请求
/*if(s.global && !$.active++){
//执行ajaxStart时间
$.event.trigger("ajaxStart");
}*/
//解析url，判断是否跨域访问
var parts=rurl.exec(s.url),
remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
//如果是跨域访问，则尝试使用脚本注入GET方式来加载JSON或Script
if (s.dataType === "script" && type === "GET" && remote){
//在head中创建script元素
var head = document.getElementsByTagName("head")[0] || document.documentElement;
var script = document.createElement("script");
script.src = s.url;
if(s.scriptCharset ){
script.charset = s.scriptCharset;
}
//处理script载入
if ( !jsonp ) {
var done = false;
//为script元素添加加载事件
script.onload = script.onreadystatechange = function(){
if (!done && (!this.readyState ||
this.readyState === "loaded" || this.readyState === "complete")){
done = true;
success();
complete();
//在IE中，释放内存
script.onload = script.onreadystatechange = null;
if (head && script.parentNode) {
head.removeChild(script);
}
}
};
}
//使用insertBefore而不是appendChild，避免在ie6中的bug
head.insertBefore(script, head.firstChild);
//跳出ajax整体方法，在回调中做后续处理
return undefined;
}
//XMLHttpRequest请求逻辑开始
var requestDone = false;
//创建XMLHttpRequest对象
var xhr = s.xhr();
if(!xhr ){
return;
}
//打开连接
if (s.username){
xhr.open(type, s.url, s.async, s.username, s.password);
} else {
xhr.open(type, s.url, s.async);
}
//使用try/catch 来避免Firefox3中的bug
try{
//设置http头，contentType
if (s.data || origSettings && origSettings.contentType) {
xhr.setRequestHeader("Content-Type", s.contentType+ (s.encoding ?"; charset=" + s.encoding : ""));
}
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if (s.ifModified) {
if($.lastModified[s.url]) {
xhr.setRequestHeader("If-Modified-Since", $.lastModified[s.url]);
}
if ($.etag[s.url] ) {
xhr.setRequestHeader("If-None-Match", $.etag[s.url]);
}
}
//设置一个requestHeader，以告知服务端是一个XMLHttpRequest
//只有当它不是一个远程XHR请求时拼入
if (!remote) {
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
}
//设置接收的数据类型
xhr.setRequestHeader("Accept", s.dataType && s.accepts[s.dataType] ?
s.accepts[s.dataType] + ", */" + "*" :
s.accepts._default );
} catch(e) {}
//调用ajax调用入参中的beforeSend方法(如果有的话)，可以在方法里设置header/mime
//且如果该方法返回false,则取消XMLHttpRequest调用
if(s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false) {
//如果是最后一个ajax活动请求
/*if(s.global && !--$.active){
$.event.trigger("ajaxStop");
}*/
//关闭打开的连接
xhr.abort();
return false;
}
/*if(s.global){
trigger("ajaxSend", [xhr, s]);
}*/
//等待XHR响应事件
var onreadystatechange = xhr.onreadystatechange = function(isTimeout){
//请求被取消
if (!xhr || xhr.readyState === 0 || isTimeout === "abort") {
// Opera 在readyState==0时不能响应onreadystatechange方法
// 所以我们手动处理
if (!requestDone){
complete();
}
requestDone = true;
if (xhr){
//设置onreadystatechange 事件为空函数
xhr.onreadystatechange = $.noop;
}
//请求完成，并且返回数据可用，或者请求超时 The transfer is complete and the data is available, or the request timed out
}else if (!requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout")){
requestDone = true;
xhr.onreadystatechange = $.noop;
status = isTimeout === "timeout" ?
"timeout" :
!$.httpSuccess(xhr) ?
"error" :
s.ifModified && $.httpNotModified(xhr, s.url)?
"notmodified" :
"success";
var errMsg;
if (status === "success") {
//处理XML解析，并获取解析错误信息
try {
//处理返回的数据
data = $.httpData(xhr, s.dataType, s);
} catch(err) {
status = "parsererror";
errMsg = err;
}
}
//确保请求成功，且无更改
if (status === "success" || status === "notmodified"){
//jsonp调用它自己的回调函数
if (!jsonp){
success();
}
}else{
//处理错误信息
$.handleError(s, xhr, status, errMsg);
}
//运行complete回调
complete();
//如果超时，则取消request
if (isTimeout === "timeout"){
xhr.abort();
}
//释放XMLHttpRequest对象
if (s.async) {
xhr = null;
}
}
};
// Override the abort handler, if we can (IE doesn't allow it, but that's OK)
// Opera doesn't fire onreadystatechange at all on abort
try {
var oldAbort = xhr.abort;
xhr.abort = function(){
if ( xhr ) {
oldAbort.call(xhr);
}
onreadystatechange("abort");
};
} catch(e) { }
//超时检查
if (s.async && s.timeout > 0){
setTimeout(function(){
//检查请求是否正常
if (xhr && !requestDone) {
onreadystatechange("timeout");
}
}, s.timeout);
}
//发送data
try {
xhr.send(type === "POST" || type === "PUT" || type === "DELETE"?s.data:null);
} catch(e) {
$.handleError(s, xhr, null, e);
// 执行complete回调
complete();
}
//firefox 1.5不能在异步的XHR请求中触发statechagne事件
if (!s.async) {
onreadystatechange();
}
function success(){
//执行success回调
if(s.success){
s.success.call(callbackContext, data, status, xhr);
}
/*if(s.global){
trigger("ajaxSuccess", [xhr, s]);
}*/
}
function complete(){
//执行complete回调
if (s.complete){
s.complete.call( callbackContext, xhr, status);
}
//请求完成
/*if (s.global){
//执行全局或context上绑定的ajaxComplete事件
trigger("ajaxComplete", [xhr, s]);
}*/
//进行ajax请求计数处理
/*if (s.global && !--$.active){
//执行全局ajaxStop事件
$.event.trigger("ajaxStop");
}*/
}
/*function trigger(type, args) {
(s.context ? $(s.context) : $.event).trigger(type, args);
}*/
//将XMLHttpRequest对象返回，以在必须时可以取消这个XHR请求
return xhr;
},
handleError: function(s, xhr, status, e){
//处理error回调
if(s.error){
s.error.call( s.context || s, xhr, status, e );
}
//执行全局回调
/*if (s.global){
//触发s.content或全局的ajaxError事件
(s.context ? $(s.context) : $.event).trigger("ajaxError",[xhr, s, e]);
}*/
},
//检查XMLHttpRequest请求是否成功
httpSuccess: function(xhr){
try {
// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
return !xhr.status && location.protocol === "file:" ||
//当其它浏览器中status是304时候，Opera则是0
(xhr.status >= 200 && xhr.status < 300 ) ||
xhr.status === 304 || xhr.status === 1223 || xhr.status === 0;
} catch(e) {}
return false;
},
//通过响应的ResponseHeader内容检查XMLHttpRequest响应是否有更改
httpNotModified: function( xhr, url ) {
var lastModified = xhr.getResponseHeader("Last-Modified"),
etag = xhr.getResponseHeader("Etag");
if (lastModified) {
$.lastModified[url]= lastModified;
}
if (etag){
$.etag[url] = etag;
}
//当其它浏览器中status是304时候，Opera则是0
return xhr.status === 304 || xhr.status === 0;
},
httpData: function(xhr, type, s){
var ct = xhr.getResponseHeader("content-type") || "",
xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
data = xml ? xhr.responseXML : xhr.responseText;
if(xml && data.documentElement.nodeName === "parsererror"){
$.error("parsererror");
}
//如果ajax调用参数中有dataFilter函数，则使用dataFilter函数对返回的数据进行处理
if(s && s.dataFilter){
data = s.dataFilter(data, type);
}
//解析服务器返回的string数据
if (typeof data === "string"){
//如果请求的数据类型是json,则解析json数据
if (type === "json" || !type && ct.indexOf("json") >= 0){
data = $.parseJSON(data);
// 如果请求的数据类型是script，那么执行script
}else if( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
$.globalEval(data);
}
}
return data;
}
});
return $;
})(window.Zepto);
|
