jquery插件 源码

下面是对Jquery几个经常用到的地方进行的增强。

功能是参考百度七巧板JS框架来完成的。

一、页面属性

$.page.getHeight():获取页面高度

$.page.getWidth():获取页面宽度
$.page.createStyleSheet(options):在页面中创建样式表对象
$.page.getScrollTop():获取纵向滚动量
$.page.getScrollLeft():获取横向滚动量
$.page.getViewHeight():获取页面视觉区域高度
$.page.getViewWidth():获取页面视觉区域宽度
$.page.getMousePosition(element):获得页面里的目前鼠标所在的坐标
$.page.getPosition(element):获取目标元素相对于整个文档左上角的位置
$.page.lazyLoadImage(options):延迟加载图片. 默认只加载可见高度以上的图片, 随着窗口滚动加载剩余图片.注意: 仅支持垂直方向.
$.page.loadCssFile(path):动态在页面上加载一个外部css文件
$.page.loadJsFile(path):动态在页面上加载一个外部js文件
$.page.load(resources, options, ignoreAllLoaded):加载一组资源，支持多种格式资源的串/并行加载，支持每个文件有单独回调函数。

二、浏览器判断
$.browser.ie
$.browser.firefox
$.browser.chrome
$.browser.isGecko
$.browser.isWebkit
$.browser.isStrict
$.browser.opera
$.browser.safari



三、平台判断
$.platform.isAndroid
$.platform.isIpad
$.platform.isIphone
$.platform.isMacintosh
$.platform.isWindows
$.platform.isX11



四、字符串处理
$.string.decodeHTML(source):对目标字符串进行html解码
$.string.encodeHTML(source):对目标字符串进行html编码
$.string.stripTags(source):去掉字符串中的html标签
$.string.escapeReg(source):将目标字符串中可能会影响正则表达式构造的字符串进行转义。
$.string.trim(source):删除目标字符串两端的空白字符



五、类型
$.lang.guid():返回一个当前页面的唯一标识字符串。
$.lang.isFunction(source):判断目标参数是否为function或Function实例
$.lang.isElement(source):判断目标参数是否为Element对象
$.lang.isArray(source):判断目标参数是否Array对象



六、数组
$.array.indexOf(source, match, fromIndex):查询数组中指定元素的索引位置
$.array.contains(source, obj):判断一个数组中是否包含给定元素
$.array.empty(source):清空一个数组
$.array.lastIndexOf(source, match, fromIndex):从后往前，查询数组中指定元素的索引位置
$.array.map(source, iterator, thisObject):遍历数组中所有元素，将每一个元素应用方法进行转换，并返回转换后的新数组。
$.array.reduce(source, iterator, initializer):遍历数组中所有元素，将每一个元素应用方法进行合并，并返回合并后的结果。
$.array.remove(source, match):移除数组中的项
$.array.removeAt(source, index):移除数组中的项
$.array.unique(source, compareFn):过滤数组中的相同项。如果两个元素相同，会删除后一个元素。



七、cookie
$.cookie.getRaw(key):获取cookie的值，不对值进行解码
$.cookie.setRaw(key, value, options):设置cookie的值，不对值进行编码
$.cookie.remove(key, options):删除cookie的值
$.cookie.get(key):获取cookie的值，用decodeURIComponent进行解码
$.cookie.set(key, value, options):设置cookie的值，用encodeURIComponent进行编码



八、整数
$.number.comma(source, length):为目标数字添加逗号分隔
$.number.randomInt(min, max):生成随机整数，范围是[min, max]
$.number.pad(source, length):对目标数字进行0补齐处理



九、日志
$.sio.log(url):通过请求一个图片的方式令服务器存储一条日志,常用于记录用户点击位置，进行分析统计



十、URL
$.url.escapeSymbol(source):对字符串进行%#&+=以及和s匹配的所有字符进行url转义
$.url.getQueryValue(url, key):根据参数名从目标URL中获取参数值
$.url.jsonToQuery(json, replacer_opt):将json对象解析成query字符串

$.url.queryToJson(url):解析目标URL中的参数成json对象

;(function($){
    $.extend({
        hasClass:function(targetClassName){
            var className = $(this).attr("class");
            var classArray = className.split(" ");
            if(className && classArray.length == 0){
                if(targetClassName == className) return true;
            }else if(className && classArray.length > 0){
                for(var i=0; i<=classArray.length-1; i++){
                    if(classArray[i] == targetClassName) return true;
                }
            }

            return false;
        },
        
        getDocument:function (element) {
            return $.lang.isElement(element) ? element : element.ownerDocument || element.document;
        }
    });
})(jQuery);

;(function($){
    $.lang = $.lang || {};
    
    $.lang.isFunction = function (source) {
        // chrome下,'function' == typeof /a/ 为true.
        return '[object Function]' == Object.prototype.toString.call(source);
    };
    
    $.lang.isString = function (source) {
        return '[object String]' == Object.prototype.toString.call(source);
    };
})(jQuery);

;(function($){
    
    $.page = $.page || {};
    $.page.xy = {x:0, y:0};//当前鼠标坐标

    $.page.getHeight = $.page.getHeight || function(){
        var doc = document,
        body = doc.body,
        html = doc.documentElement,
        client = doc.compatMode == 'BackCompat' ? body : doc.documentElement;

        return Math.max(html.scrollHeight, body.scrollHeight, client.clientHeight);
    };

    $.page.getWidth  = $.page.getWidth || function () {
        var doc = document,
        body = doc.body,
        html = doc.documentElement,
        client = doc.compatMode == 'BackCompat' ? body : doc.documentElement;

        return Math.max(html.scrollWidth, body.scrollWidth, client.clientWidth);
    };

    $.page.createStyleSheet = $.page.createStyleSheet || function(options){
        var op = options || {},
            doc = op.document || document,
            s;

        if ($.browser.ie) {
            //修复ie下会请求一个undefined的bug  berg 2010/08/27 
            if(!op.url)
                op.url = "";
            return doc.createStyleSheet(op.url, op.index);
        } else {
            s = "<style type='text/css'></style>";
            op.url && (s="<link type='text/css' rel='stylesheet' href='"+op.url+"'/>");
            $("HEAD:eq(0)").after(s);
        }
    };

    $.page.getScrollTop =  $.page.getScrollTop || function(){
        var d = document;
        return window.pageYOffset || d.documentElement.scrollTop || d.body.scrollTop;
    };

    $.page.getScrollLeft= $.page.getScrollLeft || function () {
        var d = document;
        return window.pageXOffset || d.documentElement.scrollLeft || d.body.scrollLeft;
    };

    $.page.getViewHeight = $.page.getViewHeight || function () {
        var doc = document,
            client = doc.compatMode == 'BackCompat' ? doc.body : doc.documentElement;

        return client.clientHeight;
    };

    $.page.getViewWidth = function () {
        var doc = document,
            client = doc.compatMode == 'BackCompat' ? doc.body : doc.documentElement;

        return client.clientWidth;
    };
    
    $(document).bind("mousemove", function(e){
        e = window.event || e;
        $.page.xy.x = e.clientX;
        $.page.xy.y = e.clientY;
        //console.log(e.clientX+","+e.clientY);
    });

    $.page.getMousePosition = $.page.getMousePosition || function(){
        return {
            x : $.page.getScrollLeft() + $.page.xy.x,
            y : $.page.getScrollTop() + $.page.xy.y
        };
    };

    /**
     * 获取目标元素相对于整个文档左上角的位置
     * @grammar $.dom.getPosition(element)
     * @param {HTMLElement|string} element 目标元素或目标元素的id
     *             
     * @returns {Object} 目标元素的位置，键值为top和left的Object。
     */
    $.page.getPosition = function (element) {
        var doc = $.getDocument(element),
            browser = $.browser
        // Gecko 1.9版本以下用getBoxObjectFor计算位置
        // 但是某些情况下是有bug的
        // 对于这些有bug的情况
        // 使用递归查找的方式
            BUGGY_GECKO_BOX_OBJECT = browser.isGecko > 0 && 
                                     doc.getBoxObjectFor &&
                                     $(element).css('position') == 'absolute' &&
                                     (element.style.top === '' || element.style.left === ''),
            pos = {"left":0,"top":0},
            viewport = (browser.ie && !browser.isStrict) ? doc.body : doc.documentElement,
            parent;
        var box;
        
        if(element == viewport){
            return pos;
        }

        if(element.getBoundingClientRect){ // IE and Gecko 1.9+
            //当HTML或者BODY有border width时, 原生的getBoundingClientRect返回值是不符合预期的
            //考虑到通常情况下 HTML和BODY的border只会设成0px,所以忽略该问题.
            doc = document;
            box = element.getBoundingClientRect();

            pos.left = Math.floor(box.left) + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft);
            pos.top  = Math.floor(box.top)  + Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop);
            
            // IE会给HTML元素添加一个border，默认是medium（2px）
            // 但是在IE 6 7 的怪异模式下，可以被html { border: 0; } 这条css规则覆盖
            // 在IE7的标准模式下，border永远是2px，这个值通过clientLeft 和 clientTop取得
            // 但是。。。在IE 6 7的怪异模式，如果用户使用css覆盖了默认的medium
            // clientTop和clientLeft不会更新
            pos.left -= doc.documentElement.clientLeft;
            pos.top  -= doc.documentElement.clientTop;
            
            var htmlDom = doc.body,
                // 在这里，不使用element.style.borderLeftWidth，只有computedStyle是可信的
                htmlBorderLeftWidth = parseInt($(htmlDom).css('borderLeftWidth')),
                htmlBorderTopWidth = parseInt($(htmlDom).css('borderTopWidth'));
            if(browser.ie && !browser.isStrict){
                pos.left -= isNaN(htmlBorderLeftWidth) ? 2 : htmlBorderLeftWidth;
                pos.top  -= isNaN(htmlBorderTopWidth) ? 2 : htmlBorderTopWidth;
            }
        /*
         * 因为firefox 3.6和4.0在特定页面下(场景待补充)都会出现1px偏移,所以暂时移除该逻辑分支
         * 如果 2.0版本时firefox仍存在问题,该逻辑分支将彻底移除. by rocy 2011-01-20
        } else if (doc.getBoxObjectFor && !BUGGY_GECKO_BOX_OBJECT){ // gecko 1.9-

            // 1.9以下的Gecko，会忽略ancestors的scroll值
            // https://bugzilla.mozilla.org/show_bug.cgi?id=328881 and
            // https://bugzilla.mozilla.org/show_bug.cgi?id=330619

            box = doc.getBoxObjectFor(element);
            var vpBox = doc.getBoxObjectFor(viewport);
            pos.left = box.screenX - vpBox.screenX;
            pos.top  = box.screenY - vpBox.screenY;
            */
        } else { // safari/opera/firefox
            parent = element;

            do {
                pos.left += parent.offsetLeft;
                pos.top  += parent.offsetTop;
                // safari里面，如果遍历到了一个fixed的元素，后面的offset都不准了
                if (browser.isWebkit > 0 && $(parent).css('position') == 'fixed') {
                    pos.left += doc.body.scrollLeft;
                    pos.top  += doc.body.scrollTop;
                    break;
                }
                
                parent = parent.offsetParent;
            } while (parent && parent != element);

            // 对body offsetTop的修正
            if(browser.opera > 0 || (browser.isWebkit > 0 && $(parent).css('position') == 'absolute')){
                pos.top  -= doc.body.offsetTop;
            }

            // 计算除了body的scroll
            parent = element.offsetParent;
            while (parent && parent != doc.body) {
                pos.left -= parent.scrollLeft;
                // see https://bugs.opera.com/show_bug.cgi?id=249965
    //            if (!b.opera || parent.tagName != 'TR') {
                if (!browser.opera || parent.tagName != 'TR') {
                    pos.top -= parent.scrollTop;
                }
                parent = parent.offsetParent;
            }
        }

        return pos;
    };

    /**
     * 延迟加载图片. 默认只加载可见高度以上的图片, 随着窗口滚动加载剩余图片.注意: 仅支持垂直方向.
     * @grammar $.page.lazyLoadImage([options])
     * @param {Object} options
     * @param {String} [options.className] 延迟加载的IMG的className,如果不传入该值将延迟加载所有IMG.
     * @param {Number} [options.preloadHeight] 预加载的高度, 可见窗口下该高度内的图片将被加载.
     * @param {String} [options.placeHolder] 占位图url.
     * @param {Function} [options.onlazyload] 延迟加载回调函数,在实际加载时触发.
     */
    $.page.lazyLoadImage = function(options) {
        options = options || {};
        options.preloadHeight = options.preloadHeight || 0;

        $(document).ready(function() {
            var imgs = document.getElementsByTagName('IMG'),
                    targets = imgs,
                    len = imgs.length,
                    i = 0,
                    viewOffset = getLoadOffset(),
                    srcAttr = 'data-tangram-ori-src',
                    target;
            //避免循环中每次都判断className
            if (options.className) {
                targets = [];
                for (; i < len; ++i) {
                    if ($(imgs[i]).hasClass(options.className)) {
                        targets.push(imgs[i]);
                    }
                }
            }
            //计算需要加载图片的页面高度
            function getLoadOffset() {
                return $.page.getScrollTop() + $.page.getViewHeight() + options.preloadHeight;
            }
            //加载可视图片
            for (i = 0, len = targets.length; i < len; ++i) {
                target = targets[i];
                if ($.page.getPosition(target).top > viewOffset) {
                    target.setAttribute(srcAttr, target.src);
                    options.placeHolder ? target.src = options.placeHolder : target.removeAttribute('src');
                }
            }
            //处理延迟加载
            var loadNeeded = function() {
                var viewOffset = getLoadOffset(),
                    imgSrc,
                    finished = true,
                    i = 0,
                    len = targets.length;
                for (; i < len; ++i) {
                    target = targets[i];
                    imgSrc = target.getAttribute(srcAttr);
                    imgSrc && (finished = false);
                    if ($.page.getPosition(target).top < viewOffset && imgSrc) {
                        target.src = imgSrc;
                        target.removeAttribute(srcAttr);
                        $.lang.isFunction(options.onlazyload) && options.onlazyload(target);
                    }
                }
                //当全部图片都已经加载, 去掉事件监听
                finished && $(window).unbind('scroll', loadNeeded);
            };

            $(window).bind('scroll', loadNeeded);
        });
    };

    /**
     * 动态在页面上加载一个外部css文件
     * @grammar $.page.loadCssFile(path)
     * @param {string} path css文件路径
     */
    $.page.loadCssFile = function (path) {
        var element = document.createElement("link");
        
        element.setAttribute("rel", "stylesheet");
        element.setAttribute("type", "text/css");
        element.setAttribute("href", path);

        document.getElementsByTagName("head")[0].appendChild(element);        
    };


    /**
     * 动态在页面上加载一个外部js文件
     * @grammar $.page.loadJsFile(path)
     * @param {string} path js文件路径
     */
    $.page.loadJsFile = function (path) {
        var element = document.createElement('script');

        element.setAttribute('type', 'text/javascript');
        element.setAttribute('src', path);
        element.setAttribute('defer', 'defer');

        document.getElementsByTagName("head")[0].appendChild(element);    
    };

    /**
     *
     * 加载一组资源，支持多种格式资源的串/并行加载，支持每个文件有单独回调函数。
     *
     * @name $.page.load
     * @function
     * @grammar $.page.load(resources[, options])
     *
     * @param {Array} resources               资源描述数组，单个resource含如下属性.
     * @param {String} resources.url           链接地址.
     * @param {String} [resources.type]        取值["css","js","html"]，默认参考文件后缀.
     * @param {String} [resources.requestType] 取值["dom","ajax"]，默认js和css用dom标签，html用ajax.
     * @param {Function} resources.onload        当前resource加载完成的回调函数，若requestType为ajax，参数为xhr(可能失效)，responseText；若requestType为dom，无参数，执行时this为相应dom标签。.
     *
     * @param {Object} [options]               可选参数.
     * @param {Function} [options.onload]        资源全部加载完成的回调函数，无参数。.
     * @param {Boolean} [options.parallel]      是否并行加载，默认为false，串行。.
     * @param {Boolean} [ignoreAllLoaded]       全部加载之后不触发回调事件.主要用于内部实现.
     *
     *
     * @remark
     *  //串行实例
     *  baidu.page.load([
     *      { url : "http://img.baidu.com/js/tangram-1.3.2.js" },
     *      {url : "http://xxx.baidu.com/xpath/logicRequire.js",
     *          onload : fnOnRequireLoaded
     *      },
     *      { url : "http://xxx.baidu.com/xpath/target.js" }
     *  ],{
     *      onload : fnWhenTargetOK
     *  });
     *  //并行实例
     *  baidu.page.load([
     *      {
     *          url : "http://xxx.baidu.com/xpath/template.html",
     *          onload : fnExtractTemplate
     *      },
     *      { url : "http://xxx.baidu.com/xpath/style.css"},
     *      {
     *          url : "http://xxx.baidu.com/xpath/import.php?f=baidu.*",
     *          type : "js"
     *      },
     *      {
     *          url : "http://xxx.baidu.com/xpath/target.js",
     *      },
     *      {
     *          url : "http://xxx.baidu.com/xpath/jsonData.js",
     *          requestType : "ajax",
     *          onload : fnExtractData
     *      }
     *  ],{
     *      parallel : true,
     *      onload : fnWhenEverythingIsOK
     * });
     */
    $.page.load = function(resources, options, ignoreAllLoaded) {
        options = options || {};
        var self = $.page.load,
            cache = self._cache = self._cache || {},
            loadingCache = self._loadingCache = self._loadingCache || {},
            parallel = options.parallel;

        function allLoadedChecker() {
            for (var i = 0, len = resources.length; i < len; ++i) {
                if (! cache[resources[i].url]) {
                    setTimeout(arguments.callee, 10);
                    return;
                }
            }
            options.onload();
        };

        function loadByDom(res, callback) {
            var node, loaded, onready;
            switch (res.type.toLowerCase()) {
                case 'css' :
                    node = document.createElement('link');
                    node.setAttribute('rel', 'stylesheet');
                    node.setAttribute('type', 'text/css');
                    break;
                case 'js' :
                    node = document.createElement('script');
                    node.setAttribute('type', 'text/javascript');
                    node.setAttribute('charset', res.charset || self.charset);
                    break;
                case 'html' :
                    node = document.createElement('iframe');
                    node.frameBorder = 'none';
                    break;
                default :
                    return;
            }

            // HTML,JS works on all browsers, CSS works only on IE.
            onready = function() {
                if (!loaded && (!this.readyState ||
                        this.readyState === 'loaded' ||
                        this.readyState === 'complete')) {
                    loaded = true;
                    // 防止内存泄露
                    $(node).unbind('load', onready);
                    $(node).unbind('readystatechange', onready);
                    //node.onload = node.onreadystatechange = null;
                    callback.call(window, node);
                }
            };
            $(node).bind('load', onready);
            $(node).bind('readystatechange', onready);
            //CSS has no onload event on firefox and webkit platform, so hack it.
            if (res.type == 'css') {
                (function() {
                    //避免重复加载
                    if (loaded) return;
                    try {
                        node.sheet.cssRule;
                    } catch (e) {
                        setTimeout(arguments.callee, 20);
                        return;
                    }
                    loaded = true;
                    callback.call(window, node);
                })();
            }

            node.href = node.src = res.url;
            document.getElementsByTagName('head')[0].appendChild(node);
        }

        //兼容第一个参数直接是资源地址.
        $.lang.isString(resources) && (resources = [{url: resources}]);
        //避免递归出错,添加容错.
        if (! (resources && resources.length)) return;

        function loadResources(res) {
            var url = res.url,
                shouldContinue = !!parallel,
                cacheData,
                callback = function(textOrNode) {
                    //ajax存入responseText,dom存入节点,用于保证onload的正确执行.
                    cache[res.url] = textOrNode;
                    delete loadingCache[res.url];

                    if ($.lang.isFunction(res.onload)) {
                        //若返回false, 则停止接下来的加载.
                        if (false === res.onload.call(window, textOrNode)) {
                            return;
                        }
                    }
                    //串行时递归执行
                    !parallel && self(resources.slice(1), options, true);
                    if ((! ignoreAllLoaded) && $.lang.isFunction(options.onload)) {
                        allLoadedChecker();
                    }
                };
            //默认用后缀名, 并防止后缀名大写
            res.type = res.type || url.replace(/^[^?#]+.(css|js|html)(?|#| |$)[^?#]*/i, '$1'); //[bugfix]修改xxx.js?v这种情况下取不到js的问题。 
            //默认html格式用ajax请求,其他都使用dom标签方式请求.
            res.requestType = res.requestType || (res.type == 'html' ? 'ajax' : 'dom');

            if (cacheData = cache[res.url]) {
                callback(cacheData);
                return shouldContinue;
            }
            if (!options.refresh && loadingCache[res.url]) {
                setTimeout(function() {loadResources(res);}, 10);
                return shouldContinue;
            }
            loadingCache[res.url] = true;
            if (res.requestType.toLowerCase() == 'dom') {
                loadByDom(res, callback);
            }else {//ajax
                $.getScript(res.url, function(responseText){
                    callback(responseText);
                });
            }
            //串行模式,通过callback方法执行后续
            return shouldContinue;
        };

        $.each(resources, function(k, item){
            loadResources(item);
        });
    };
    //默认编码设置为UTF8
    $.page.load.charset = 'UTF8';
})(jQuery);

;(function($){
    /**
     * 判断浏览器类型
     */
    $.browser = $.browser || {};

    $.browser.ie = /msie (d+.d+)/i.test(navigator.userAgent) ? (document.documentMode || + RegExp['x241']) : undefined;
    
    $.browser.firefox = /firefox/(d+.d+)/i.test(navigator.userAgent) ? + RegExp['x241'] : undefined;

    $.browser.chrome = /chrome/(d+.d+)/i.test(navigator.userAgent) ? + RegExp['x241'] : undefined;
    
    //判断是否为gecko内核
    $.browser.isGecko = /gecko/i.test(navigator.userAgent) && !/like gecko/i.test(navigator.userAgent);
    
    //判断是否为webkit内核
    $.browser.isWebkit = /webkit/i.test(navigator.userAgent);
    
    //判断是否严格标准的渲染模式
    $.browser.isStrict = document.compatMode == "CSS1Compat";

    $.browser.opera = /opera(/| )(d+(.d+)?)(.+?(version/(d+(.d+)?)))?/i.test(navigator.userAgent) ?  + ( RegExp["x246"] || RegExp["x242"] ) : undefined;

    (function(){
        var ua = navigator.userAgent;
        /**
         * 判断是否为safari浏览器, 支持ipad
         * @property safari safari版本号
         * @grammar $.browser.safari
         */
        $.browser.safari = /(d+.d)?(?:.d)?s+safari/?(d+.d+)?/i.test(ua) && !/chrome/i.test(ua) ? + (RegExp['x241'] || RegExp['x242']) : undefined;
    })();
})(jQuery);


;(function($){
    /**
     * 判断平台类型和特性的属性
     */
    $.platform = $.platform || {};

    /**
     * 判断是否为android平台
     */
    $.platform.isAndroid = /android/i.test(navigator.userAgent);


    /**
     * 判断是否为ipad平台
     */
    $.platform.isIpad = /ipad/i.test(navigator.userAgent);

    /**
     * 判断是否为iphone平台
     */
    $.platform.isIphone = /iphone/i.test(navigator.userAgent);


    /**
     * 判断是否为macintosh平台
     */
    $.platform.isMacintosh = /macintosh/i.test(navigator.userAgent);



    /**
     * 判断是否为windows平台
     */
    $.platform.isWindows = /windows/i.test(navigator.userAgent);



    /**
     * 判断是否为x11平台
     */
    $.platform.isX11 = /x11/i.test(navigator.userAgent);
})(jQuery);


;(function($){
    /**
     * String增强
     */
    $.string = $.string || {};

    /**
     * 对目标字符串进行html解码
     * @grammar $.string.decodeHTML(source)
     * @param {string} source 目标字符串
     *             
     * @returns {string} html解码后的字符串
     */
    $.string.decodeHTML = function (source) {
        var str = String(source)
                    .replace(/"/g,'"')
                    .replace(/</g,'<')
                    .replace(/>/g,'>')
                    .replace(/&/g, "&");
        //处理转义的中文和实体字符
        return str.replace(/&#([d]+);/g, function(_0, _1){
            return String.fromCharCode(parseInt(_1, 10));
        });
    };

    /**
     * 对目标字符串进行html编码
     * @grammar $.string.encodeHTML(source)
     * @param {string} source 目标字符串
     * 编码字符有5个：&<>"'
     *             
     * @returns {string} html编码后的字符串
     */
    $.string.encodeHTML = function (source) {
        return String(source)
                    .replace(/&/g,'&')
                    .replace(/</g,'<')
                    .replace(/>/g,'>')
                    .replace(/"/g, """)
                    .replace(/'/g, "'");
    };

    /**
     * 去掉字符串中的html标签
     * @function
     * @grammar $.string.stripTags(source)
     * @param {string} source 要处理的字符串.
     * @return {String}
     */
    $.string.stripTags = function(source) {
        return String(source || '').replace(/<[^>]+>/g, '');
    };

    /**
     * 将目标字符串中可能会影响正则表达式构造的字符串进行转义。
     * @grammar $.string.escapeReg(source)
     * @param {string} source 目标字符串
     * @remark
     * 给以下字符前加上“”进行转义：.*+?^=!:${}()|[]/
     *             
     * @returns {string} 转义后的字符串
     */
    $.string.escapeReg = function (source) {
        return String(source)
                .replace(new RegExp("([.*+?^=!:x24{}()|[\]/\\])", "g"), '\x241');
    };

    /**
     * 删除目标字符串两端的空白字符
     * @grammar $.string.trim(source)
     * @param {string} source 目标字符串
     * @remark
     * 不支持删除单侧空白字符
     *             
     * @returns {string} 删除两端空白字符后的字符串
     */

    (function () {
        var trimer = new RegExp("(^[\s\t\xa0\u3000]+)|([\u3000\xa0\s\t]+x24)", "g");
        
        $.string.trim = function (source) {
            return String(source)
                    .replace(trimer, "");
        };
    })();
})(jQuery);


;(function($){
    /**
     * GUID
     */
    $.lang = $.lang || {};
    /**
     * 返回一个当前页面的唯一标识字符串。
     * @grammar $.lang.guid()
     *             
     * @returns {String} 当前页面的唯一标识字符串
     */
    $.lang.guid = function() {
        return "TANGRAM$" + $.lang._counter ++;
    };

    //不直接使用window，可以提高3倍左右性能
    $.lang._counter = $.lang._counter || 1;
    $.guid = $.lang.guid;//设置$.page.guid别名$.guid


    /**
     * 判断目标参数是否为function或Function实例
     * @grammar $.lang.isFunction(source)
     * @param {Any} source 目标参数
     * @returns {boolean} 类型判断结果
     */
    $.lang.isFunction = function (source) {
        // chrome下,'function' == typeof /a/ 为true.
        return '[object Function]' == Object.prototype.toString.call(source);
    };

    /**
     * 判断目标参数是否为Element对象
     * @grammar $.lang.isElement(source)
     * @param {Any} source 目标参数
     * @returns {boolean} 类型判断结果
     */
    $.lang.isElement = function (source) {
        return !!(source && source.nodeName && source.nodeType == 1);
    };

    /**
     * 判断目标参数是否Array对象
     * @grammar $.lang.isArray(source)
     * @param {Any} source 目标参数   
     * @returns {boolean} 类型判断结果
     */
    $.lang.isArray = function (source) {
        return '[object Array]' == Object.prototype.toString.call(source);
    };
})(jQuery);

;(function($){
    /**
     * Array增强
     */
     $.array = $.array || {};

    /**
     * 查询数组中指定元素的索引位置
     * @grammar $.array.indexOf(source, match[, fromIndex])
     * @param {Array} source 需要查询的数组
     * @param {Any} match 查询项
     * @param {number} [fromIndex] 查询的起始位索引位置，如果为负数，则从source.length+fromIndex往后开始查找
     *             
     * @returns {number} 指定元素的索引位置，查询不到时返回-1
     */
    $.array.indexOf = function (source, match, fromIndex) {
        var len = source.length,
            iterator = match;
            
        fromIndex = fromIndex | 0;
        if(fromIndex < 0){//小于0
            fromIndex = Math.max(0, len + fromIndex)
        }
        for ( ; fromIndex < len; fromIndex++) {
            if(fromIndex in source && source[fromIndex] === match) {
                return fromIndex;
            }
        }
        
        return -1;
    };

    /**
     * 判断一个数组中是否包含给定元素
     * @grammar $.array.contains(source, obj)
     * @param {Array} source 需要判断的数组.
     * @param {Any} obj 要查找的元素.
     * @return {boolean} 判断结果.
     * @author berg
     */
    $.array.contains = function(source, obj) {
        return ($.array.indexOf(source, obj) >= 0);
    };

    /**
     * 清空一个数组
     * @grammar $.array.empty(source)
     * @param {Array} source 需要清空的数组.
     * @author berg
     */
    $.array.empty = function(source) {
        source.length = 0;
    };

    /**
     * 从后往前，查询数组中指定元素的索引位置
     * @grammar $.array.lastIndexOf(source, match)
     * @param {Array} source 需要查询的数组
     * @param {Any} match 查询项
     * @param {number} [fromIndex] 查询的起始位索引位置，如果为负数，则从source.length+fromIndex往前开始查找
     *             
     * @returns {number} 指定元素的索引位置，查询不到时返回-1
     */

    $.array.lastIndexOf = function (source, match, fromIndex) {
        var len = source.length;

        fromIndex = fromIndex | 0;

        if(!fromIndex || fromIndex >= len){
            fromIndex = len - 1;
        }
        if(fromIndex < 0){
            fromIndex += len;
        }
        for(; fromIndex >= 0; fromIndex --){
            if(fromIndex in source && source[fromIndex] === match){
                return fromIndex;
            }
        }
        
        return -1;
    };

    /**
     * 遍历数组中所有元素，将每一个元素应用方法进行转换，并返回转换后的新数组。
     * @grammar $.array.map(source, iterator[, thisObject])
     * @param {Array}    source   需要遍历的数组.
     * @param {Function} iterator 对每个数组元素进行处理的函数.
     * @param {Object} [thisObject] 函数调用时的this指针，如果没有此参数，默认是当前遍历的数组
     * @return {Array} map后的数组.
     */
    $.array.map = function(source, iterator, thisObject) {
        var results = [],
            i = 0,
            l = source.length;
        for (; i < l; i++) {
            results[i] = iterator.call(thisObject || source, source[i], i);
        }
        return results;
    };

    /**
     * 遍历数组中所有元素，将每一个元素应用方法进行合并，并返回合并后的结果。
     * @grammar $.array.reduce(source, iterator[, initializer])
     * @param {Array}    source 需要遍历的数组.
     * @param {Function} iterator 对每个数组元素进行处理的函数，函数接受四个参数：上一次reduce的结果（或初始值），当前元素值，索引值，整个数组.
     * @param {Object}   [initializer] 合并的初始项，如果没有此参数，默认用数组中的第一个值作为初始值.
     * @return {Array} reduce后的值.
     */
    $.array.reduce = function(source, iterator, initializer) {
        var i = 0,
            l = source.length,
            found = 0;

        if( arguments.length < 3){
            //没有initializer的情况，找到第一个可用的值
            for(; i < l; i++){
                initializer = source[i++];
                found = 1;
                break;
            }
            if(!found){
                return ;
            }
        }

        for (; i < l; i++) {
            if( i in source){
                initializer = iterator(initializer, source[i] , i , source);
            }
        }
        return initializer;
    };

    /**
     * 移除数组中的项
     * @grammar $.array.remove(source, match)
     * @param {Array} source 需要移除项的数组
     * @param {Any} match 要移除的项
     *             
     * @returns {Array} 移除后的数组
     */
    $.array.remove = function (source, match) {
        var len = source.length;
            
        while (len--) {
            if (len in source && source[len] === match) {
                source.splice(len, 1);
            }
        }
        return source;
    };

    /**
     * 移除数组中的项
     * @grammar $.array.removeAt(source, index)
     * @param {Array} source 需要移除项的数组
     * @param {number} index 要移除项的索引位置
     * @returns {Any} 被移除的数组项
     */
    $.array.removeAt = function (source, index) {
        return source.splice(index, 1)[0];
    };

    /**
     * 过滤数组中的相同项。如果两个元素相同，会删除后一个元素。
     * @grammar $.array.unique(source[, compareFn])
     * @param {Array} source 需要过滤相同项的数组
     * @param {Function} [compareFn] 比较两个数组项是否相同的函数,两个数组项作为函数的参数。
     *             
     * @returns {Array} 过滤后的新数组
     */
    $.array.unique = function (source, compareFn) {
        var len = source.length,
            result = source.slice(0),
            i, datum;
            
        if ('function' != typeof compareFn) {
            compareFn = function (item1, item2) {
                return item1 === item2;
            };
        }
        
        // 从后往前双重循环比较
        // 如果两个元素相同，删除后一个
        while (--len > 0) {
            datum = result[len];
            i = len;
            while (i--) {
                if (compareFn(datum, result[i])) {
                    result.splice(len, 1);
                    break;
                }
            }
        }

        return result;
    };
})(jQuery);

;(function(){
    /**
     * 操作cookie的方法
     * @namespace $.cookie
     */
    $.cookie = $.cookie || {};

    /**
     * 验证字符串是否合法的cookie键名
     * 
     * @param {string} source 需要遍历的数组
     * @meta standard
     * @return {boolean} 是否合法的cookie键名
     */
    $.cookie._isValidKey = function (key) {
        // http://www.w3.org/Protocols/rfc2109/rfc2109
        // Syntax:  General
        // The two state management headers, Set-Cookie and Cookie, have common
        // syntactic properties involving attribute-value pairs.  The following
        // grammar uses the notation, and tokens DIGIT (decimal digits) and
        // token (informally, a sequence of non-special, non-white space
        // characters) from the HTTP/1.1 specification [RFC 2068] to describe
        // their syntax.
        // av-pairs   = av-pair *(";" av-pair)
        // av-pair    = attr ["=" value] ; optional value
        // attr       = token
        // value      = word
        // word       = token | quoted-string
        
        // http://www.ietf.org/rfc/rfc2068.txt
        // token      = 1*<any CHAR except CTLs or tspecials>
        // CHAR       = <any US-ASCII character (octets 0 - 127)>
        // CTL        = <any US-ASCII control character
        //              (octets 0 - 31) and DEL (127)>
        // tspecials  = "(" | ")" | "<" | ">" | "@"
        //              | "," | ";" | ":" | "" | <">
        //              | "/" | "[" | "]" | "?" | "="
        //              | "{" | "}" | SP | HT
        // SP         = <US-ASCII SP, space (32)>
        // HT         = <US-ASCII HT, horizontal-tab (9)>
            
        return (new RegExp("^[^\x00-\x20\x7f\(\)<>@,;:\\\"\[\]\?=\{\}\/\u0080-\uffff]+x24")).test(key);
    };

    /**
     * 获取cookie的值，不对值进行解码
     * @grammar $.cookie.getRaw(key)
     * @param {string} key 需要获取Cookie的键名
     * @returns {string|null} 获取的Cookie值，获取不到时返回null
     */
    $.cookie.getRaw = function (key) {
        if ($.cookie._isValidKey(key)) {
            var reg = new RegExp("(^| )" + key + "=([^;]*)(;|x24)"),
                result = reg.exec(document.cookie);
                
            if (result) {
                return result[2] || null;
            }
        }

        return null;
    };

    /**
     * 设置cookie的值，不对值进行编码
     * @grammar $.cookie.setRaw(key, value[, options])
     * @param {string} key 需要设置Cookie的键名
     * @param {string} value 需要设置Cookie的值
     * @param {Object} [options] 设置Cookie的其他可选参数
     * @config {string} [path] cookie路径
     * @config {Date|number} [expires] cookie过期时间,如果类型是数字的话, 单位是毫秒
     * @config {string} [domain] cookie域名
     * @config {string} [secure] cookie是否安全传输
     * @remark
     * 
    <b>options参数包括：</b><br>
    path:cookie路径<br>
    expires:cookie过期时间，Number型，单位为毫秒。<br>
    domain:cookie域名<br>
    secure:cookie是否安全传输
     */
    $.cookie.setRaw = function (key, value, options) {
        if (!$.cookie._isValidKey(key)) {
            return;
        }
        
        options = options || {};
        //options.path = options.path || "/"; // meizz 20100402 设定一个初始值，方便后续的操作
        //berg 20100409 去掉，因为用户希望默认的path是当前路径，这样和浏览器对cookie的定义也是一致的
        
        // 计算cookie过期时间
        var expires = options.expires;
        if ('number' == typeof options.expires) {
            expires = new Date();
            expires.setTime(expires.getTime() + options.expires);
        }
        
        document.cookie =
            key + "=" + value
            + (options.path ? "; path=" + options.path : "")
            + (expires ? "; expires=" + expires.toGMTString() : "")
            + (options.domain ? "; domain=" + options.domain : "")
            + (options.secure ? "; secure" : ''); 
    };

    /**
     * 删除cookie的值
     * @grammar $.cookie.remove(key, options)
     * @param {string} key 需要删除Cookie的键名
     * @param {Object} options 需要删除的cookie对应的 path domain 等值
     */
    $.cookie.remove = function (key, options) {
        options = options || {};
        options.expires = new Date(0);
        $.cookie.setRaw(key, '', options);
    };

    /**
     * 获取cookie的值，用decodeURIComponent进行解码
     * @grammar $.cookie.get(key)
     * @param {string} key 需要获取Cookie的键名
     * @remark
     * <b>注意：</b>该方法会对cookie值进行decodeURIComponent解码。如果想获得cookie源字符串，请使用getRaw方法。
     *             
     * @returns {string|null} cookie的值，获取不到时返回null
     */
    $.cookie.get = function (key) {
        var value = $.cookie.getRaw(key);
        if ('string' == typeof value) {
            value = decodeURIComponent(value);
            return value;
        }
        return null;
    };

    /**
     * 设置cookie的值，用encodeURIComponent进行编码
     * @grammar $.cookie.set(key, value[, options])
     * @param {string} key 需要设置Cookie的键名
     * @param {string} value 需要设置Cookie的值
     * @param {Object} [options] 设置Cookie的其他可选参数
     * @config {string} [path] cookie路径
     * @config {Date|number} [expires] cookie过期时间,如果类型是数字的话, 单位是毫秒
     * @config {string} [domain] cookie域名
     * @config {string} [secure] cookie是否安全传输
     * @remark
     * 
    1. <b>注意：</b>该方法会对cookie值进行encodeURIComponent编码。如果想设置cookie源字符串，请使用setRaw方法。<br><br>
    2. <b>options参数包括：</b><br>
    path:cookie路径<br>
    expires:cookie过期时间，Number型，单位为毫秒。<br>
    domain:cookie域名<br>
    secure:cookie是否安全传输
     */
    $.cookie.set = function (key, value, options) {
        $.cookie.setRaw(key, encodeURIComponent(value), options);
    };
})(jQuery);

;(function($){
    $.number = $.number || {};

    /**
     * 为目标数字添加逗号分隔
     * @grammar $.number.comma(source[, length])
     * @param {number} source 需要处理的数字
     * @param {number} [length] 两次逗号之间的数字位数，默认为3位
     *             
     * @returns {string} 添加逗号分隔后的字符串
     */
    $.number.comma = function (source, length) {
        if (!length || length < 1) {
            length = 3;
        }

        source = String(source).split(".");
        source[0] = source[0].replace(new RegExp('(\d)(?=(\d{'+length+'})+$)','ig'),"$1,");
        return source.join(".");
    };

    /**
     * 生成随机整数，范围是[min, max]
     * @grammar $.number.randomInt(min, max) 
     * 
     * @param     {number} min     随机整数的最小值
     * @param     {number} max     随机整数的最大值
     * @return     {number}         生成的随机整数
     */
    $.number.randomInt = function(min, max){
        return Math.floor(Math.random() * (max - min + 1) + min);
    };

    /**
     * 对目标数字进行0补齐处理
     * @grammar $.number.pad(source, length)
     * @param {number} source 需要处理的数字
     * @param {number} length 需要输出的长度
     *             
     * @returns {string} 对目标数字进行0补齐处理后的结果
     */
    $.number.pad = function (source, length) {
        var pre = "",
            negative = (source < 0),
            string = String(Math.abs(source));

        if (string.length < length) {
            pre = (new Array(length - string.length + 1)).join('0');
        }

        return (negative ?  "-" : "") + pre + string;
    };
})(jQuery);

;(function($){
    $.sio = $.sio || {};
    /**
     * 通过请求一个图片的方式令服务器存储一条日志
     * @grammar $.sio.log(url)
     * @param {string} url 要发送的地址.
     */
    $.sio.log = function(url) {
      var img = new Image(),
          key = 'tangram_sio_log_' + Math.floor(Math.random() *
                2147483648).toString(36);

      // 这里一定要挂在window下
      // 在IE中，如果没挂在window下，这个img变量又正好被GC的话，img的请求会abort
      // 导致服务器收不到日志
      window[key] = img;

      img.onload = img.onerror = img.onabort = function() {
        // 下面这句非常重要
        // 如果这个img很不幸正好加载了一个存在的资源，又是个gif动画
        // 则在gif动画播放过程中，img会多次触发onload
        // 因此一定要清空
        img.onload = img.onerror = img.onabort = null;

        window[key] = null;

        // 下面这句非常重要
        // new Image创建的是DOM，DOM的事件中形成闭包环引用DOM是典型的内存泄露
        // 因此这里一定要置为null
        img = null;
      };

      // 一定要在注册了事件之后再设置src
      // 不然如果图片是读缓存的话，会错过事件处理
      // 最后，对于url最好是添加客户端时间来防止缓存
      // 同时服务器也配合一下传递Cache-Control: no-cache;
      img.src = url;
    };
})(jQuery);


;(function($){
    $.url = $.url || {};
    /**
     * 对字符串进行%#&+=以及和s匹配的所有字符进行url转义
     * @grammar $.url.escapeSymbol(source)
     * @param {string} source 需要转义的字符串.
     * @return {string} 转义之后的字符串.
     * @remark
     * 用于get请求转义。在服务器只接受gbk，并且页面是gbk编码时，可以经过本转义后直接发get请求。
     *
     * @return {string} 转义后的字符串
     */
    $.url.escapeSymbol = function(source) {
        
        //TODO: 之前使用s来匹配任意空白符
        //发现在ie下无法匹配中文全角空格和纵向指标符v，所以改s为f
	v以及中文全角空格和英文空格
        //但是由于ie本身不支持纵向指标符v,故去掉对其的匹配，保证各浏览器下效果一致
        return String(source).replace(/[#%&+=/\ 　f
	]/g, function(all) {
            return '%' + (0x100 + all.charCodeAt()).toString(16).substring(1).toUpperCase();
        });
    };

    /**
     * 根据参数名从目标URL中获取参数值
     * @grammar $.url.getQueryValue(url, key)
     * @param {string} url 目标URL
     * @param {string} key 要获取的参数名
     *             
     * @returns {string|null} - 获取的参数值，其中URI编码后的字符不会被解码，获取不到时返回null
     */
    $.url.getQueryValue = function (url, key) {
        var reg = new RegExp(
                            "(^|&|\?|#)" 
                            + $.string.escapeReg(key) 
                            + "=([^&#]*)(&|x24|#)", 
                        "");
        var match = url.match(reg);
        if (match) {
            return match[2];
        }
        
        return null;
    };

    /**
     * 将json对象解析成query字符串
     * @grammar $.url.jsonToQuery(json[, replacer])
     * @param {Object} json 需要解析的json对象
     * @param {Function=} replacer_opt 对值进行特殊处理的函数，function (value, key)
     *             
     * @return {string} - 解析结果字符串，其中值将被URI编码，{a:'&1 '} ==> "a=%261%20"。
     */
    $.url.jsonToQuery = function (json, replacer_opt) {
        var result = [], 
            itemLen,
            replacer = replacer_opt || function (value) {
              return $.url.escapeSymbol(value);
            };
            
        $.each(json, function(item, key){
            // 这里只考虑item为数组、字符串、数字类型，不考虑嵌套的object
            if ($.lang.isArray(item)) {
                itemLen = item.length;
                // value的值需要encodeURIComponent转义吗？
                // FIXED 优化了escapeSymbol函数
                while (itemLen--) {
                    result.push(key + '=' + replacer(item[itemLen], key));
                }
            } else {
                result.push(key + '=' + replacer(item, key));
            }
        });
        
        return result.join('&');
    };


    /**
     * 解析目标URL中的参数成json对象
     * @grammar $.url.queryToJson(url)
     * @param {string} url 目标URL
     *             
     * @returns {Object} - 解析为结果对象，其中URI编码后的字符不会被解码，'a=%20' ==> {a:'%20'}。
     */
    $.url.queryToJson = function (url) {
        var query   = url.substr(url.lastIndexOf('?') + 1),
            params  = query.split('&'),
            len     = params.length,
            result  = {},
            i       = 0,
            key, value, item, param;
        
        for (; i < len; i++) {
            if(!params[i]){
                continue;
            }
            param   = params[i].split('=');
            key     = param[0];
            value   = param[1];
            
            item = result[key];
            if ('undefined' == typeof item) {
                result[key] = value;
            } else if ($.lang.isArray(item)) {
                item.push(value);
            } else { // 这里只可能是string了
                result[key] = [item, value];
            }
        }
        
        return result;
    };
})(jQuery);