B.msie、B.version、B.safari……
* @name giant.B */
giant.B = {};
/** 浏览器版本。
* @type String */
giant.B.version = (__userAgent__.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1];
/** 是否是Safari浏览器。
* @type Boolean */
giant.B.safari = /webkit/.test( __userAgent__ );
/** 是否是Opera浏览器。
* @type Boolean */
giant.B.opera = /opera/.test( __userAgent__ );
/** 是否是IE浏览器。
* @type Boolean */
giant.B.msie = /msie/.test( __userAgent__ ) && !/opera/.test( __userAgent__ );
/** 是否是Mozilla浏览器。
* @type Boolean */
giant.B.mozilla = /mozilla/.test( __userAgent__ ) && !/(compatible|webkit)/.test( __userAgent__ );
window.B = giant.B;
/**
* 一个空函数引用。
* @field
* @type Function
*/
giant.EmptyFn = function() {};
/**
* 若指定的对象 o 是一个布尔值对象，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isBool = function(o) { return typeof o === 'boolean'; };
/**
* 若指定的对象 o 是一个HTMLElement对象，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isElement = function(o) { return o && o.nodeType === 1; };
/**
* 若指定的对象 o 是一个空字符串或者是一个长度为0的数组，则返回 true，否则返回 false .
* @param {Object} o 要检查的对象 .
* @type Boolean
*/
giant.isEmpty = function(o) {
return giant.isArray(o) ? o.length === 0 : (giant.isString(o) ? o === String.Empty : false);
};
/**
* 若指定的对象 o 是一个null值或者空字符串或者是一个长度为0的数组，则返回 true，否则返回 false .
* @param {Object} o 要检查的对象 .
* @type Boolean
*/
giant.isNullOrEmpty = function(o) {
return (o == null || this.isEmpty(o));
};
/**
* 若指定的对象 o 是一个字符串，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isString = function(o) { return typeof o === 'string'; };
/**
* 若指定的对象 o 是一个数组，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isArray = function(o) { return __tostr__.call(o) === '[object Array]'; };
/**
* 若指定的对象 o 是一个函数，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isFunction = function(o) { return __tostr__.call(o) === '[object Function]'; };
/**
* 若指定的对象 o 是一个数字，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isNumber = function(o) { return typeof o === "number" && isFinite(o); };
/**
* 若指定的对象 o 是一个undefined，则返回 true，否则返回 false。
* @param {Object} o 要检查的对象。
* @type Boolean
*/
giant.isUndef = function(o) { return typeof o === 'undefined'; };
/**
* 用于对象属性的快速复制(继承)。将source的属性或方法复制(继承)到对象
* target中，若deep为true，则子对象的子属性
* 也一起被复制(继承)。相同属性的将会被source中的新属性覆盖。
* @example
* var source = {id:1, name:'Jack Source'}, target = {name:'Jack Target', gender:1};
* var newObj1 = Object.extend(target, source);
* // newObj1 -->> {id:1, name:'Jack Source', gender:1}
* Object.extend(target);
* // Object.name -->> 'Jack Target'
* // Object.gender -->> 1
*
* @param {Object} target 目标对象。
* @param {Object} source 源对象。
* @param {boolean} deep 是否复制(继承)对象中的对象。
* @returns {Object} 返回继承了source对象属性的新对象。
*/
Object.extend = function(target, /*optional*/source, /*optional*/deep) {
target = target || {};
var sType = typeof source, i = 1, options;
if( sType === 'undefined' || sType === 'boolean' ) {
deep = sType === 'boolean' ? source : false;
source = target;
target = this;
}
if( typeof source !== 'object' &&
__tostr__.call(source) !== '[object Function]' )
source = {};
while(i <= 2) {
options = i === 1 ? target : source;
if( options != null ) {
for( var name in options ) {
var src = target[name], copy = options[name];
if(target === copy)
continue;
if(deep && copy && typeof copy === 'object' && !copy.nodeType)
target[name] = this.extend(src ||
(copy.length != null ? [] : {}), copy, deep);
else if(copy !== undefined)
target[name] = copy;
}
}
i++;
}
return target;
};
Object.extend(String.prototype,
/** @lends String */
{
/**
* 返回字符串的副本，用引号引用此字符串。
* @returns {String} 被双引号引用的字符串。
*/
quote: function() {
var reEscapeable = /[\"\\\x00-x1f\x7f-\x9f]/g;
if( reEscapeable.test(this) ) {
return '"' + this.replace(reEscapeable, function(a) {
var c = String.SpecialChars[a];
if( typeof c === 'string' )
return c;
c = a.charCodeAt();
return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
}) + '"';
}
return '"' + this + '"';
},
/**
* 返回字符串的副本，忽略前导空白和尾部空白。
* @returns {String} 此字符串移除了前导和尾部空白，如果没有前导和尾部空白字符，则返回此字符串。
*/
trim: function() { return this.replace(/^\s+|\s+$/g, ''); },
/**
* 返回字符串的副本，忽略前导空白。
* @returns {String} 此字符串移除了前导空白，如果没有前导空白字符，则返回此字符串。
*/
ltrim: function() { return this.replace(/^\s+/g, ''); },
/**
* 返回字符串的副本，忽略尾部空白。
* @returns {String} 此字符串移除了尾部空白，如果没有尾部空白字符，则返回此字符串。
*/
rtrim: function() { return this.replace(/\s+$/g, ''); },
/**
* 返回字符串的副本，忽略前导空白和尾部空白。
* @returns {String}
* @see 见trim()
*/
strip: function() { return this.trim(); },
/**
* 返回字符串的副本，忽略字符串内部的含有的所有标签字符串。
* @param {String} replacement 用于替换标签的指定字符串。
* @returns {String} 此字符串移除了所有的表为HTML标签的字符，如没有标签字符，则返回此字符串。
*/
stripTags: function(replacement) {
return this.replace(/<\/?[^>]+>/ig, (replacement || ''));
},
/**
* 返回字符串的副本，忽略字符串内部的含有的所有标签字符串包括忽略标签里有一些JS事件。
* @param {String} replacement 用于替换标签的指定字符串。
* @returns {String} 此字符串移除了所有的表为HTML标签的字符，如没有标签字符，则返回此字符串。
*/
stripAllTags: function (replacement) {
return this.replace(/<(?:\"[^\"]*\"|\'[^\']*\'|[^><])*>/igm, (replacement || ''));
},
/**
* 返回字符串的副本，忽略字符串的HTML的Script标签字符串。
* @param {String} replacement 用于替换标签的指定字符串。
* @returns {String} 此字符串移除了所有的表示为HTML的Script标签的字符，如没有Script标签，则返回此字符串。
*/
stripScript: function(replacement) {
return this.replace(new RegExp(RegExp.ScriptExpr), (replacement || ''));
},
/**
* 返回字符串的副本，忽略字符串的HTML标签中的JS事件如onload,onclick等。
* @param {String} replacement 用于替换标签的指定字符串。
* @returns {String} 此字符串移除了所有的表示为HTML的JS事件的字符，如没有JS事件，则返回此字符串。
*/
striptJsEvents:function(replacement){
return this.replace(/<[a-z][^>]*\s*on[a-z]+\s*=[^>]+/ig, function($0, $1) {
return $0.replace(/\s*on[a-z]+\s*=\s*("[^"]+"|'[^']+'|[^\s]+)\s*/ig, replacement||"");
});
},
/**
* 返回字符串的副本，字符串中的特定字符将被转换。unescapeHTML 方法可还原经该方法转换的字符串。
* @example
*
* & --> &
* < --> <
* > --> &>
* " --> "
* ' --> '
*
* @returns {String} 此字符串将转换特定的字符，如没有那些字符，则返回此字符串。
*/
escapeHTML: function() {
return this.replace(/&/g, '&').replace(//g, '>')
.replace(/\"/g, '"').replace(/\'/g, ''');
},
/**
* 返回字符串的副本，字符串中的特定字符将被转换，escapeHTML 方法可还原经该方法转换的字符串。
* @example
*
* & --> &
* < --> <
* > --> >
* " --> "
* ' --> '
*
* @returns {String} 此字符串将转换特定的字符，如没有那些字符，则返回此字符串。
*/
unescapeHTML: function() {
return this.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>')
.replace(/"/g, '"').replace(/'/g, '\'');
},
/**
* 返回字符串的副本，字符串中的格式字符将被转换。
* @example
*
* // reverse == true时，以下字符将被转换：
* <br /> --> \n
* --> _ (表示一个空格)
* & --> &
* // reverse == false时，以下字符将被转换：
* & --> &
* _(blank) -->
* \r\n --> \n
* \n --> <br />
*
* @param {Boolean} reverse 指示是否使用反向转换。
* @returns {String} 此字符串将转换格式字符，如没有格式字符，则返回此字符串。
*/
formatHTML: function(reverse) {
var str = this.toString();
if( reverse ) {
str = str.replace(/
* background-color --> backgroundColor
* border-top-color --> borderTopColor
*
* @returns {String} 新的字符串，它移除原字符串的短线 -，并将短线后第一个字符转为大写。
*/
toCamel: function() {
var aParts = this.split('-'), iLen = aParts.length;
if( iLen == 1 ) return aParts[0];
var camelized = this.charAt(0) === '-' ? aParts[0].charAt(0).toUpperCase() +
aParts[0].substring(1) : aParts[0];
for( var i = 1; i < iLen; i++ )
camelized += aParts[i].charAt(0).toUpperCase() + aParts[i].substring(1);
return camelized;
},
/**
* 测试此字符串是否以指定的前缀开始。
* @param {String} p 指定的前缀。
* @returns {boolean} 如果该参数表示的字符序列是此字符串表示的字符序列的前缀，则为true，
* 否则为false。还要注意，如果参数是空字符串，则返回true。
*/
startsWith: function(p) {
return p === '' ? true : (this.indexOf(p) === 0);
},
/**
* 测试此字符串是否以指定的后缀结束。
* @param {String} p 指定的后缀。
* @returns {boolean} 如果该参数表示的字符序列是此字符串表示的字符序列的后缀，则为true，
* 否则为false。还要注意，如果参数是空字符串，则返回true。
*/
endsWith: function(p) {
if( p === '' ) return true;
var d = this.length - p.length;
return d >= 0 && this.lastIndexOf(p) === d;
},
/**
* 测试此字符串是否是一串空格组成的空字符串。
* @returns {boolean} 如果该字符串是一串字可知组成的字符串，则为true，否则为false。
*/
isBlank: function() { return this.length > 0 && /^\s*$/.test(this); },
/**
* 测试此字符串是否是一个正确格式的Email。
* @returns {boolean} 如果该字符串是一个正确格式的Email，则为true，否则为false。
*/
isEmail: function() { return (/^(?:\w+\.?)*\w+@(?:\w+\.?)*[a-zA-Z]{2,3}$/i).test(this.trim()); },
/**
* 测试此字符串是否是空字符串。
* @returns {boolean} 如果该字符串是空字符串，则为true，否则为false。
*/
isEmpty: function() { return this === String.Empty; },
/**
* 测试此字符串是否全部由数字组成。
* @returns {boolean} 如果该字符串全部由数字组成，则为true，否则为false。
*/
isNumber: function() { return /^\d+$/.test(this); },
/**
* 测试此字符串是否为合法的变量命名。
* @returns {boolean} 如果该字符串为合法的变量命名格式，则为true，否则为false。
*/
isVar: function() { return /^[a-zA-Z]\w+$/.test(this); },
/**
* 将此字符串转换成JSON格式。
* @returns {String} 此字符串的JSON格式的副本。
*/
toJSON: function() { return this.quote(); }
}, true);
/**
* 创建一个新的StringBuilder实例。
* @class
* 一个类似于java.lang.StringBuffer的可变字符序列。
* @example
* var sb = new StringBuilder();
* sb.append('<div id="div1">\n');
* sb.append(' <h2>this is a h2 title.</h2>\n');
* sb.append('</div>\n');
* var shtml = sb.toString();
* // shtml为: "<div id="div1">\n <h2>this is a h2 title.</h2>\n</div>"
*
* @constructor
* @name StringBuilder
* @param {Object} o 要添加到序列首部的对象。
* @returns {StringBuilder}的新实例。
*/
function StringBuilder(o) {
this.__strings__ = [];
if( o )
this.append(o);
};
/**#@+
* @memberOf StringBuilder
* @method
*/
StringBuilder.prototype = {
/**
* 追加Object参数的字符串表示形式。
* 参数将被转换成字符串，就好象使用了 o.toString() 方法一样。然后，将所得字符串中的字符追加到此序列。* @param {Object} o 一个Object * @returns 返回这个
StringBuilder 对象的一个引用。
* @type StringBuilder
*/
append: function(o) {
if( !o )
return this;
if( Object.prototype.toString.call(o) === '[object Array]' )
this.__strings__.push(o.join('').toString());
else
this.__strings__.push(o.toString());
return this;
},
/**
* 清空此字符序列。
* @type void
*/
clear: function() { this.__strings__ = []; },
/**
* 返回长度（字符数）。
* 该长度与给定的表示编码的参数有关。在UTF-8编码中，一个全角字符表示3个英文字符。
* 不指定字符编码情况下，默认为正常的长度，即所有字符的长度为1。
* @param {boolean} b 是否使用UTF-8字符编码解析序列长度。
* @returns {Number} 返回给定字符编码的此序列的长度。
*/
length: function(b) {
if( arguments.length == 0 )
b = false;
var s = this.toString();
if( b )
return s.replace(/[^\x00-xFF]/g,'***').length;
return s.length;
},
/**
* 返回此序列中数据的字符串表示形式。
* 分配一个新的 String 对象，并将它初始化，以包含当前由此对象表示的字符串序列。然后返回此 String。
* 对此序列的后续更改不影响该 String 的内容。
*
* @return {String} 字符序列的字符串表示形式。
*/
toString: function() {
var __newString__ = this.__strings__.join('');
return __newString__;
}
};
/**
* Web系统中统一的Ajax控制工具类。
* @class Ajax控制工具类。
* @constructor
*/
var GiantAjax = function() {};
window.GiantAjax = GiantAjax;
(function($) {
/**
* @class Ajax请求的返回状态值信息。
* 该类的快捷引用是：AjaxStatus，如：AjaxStatus.success
* @name giant.Status
*/
GiantAjax.Status = {
/**
* 表示Ajax请求返回成功的标识。
* @type Number
*/
success: 1,
/**
* 表示Ajax请求返回失败的标识。
* @type Number
*/
failure: 0,
/**
* 表示Ajax请求发生错误的标识。
* @type Number
*/
error: -1
};
window.AjaxStatus = GiantAjax.Status;
/**
* Ajax请求的默认载入控制器前缀。
* @type String
*/
GiantAjax.LOAD = "ajaxLoad";
/**
* Ajax请求的默认保存控制器前缀。
* @type String
*/
GiantAjax.SAVE = "ajaxSave";
/**
* Ajax请求的默认更新控制器前缀。
* @type String
*/
GiantAjax.UPDATE = "ajaxUpdate";
/**
* Ajax请求的默认上传控制器前缀。
* @type String
*/
GiantAjax.UPLOAD = "ajaxUpload";
/**
* Ajax请求的默认删除控制器前缀。
* @type String
*/
GiantAjax.DELETE = "ajaxDelete";
/**
* 用于执行响应返回Html的Ajax请求。
* @example
*
* GiantAjax.responseHtml('#div1', {
* url: '/profile/ajaxLoadWorkExps.do',
* params: { uid:'MMMMMMMMMMMMMM' },
* error: function(xhr, status, error) {
* // Ajax请求错误时，将执行该函数
* alert(status);
* },
* before: function() {
* // this 表示Ajax请求传递的 options 参数
* // return false; 若返回 false，则取消本次Ajax请求
* return true;
* },
* success: function() {
* // div1内的Html被此请求返回的Html替换后，执行的回调函数
* // this 表示Ajax请求传递的 options 参数
* }
* });
*
*
* @param {String} container 装载返回的Html代码的Html容器Id。
* @param {Object} options Ajax请求的相关参数。
* GiantAjax.requestHtml({
* url: '/profile/ajaxLoadWorkExps.do',
* params: { uid:'MMMMMMMMMMMMMM' },
* error: function(xhr, status, error) {
* // Ajax请求错误时，将执行该函数
* alert(status);
* },
* before: function() {
* // this 表示Ajax请求传递的 options 参数
* // return false; 若返回 false，则取消本次Ajax请求
* return true;
* },
* success: function(html) {
* // 成功请求后，执行的回调函数
* // this 表示Ajax请求传递的 options 参数
* }
* });
*
*
* @param {String} container 装载返回的Html代码的Html容器Id。
* @param {Object} options Ajax请求的相关参数。
* GiantAjax.responseJson({
* url: '/profile/ajaxLoadWorkExps.do',
* params: { uid:'MMMMMMMMMMMMMM' },
* error: function(xhr, status, error) {
* // Ajax请求错误时，将执行该函数
* alert(status);
* },
* before: function() {
* // this 表示Ajax请求传递的 options 参数
* // return false; 若返回 false，则取消本次Ajax请求
* // 该方法与jQuery的beforeSend相同
* return true;
* },
* success: function(jsonData) {
* // Ajax成功执行后的回调函数
* }
* });
* // 跨域Ajax请求
* GiantAjax.responseJson({
* crossdomain: true,
* url: '/profile/ajaxLoadWorkExps.do',
* params: { uid:'MMMMMMMMMMMMMM' },
* success: function(jsonData) {
* // Ajax成功执行后的回调函数
* }
* });
* // 跨域Ajax请求返回的JSON
* // jsonCallback是事先定义要执行的函数名(该函数名根据需要进行更改)
* jsonCallback(JSON数据)
*
*
* @param {Object} options Ajax请求的相关参数。* // FORM表单的Ajax方式提交 * GiantAjax.formSubmit('#form_login', { * // 此方法通常只做表单数据验证，和一些数据的前期处理 * beforeSubmit: function() { * if(this.userAccount.value=='' || this.userPassword.value=='') { * alert('请输入对应的账号和密码！'); * return false; * } * return true; * }, * success: function(data) { alert(data.message); }, * dataType: 'json' * }); ** * @param {String} formId 要执行Ajax提交的表单Id(前缀可包含#)。 * @param {Object} options Ajax请求的相关参数。