jsADS的库（待更新）

/**
 * project:javascript DOM Advanced
 */
(function () {
    'use strict';
    //ADS命名空间
    //判断ADS对象是否存在，否则创建
    if (!window.ADS) {
        window.ADS = {};
    }

    //确定当前浏览器是否与整个库兼容
    function isCompatible(other) {
        //使用能力检测来检查必要条件
        if (other === false || !Array.prototype.push || !Object.hasOwnProperty || !document.createElement || !document.getElementsByTagName) {
            return false;
        }
        return true;
    }

    window.ADS.isCompatible = isCompatible;

    function $() {
        var elements = [];
        //查找作为参数提供的所有元素
        for (var i = 0; i < arguments.length; i++) {
            var element = arguments[i];
            //如果这参数是一个字符串那假设它是一个id
            if (typeof element === "string") {
                element = document.getElementById(element);
            }
            //如果只提供一个参数
            //则立即返回这个元素
            if (arguments.length === 1) {
                return element;
            }
            //否则，将它添加到数组中
            elements.push(element);
        }
        //返回包含多个被请求元素的数组
        return elements;
    }

    window.ADS.$ = $;

    /**
     * addEvent(node, type, listener)   添加事件程序处理
     * @param node DOM节点元素
     * @param type 事件类型
     * @param listener 事件函数
     * @return {Boolean}
     */
    function addEvent(node, type, listener) {
        //使用方法检查兼容性以保证平稳退化
        if (!isCompatible()) {
            return false;
        }
        //检查是不是DOM对象的引用
        if (!(node = $(node))) {
            return false;
        }
        if (node.addEventListener) {
            //W3C的方法
            node.addEventListener(type, listener, false);       //第三个参数为true时则启用捕获阶段
            return true;
        } else {
            //MSIE的方法
            //修正ie事件中this指向window的问题
            //把执行函数赋给自定义对象属性
            node["e" + type + listener] = listener;
            //把事件函数赋给自定义对象属性
            node[type + listener] = function () {
                node["e" + type + listener](window.event);
            };
            node.attachEvent("on" + type, node[type + listener]);
            return true;
        }
        //若两种方法都不具备则返回false
        return false;
    }

    window.ADS.addEvent = addEvent;

    /**
     * load事件在嵌入图像载入完成之前运行
     * @param {Function} loadEvent
     * @param {Boolean} waitForImages 当为true时，调用原始的addEvent()方法，等待加载完毕后才执行
     * demo:
     *      ADS.addLoadEvent(function(w3cEvent){
     *          //...
     *      });
     */
    function addLoadEvent(loadEvent, waitForImages) {
        if (!isCompatible()) {
            return false;
        }

        //如果等待标记是true则使用常规的添加事件的方法
        if (waitForImages) {
            return addEvent(window, 'load', loadEvent);
        }

        //否则使用一些不同的方式包装loadEvent()方法
        //以便为this关键字制定正确的内容，同时确定
        //事件不会被执行两次
        var init = function () {
            //如果这个函数已经被调用过了则返回
            if (init.done) {
                return;
            }

            //标记这个函数以便检测它是否运行过
            init.done = true;

            //在document的环境中运行载入事件
            loadEvent.apply(document, arguments);
        };

        //为DOMContentLoaded事件注册事件侦听器
        if (document.addEventListener) {
            document.addEventListener('DOMContentLoaded', init, false);
        }

        //对于safari，使用setInterval()函数检测
        //document是否载入完成
        if (/WebKit/i.test(navigator.userAgent)) {
            var _timer = setInterval(function () {
                if (/loaded|complete/.test(document.readyState)) {
                    clearInterval(_timer);
                    init();
                }
            }, 10);
        }

        //对于IE（使用条件注释）
        //附加一个在载入过程最后执行的脚本
        //并检测该脚本是否载入完成
        /*@cc_on @*/
        /*@if (@_win32)
         document.write("<script id=_ie_onload defer src=javascript:void(0)><\/script>");
         var script = document.getElementById('_ie_onload');
         script.onreadystatechange = function(){
         if((this.readyState === 'complete') || this.readyState === 'loaded'){
         init();
         }
         };
         /*@end @*/
        return true;
    }

    window.ADS.addLoadEvent = addLoadEvent;

    function removeEvent(node, type, listener) {
        if (!(node = $(node))) {
            return false;
        }
        if (node.removeEventListener) {
            //W3C 方法
            node.removeEventListener(type, listener, false);
            return true;
        } else if (node.detachEvent) {
            //MSIE方法
            node.detachEvent("on" + type, node[type + listener]);
            node[type + listener] = null;
            return true;
        }
        //若两种方法都不具备则返回false
        return false;
    }

    window.ADS.removeEvent = removeEvent;

    /**
     * 获取event事件对象
     * @param w3cEvent
     * @return {*|Event}
     */
    function getEventObject(w3cEvent) {
        return w3cEvent || window.event;
    }

    window.ADS.getEventObject = getEventObject;

    function getTarget(event) {
        event = event || getEventObject(event);

        //如果是w3c或MSIE的模型
        var target = event.target || event.srcElement;

        //如果像Safari中一样是一个文本节点
        //重新将目标对象指定为父元素
        if (target.nodeType === 3) {
            target = target.parentNode;
        }

        return target;
    }

    window.ADS.getTarget = getTarget;

    function getMouseButton(event) {
        event = event || getEventObject(event);

        //使用适当的属性初始化一个对象变量
        var buttons = {
            left: false,
            middle: false,
            right: false
        };

        //检查event对象的toString()方法的值
        //w3c有toString方法并且此时该方法的
        // 返回应该是MouseEvent
        if (event.toString() && event.toString().indexOf('MouseEvent') !== -1) {
            //w3c
            switch (event.button) {
                case 0:
                    buttons.left = true;
                    break;
                case 1:
                    buttons.middle = true;
                    break;
                case 2:
                    buttons.right = true;
                    break;
                default:
                    break;
            }
        } else if (event.button) {
            //MSIE
            switch (event.button) {
                case 1:
                    buttons.left = true;
                    break;
                case 2:
                    buttons.right = true;
                    break;
                case 3:
                    buttons.left = true;
                    buttons.right = true;
                    break;
                case 4:
                    buttons.middle = true;
                    break;
                case 5:
                    buttons.left = true;
                    buttons.middle = true;
                    break;
                case 6:
                    buttons.middle = true;
                    buttons.right = true;
                    break;
                case 7:
                    buttons.left = true;
                    buttons.middle = true;
                    buttons.right = true;
                    break;
                default:
                    break;

            }
        } else {
            return false;
        }
        return buttons;
    }

    window.ADS.getMouseButton = getMouseButton;

    /**
     * 光标相对于文档原点的位置
     * @param {event} event
     * @return {Object}
     */
    function getPointerPositionInDocument(event) {
        event = event || getEventObject(event);
        var x = event.pageX || (event.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft));
        var y = event.pageY || (event.clientY + (document.documentElement.scrollTop || document.body.scrollTop));
        //现在x和y中包含着鼠标
        //相对于文档原点的坐标
        return {
            x: x,
            y: y
        };
    }

    window.ADS.getPointerPositionInDocument = getPointerPositionInDocument;

    /**
     * 获取键盘按键的Unicode值
     * @param event
     * @return {Object}
     */
    function getKeyPressed(event) {
        event = event || getEventObject(event);

        //charCode for FF
        var code = (typeof event.charCode === 'number') ? event.charCode : event.keyCode;
        var value = String.fromCharCode(code);
        return {
            code: code,
            value: value
        };
    }

    window.ADS.getKeyPressed = getKeyPressed;

    /**
     * getElementsByClassName(className, tag, parent)    获取class为className的DOM元素
     * @param searchClass 类名 （第二个函数可实现多类名查询）
     * @param node DOM元素
     * @param tag 标签名
     * @return {*}
     */
    /*原书
     function getElementsByClassName(className, tag, parent) {
     parent = parent || document;
     if (!(parent = $(parent))) {
     return false;
     }
     //查找所有匹配的标签
     //由于IE5不支持document.getElementsByTagName("*")，要使用分支document.all以防错误
     var allTags = (tag == "*" && parent.all) ? parent.all : parent.getElementsByTagName(tag);
     var matchingElements = [];
     //创建一个正则表达式，来判断className是否正确
     className = className.replace(/\-/g, "\\-");
     var regex = new RegExp("(^|\\s)" + className + "(\\s|$)");
     var element;
     if (document.getElementsByClassName) {
     return document.getElementsByClassName(className);
     } else {
     //检查每个元素
     for (var i = 0; i < allTags.length; i++) {
     element = allTags[i];
     if (regex.test(element.className)) {
     matchingElements.push(element);
     }
     }
     //返回任何匹配的元素
     return matchingElements;
     }
     }*/
    function getElementsByClassName(searchClass, tag, node) {
        node = node || document;
        tag = tag || "*";
        if (!(node = $(node))) {
            return false;
        }
        //如果支持原生getElementsByClassName
        if (document.getElementsByClassName) {
            //获取所有匹配的className的DOM元素
            var nodes = node.getElementsByClassName(searchClass),
                result = nodes;
            //如果tag被定义了
            if (tag !== '*') {
                result = [];
                for (var i = 0; node = nodes[i]; i++) {
                    //匹配标签名为非“*”的标签
                    if (node.tagName.toLowerCase() === tag.toLowerCase()) {
                        result.push(node);
                    }
                }
            }
            return result;
        } else {
            //不支持原生getElementsByClassName的
            var classes = searchClass.split(" "), //要查询的所有className
                elements = (tag === "*" && node.all) ? node.all : node.getElementsByTagName(tag), //获取所有匹配的标签DOM元素
                patterns = [],
                returnElements = [],
                current,
                match;
            var i = classes.length;
            while (--i >= 0) {
                patterns.push(new RegExp("(^|\\s)" + classes[i] + "(\\s|$)"));
            }
            var j = elements.length;
            while (--j >= 0) {
                current = elements[j];
                match = false;
                //每个元素的className分别和要查询的className对比
                for (var k = 0, kl = patterns.length; k < kl; k++) {
                    match = patterns[k].test(current.className);
                    if (!match) {
                        break;
                    }
                }
                if (match) {
                    returnElements.push(current);
                }
            }
            return returnElements;
        }
    }

    window.ADS.getElementsByClassName = getElementsByClassName;
    //运用：var a = ADS.getElementsByClassName("li", "li", document);

    function toggleDisplay(node, value) {
        if (!(node = $(node))) {
            return false;
        }
        if (node.style.display !== "none") {
            node.style.display = "none";
        } else {
            node.style.display = value || "";
        }
        return true;
    }

    window.ADS.toggleDisplay = toggleDisplay;

    /**
     * DOM操作：将节点插入到目标节点之后
     * @param node 新节点
     * @param referenceNode 目标节点
     * @return {*}
     * etc: ADS.insertAfter("l1","l2");
     */
    function insertAfter(node, referenceNode) {
        if (!(node = $(node))) {
            return false;
        }
        if (!(referenceNode = $(referenceNode))) {
            return false;
        }
        return referenceNode.parentNode.insertBefore(node, referenceNode.nextSibling);
    }

    window.ADS.insertAfter = insertAfter;

    /**
     * 删除所有子节点
     * @param parent 父节点
     * @return {*}
     */
    function removeChildren(parent) {
        if (!(parent = $(parent))) {
            return false;
        }
        //当存在子节点时删除该子节点
        while (parent.firstChild) {
            parent.firstChild.parentNode.removeChild(parent.firstChild);
        }
        //再返回父元素，以便实现方法连缀
        return parent;
    }

    window.ADS.removeChildren = removeChildren;

    /**
     * 添加为节点第一个子节点
     * @param parent 父节点
     * @param newChild 新节点
     * @return {*}
     */
    function prependChild(parent, newChild) {
        if (!(parent = $(parent))) {
            return false;
        }
        if (!(newChild = $(newChild))) {
            return false;
        }
        if (parent.firstChild) {
            //如果存在一个子节点，则在这个字节点之前插入
            parent.insertBefore(newChild, parent.firstChild);
        } else {
            //如果没有子节点则直接添加
            parent.appendChild(newChild);
        }
        //再返回父元素，以便实现方法连缀
        return parent;
    }

    window.ADS.prependChild = prependChild;

    /**
     * 绑定函数到指定作用域
     * @param obj 对象
     * @param func 函数
     * @return {Function}
     */
    function bindFunction(obj, func) {
        return function () {
            //调用func函数，指定环境为obj，添加arguments参数
            func.apply(obj, arguments);
        };
    }

    window.ADS.bindFunction = bindFunction;

    /**
     * 获取浏览器窗口大小
     * @return {Object}
     */
    function getWinSize() {
        var de = document.documentElement;
        return {
            'width': (window.innerWidth || (de && de.clientWidth) || document.body.clientWidth),
            'height': (window.innerHeight || (de && de.clientHeight) || document.body.clientHeight)

        };
    }

    window.ADS.getWinSize = getWinSize;

    /**
     * 定义DOM常量
     * @type {Object}
     */
    window.ADS.node = {
        ELEMENT_NODE: 1,
        ATTRIBUTE_NODE: 2,
        TEXT_NODE: 3,
        CDATA_SECTION_NODE: 4,
        ENTITY_REFERENCE_NODE: 5,
        ENTITY_NODE: 6,
        PROCESSING_INSTRUCTION_NODE: 7,
        COMMENT_NODE: 8,
        DOCUMENT_NODE: 9,
        DOCUMENT_TYPE_NODE: 10,
        DOCUMENT_FRAGMENT_NODE: 11,
        NOTATION_NODE: 12
    };

    /**
     * 遍历DOM，并调用函数(效率最慢)
     * @param {Function} func
     * @param {Node} node
     */
    function walkElementsLinear(func, node) {
        var root = node || window.document;
        var nodes = root.getElementsByTagName('*');
        for (var i = 0, len = nodes.length; i < len; i++) {
            func.call(nodes[i]);
        }
    }

    window.ADS.walkElementsLinear = walkElementsLinear;

    /**
     * 迭代DOM
     * @param {Function} func
     * @param {Node} node
     * @param {Number} depth
     * @param returnedFromParent
     */
    function walkTheDOMRecursive(func, node, depth, returnedFromParent) {
        var root = node || window.document;
        //父节点调用函数的返回值，作为子节点调用函数时候的参数
        returnedFromParent = func.call(root, depth++, returnedFromParent);
        node = root.firstChild;
        while (node) {
            //迭代该节点后代元素
            walkTheDOMRecursive(func, node, depth, returnedFromParent);
            //移向下一个子节点
            node = node.nextSibling;
        }
    }

    window.ADS.walkTheDOMRecursive = walkTheDOMRecursive;

    /**
     * 迭代DOM节点的属性
     * @param {Node} node
     * @param {Function} func
     * @param {Number} depth
     * @param returnedFromParent
     */
    function walkTheDOMWithAttributes(node, func, depth, returnedFromParent) {
        var root = node || window.document;
        returnedFromParent = func(root, depth++, returnedFromParent);
        if (root.attributes) {
            for (var i = 0; i < root.attributes.length; i++) {
                walkTheDOMWithAttributes(root.attributes[i], func, depth - 1, returnedFromParent);
            }
        }
        if (root.nodeType !== window.ADS.node.ATTRIBUTE_NODE) {
            node = root.firstChild;
            while (node) {
                walkTheDOMWithAttributes(node, func, depth, returnedFromParent);
                node = node.nextSibling;
            }
        }
    }

    window.ADS.walkTheDOMWithAttributes = walkTheDOMWithAttributes;

    function walkTheDOM(node, func) {
        func(node);
        node = node.firstChild;
        while (node) {
            walkTheDOM(node, func);
            node = node.nextSibling;
        }
    }

    window.ADS.walkTheDOM = walkTheDOM;

    /**
     * 把word-word转换为wordWord
     * @param {String} s
     * @return {String|XML|void}
     */
    function camelize(s) {
        return s.replace(/-(\w)/g, function (strMatch, p1) {    //strMatch为正则匹配的字符
            //p1为\w匹配的一个字符
            return p1.toUpperCase();
        });
    }

    window.ADS.camelize = camelize;

    /**
     * 阻止事件冒泡
     * @param {event} eventObject
     */
    function stopPropagation(eventObject) {
        eventObject = eventObject || getEventObject(eventObject);
        if (eventObject.stopPropagation) {
            eventObject.stopPropagation();
        } else {
            eventObject.cancelBubble = true;
        }
    }

    window.ADS.stopPropagation = stopPropagation;

    /**
     * 取消默认事件
     * @param {event} eventObject
     * 可被取消的DOM事件:
     * click, mousedown, mouseup, mouseover, mouseout, submit, DOMActive及键盘事件
     */
    function preventDefault(eventObject) {
        eventObject = eventObject || getEventObject(eventObject);
        if (eventObject.preventDefault) {
            eventObject.preventDefault();
        } else {
            eventObject.returnValue = false;
        }
    }

    window.ADS.preventDefault = preventDefault;

    function uncamelize(property, splitChar) {
        return property.replace(/([a-z])([A-Z])/, '$1' + splitChar + '$2').toLowerCase();
    }

    window.ADS.uncamelize = uncamelize;

    /**
     * 用过ID修改单个元素的样式
     * @param {Node} element 元素节点
     * @param {Object} styles 样式对象
     */
    function setStyleById(element, styles) {
        //取得对象的引用
        if (!(element = $(element))) {
            return false;
        }
        //循环遍历styles对象并应用每个属性
        for (var property in styles) {
            //检测是否是样式属性
            if (!styles.hasOwnProperty(property)) {
                continue;
            }

            try {
                //DOM2样式规范方法
                element.style.setProperty(uncamelize(property, '-'), styles[property], null);
            } catch (ex) {
                //备用方法
                element.style[camelize(property)] = styles[property];
            }
        }
        return true;
    }

    window.ADS.setStyle = setStyleById;
    window.ADS.setStyleById = setStyleById;


    /**
     * 通过类名修改多个元素的样式
     * @param {Node} parent
     * @param {String} tag
     * @param {String} className
     * @param {Object} styles
     */
    function setStylesByClassName(parent, tag, className, styles) {
        if (!(parent = $(parent))) {
            return false;
        }
        var elements = getElementsByClassName(className, parent, tag);
        for (var i = 0; i < elements.length; i++) {
            setStyleById(elements[i], styles);
        }
        return true;
    }

    window.ADS.setStylesByClassName = setStylesByClassName;

    /**
     * 涌过标签名修改多个元素的样式
     * @param {String} tagname
     * @param {Object} styles
     * @param {Node} parent
     */
    function setStylesByTagName(tagname, styles, parent) {
        parent = $(parent) || document;
        var elements = parent.getElementsByTagName(tagname);
        for (var i = 0, len = elements.length; i < len; i++) {
            setStyleById(elements[i], styles);
        }
    }

    window.ADS.setStylesByTagName = setStylesByTagName;

    /**
     * 取得包含元素className的数组
     * @param {Node} element
     */
    function getClassName(element) {
        if (!(element = $(element))) {
            return false;
        }
        return element.className.replace(/\s+/g, ' ').split(' ');
    }

    window.ADS.getClassName = getClassName;

    /**
     * 检察院苏中是否存在某个className
     * @param {Node} element
     * @param {String} className
     * @return {Boolean}
     */
    function hasClassName(element, className) {
        if (!(element = $(element))) {
            return false;
        }
        var classes = getClassName(element);
        for (var i = 0; i < classes.length; i++) {
            //检测className是否匹配，如果是则返回true
            if (classes[i] === className) {
                return true;
            }
        }
        return false;
    }

    window.ADS.hasClassName = hasClassName;

    /**
     * 为元素添加className
     * @param element
     * @param className
     * @return {Boolean}
     */
    function addClassName(element, className) {
        if (!(element = $(element))) {
            return false;
        }
        //将className添加到当前className的末尾
        //如果没有className，则不包含空格
        element.className += (element.className ? ' ' : '') + className;
        return true;
    }

    window.ADS.addClassName = addClassName;

    /**
     * 删除一个或多个类名
     * @param element
     * @param className
     * @return {Boolean}
     */
    function removeClassName(element, className) {
        if (!(element = $(element))) {
            return false;
        }
        className = (className || '').trim().replace(/\s+/g, ' ');
        if (className === '') {
            //未定义或者空的情况为删除所有类名
            element.className = '';
        } else if (className.indexOf(' ') !== -1) {
            //对多个以空格为分隔的类名进行处理，然后迭代
            var classarr = className.split(' ');
            for (var i = 0; i < classarr.length; i++) {
                removeClassName(element, classarr[i]);
            }
        } else {
            //对单个类名的处理
            className = (' ' + className + ' ');
            var elemClass = ' ' + element.className + ' ';
            if (elemClass.indexOf(className) !== -1) {
                element.className = elemClass.replace(className, ' ').replace(/\s+/g, ' ').trim();
            } else {
                return false;
            }
        }
        return true;
    }

    window.ADS.removeClassName = removeClassName;

    /**
     * 切换类名
     * @param element
     * @param className
     */
    function toggleClassName(element, className) {
        if (!hasClassName(element, className)) {
            addClassName(element, className);
        } else {
            removeClassName(element, className);
        }
    }

    window.ADS.toggleClassName = toggleClassName;

    /**
     * 添加样式表
     * @param {String} url url地址
     * @param {String} media 媒介类型
     */
    function addStyleSheet(url, media) {
        media = media || 'screen';
        var link = document.createElement('link');
        link.setAttribute('rel', 'stylesheet');
        link.setAttribute('type', 'stylesheet');
        link.setAttribute('href', url);
        link.setAttribute('media', media);
        link.disabled = false;
        document.getElementsByTagName('head')[0].appendChild(link);
    }

    window.ADS.addStyleSheet = addStyleSheet;

    /**
     * 禁用样式表
     * @param url
     * @param media
     */
    function removeStyleSheet(url, media) {
        var styles = getStyleSheets(url, media);
        for (var i = 0; i < styles.length; i++) {
            // for standard and IE
            var node = styles[i].ownerNode || styles[i].owningElement;
            //禁用样式表
            styles[i].disabled = true;
            //移除节点
            node.parentNode.removeChild(node);
        }
    }

    window.ADS.removeStyleSheet = removeStyleSheet;

    /**
     * 通过URL取得包含所有样式表的数组
     * @param url
     * @param media
     * @return {Array}
     */
    function getStyleSheets(url, media) {
        var sheets = [];
        for (var i = 0; i < document.styleSheets.length; i++) {
            if (url && document.styleSheets[i].href.indexOf(url) === -1) {
                continue;
            }
            if (media) {
                //规范化media字符串
                media = media.replace(/,\s*/, ',');
                var sheetMedia;

                if (document.styleSheets[i].media.mediaText) {
                    //DOM方法
                    sheetMedia = document.styleSheets[i].media.mediaText.replace(/,\s*/, ',');
                    //Safari会添加额外的都好和空格
                    sheetMedia = sheetMedia.replace(/,\s*$/, '');
                } else {
                    // MSIE
                    sheetMedia = document.styleSheets[i].media.replace(/,\s*/, ',');
                }

                //如果media不匹配则跳过
                if (media !== sheetMedia) {
                    continue;
                }
            }
            sheets.push(document.styleSheets[i]);
        }
        return sheets;
    }

    window.ADS.getStyleSheets = getStyleSheets;

    /**
     * 编辑一条样式规则
     * @param {String} selector 选择器
     * @param {Object} styles 样式对象
     * @param {String || Array} url url地址或者styleSheets数组
     * @param {String} media 媒介查询
     */
    function editCSSRule(selector, styles, url, media) {

        var styleSheets = (typeof url === 'array') ? url : getStyleSheets(url, media);

        for (var i = 0; i < styleSheets.length; i++) {
            // 取得规则列表
            // DOM2样式规范方法是styleSheets[i].cssRules
            // MSIE方法是styleSheets[i].rules
            var rules = styleSheets[i].cssRules || styleSheets[i].rules;
            if (!rules) {
                continue;
            }

            // 由于MSIE默认使用大写故转换为大写形式
            // 如果拟使用的是区分大小写的id，则可能会
            // 导致冲突
            selector = selector.toUpperCase();

            for (var j = 0; j < rules.length; j++) {
                // 检查是否匹配
                if (rules[i].selectorText.toUpperCase() === selector) {
                    for (var property in styles) {
                        if (!styles.hasOwnProperty(property)) {
                            continue;
                        }
                        // 设置新的样式属性
                        rules[i].style[camelize(property)] = styles[property];
                    }
                }
            }
        }
    }

    window.ADS.editCSSRule = editCSSRule;

    /**
     * 添加一条css规则
     * @param selector
     * @param styles
     * @param {Number} index 列表规则的序号
     * @param url
     * @param media
     */
    function addCSSRule(selector, styles, index, url, media) {
        var declaration = '';

        // 根据styles参数（样式对象）构建声明字符串
        for (var property in styles) {
            if (!styles.hasOwnProperty(property)) {
                continue;
            }
            declaration += property + ':' + styles[property] + ';';
        }

        var styleSheets = (typeof url === 'array') ? url : getStyleSheets(url, media);
        var newIndex;
        for (var i = 0; i < styleSheets.length; i++) {
            // 添加规则
            if (styleSheets[i].insertRule) {
                // DOM2样式规范方法
                // index = length 是列表末尾
                newIndex = (index >= 0 ? index : styleSheets[i].cssRules.length);
                styleSheets[i].insertRule(
                    selector + ' { ' + declaration + ' } ',
                    newIndex
                );
            } else if (styleSheets[i].addRule) {
                // MSIE的方法
                // index = -1 是列表末尾
                newIndex = (index >= 0 ? index : -1);
                styleSheets[i].addRule(selector, declaration, newIndex);
            }
        }
    }

    window.ADS.addCSSRule = addCSSRule;

    /**
     * 取得一个元素的计算样式
     * @param {Node} element 元素节点
     * @param {String} property css属性
     *      格式：font-size
     * @return {*}
     */
    function getStyle(element, property) {
        if (!(element = $(element)) || !property) {
            return false;
        }
        // 检测元素style属性中的值
        // 只能获取嵌入方式定义的样式
        var value = element.style[camelize(property)];
        if (!value) {
            // 取得计算的样式值
            if (document.defaultView && document.defaultView.getComputedStyle) {
                // DOM方法
                var css = document.defaultView.getComputedStyle(element, null);
                // 也可以使用css[camelize(property)]
                value = css ? css.getPropertyValue(property) : null;
            } else if (element.currentStyle) {
                // MSIE方法
                value = element.currentStyle[camelize(property)];
            }
        }
        // 返回字符串不包括auto的值
        return value === 'auto' ? '' : value;
    }

    window.ADS.getStyle = getStyle;
    window.ADS.getStyleById = getStyle;

    /**
     * 检查JSON文本，确保安全
     * @param {String} s JSON字符串
     * @param {Function} filter 过滤方法
     * @return {*}
     */
    function parseJSON(s, filter) {
        var j;

        /**
         * 递归地遍历了新生成的结构
         而且将每个名/值对传递给一个过滤函数，以便进行
         可能的转换
         * @param k
         * @param v
         * @return {*}
         */
        function walk(k, v) {
            if (v && typeof v === 'object') {
                for (var i in v) {
                    if (v.hasOwnProperty(i)) {
                        v[i] = walk(i, v[i]);
                    }
                }
            }
            return filter(k, v);
        }

        /*
         解析通过3个阶段进行。第一阶段，通过正则表达式
         检测JSON文本，查找非JSON字符串。其中，特别关注
         “()”和"new"，因为它们会引起语句的调用，还有“=”，
         因为它会导致变量的值发生改变。不过，为安全起见
         这里会拒绝所有不希望出现的字符串
         */
        /*
         首先这个串分成两部分，看中间的或符号（｜）
         "(\\.|[^\\\n\r])*?"和[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]
         先分解"(\\.|[^\\\n\r])*?"
         它匹配一个双引号的字符串,两边引号不说了括号内一个“|”又分成两段 “\\.“匹配一个转义字符
         比如js字符串里的\n，\r，\'，\"等。[^\\\n\r]匹配一个非\,回车换行的字符 其实它就是js里字符串的规则－－－不包含回车换行，回车换行用 \n\r表示,\后面跟一个字符表示转义
         其次看[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]
         它匹配一个单个字符，这个字符可以是 ,，:，{，}，[，]，数字，除 "\n" 之外的任何单个字符，－，+，E，a，e，f，l，n，r-u之间的字符，回车，换行，制表符，
         */
        if (/^("(\\.|[^"\\\n\r])*?"|[,:\{\}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.test(s)) {
            /*
             第二阶段，使用eval()函数将JSON文本编译为js
             结构。其中的“{”操作符具有语法上的二义性，即它可
             以定义一个语句块，也可以表示对象字面量。这里将
             JSON文本用括号括起来是为了消除这种二义性
             */
            try {
                j = eval('(' + s + ')');
            } catch (e) {
                throw new SyntaxError('parseJSON');
            }
        } else {
            throw new SyntaxError('parseJSON');
        }

        /*
         在可选的第三阶段，代码递归地遍历了新生成的结构
         而且将每个名/值对传递给一个过滤函数，以便进行
         可能的转换
         */
        if (typeof filter === 'function') {
            j = walk('', j);
        }
        return j;
    }

    /**
     * 设置XMLHttpRequest对象的各个不同的部分
     * @param url
     * @param options
     *      参数options的成员属性
     *      method, 适用于请求的方法，默认为GET。
     *      send, 是一个包含在XMLHttpRequest.send()中的可选字符串，默认为null。
     *      loadListener， 是当readyState为1时调用的onreadystatechange侦听器
     *      loadedListener, 是当readyState为2时调用的onreadystatechange侦听器。
     *      interactiveListener, 是当readyState为3时调用的onreadystatechange侦听器。
     *      jsResponseListener, 是当请求成功并且响应的Content-Type为application/javascript或text/javascript时调用的侦听器，这个侦听器将从响应中取得js字符串作为其第一个参数。如果要执行该js字符串，必须使用eval()方法。
     *      jsonResponseListener, 是当请求成功并且响应的Content-Type为application/json时调用的侦听器。这个侦听器将从响应中取得JSON对象作为其第一个参数。
     *      xmlResponseListener, 是当请求成功并且响应的Content-Type为application/xml或application/xhtml+xml时调用的侦听器。这个侦听器将从响应中取得的XML DOM文档作为其第一个参数。
     *      htmlResponseListener， 是当请求成功并且响应的content-Type为text/html时调用的侦听器。这个侦听器将从响应中取得的HTML字符串作为其第一个参数。
     *      completeListener, 是当上面所列的针对Content-Type的响应侦听器调用之后被调用的侦听器。这个方法总是在成功的响应最后被调用，也就是说如果相应中没有适当的Content-Type头部信息，那么你可以制定这个方法作为兜底儿的侦听器。
     *      errorListener, 是当响应状态值不是200也不是0时被调用的侦听器。如果是在不会提供适当响应代码的系统上运行（如硬盘驱动器中的本地文件系统）XMLHttpRequest，那么状态值将始终为0.在这种情况下，只有completeListener会被调用。
     */
    /*
     demo：
     ADS.ajaxRequest('/path/to/script/',{
     method:'GET',
     completeListener:function(){
     alert(this.responseText);
     }
     });
     */
    // 因为使用了call和apply方法，此时的this引用的是
    // 请求对象而不是onreadystatechange方法。
    function getRequestObject(url, options) {
        // 初始化请求对象
        var req = false;
        if (window.XMLHttpRequest) {
            req = getRequestObject.req = new window.XMLHttpRequest();
        } else if (window.ActiveXObject) {
            req = getRequestObject.req = new ActiveXObject('Microsoft.XMLHTTP');
        }

        if (!req) {
            return false;
        }

        // 定义默认的选项
        options = options || {};
        options.method = options.method || 'GET';
        options.send = options.send || null;

        // 为请求的每个阶段定义不同的侦听器
        req.onreadystatechange = function () {
            switch (req.readyState) {
                case 1:
                    // 载入中
                    if (options.loadListener) {
                        options.loadListener.apply(req, arguments);
                    }
                    break;
                case 2:
                    // 载入完成
                    if (options.loadedListener) {
                        options.loadedListener.apply(req, arguments);
                    }
                    break;
                case 3:
                    // 交互
                    if (options.interactiveListener) {
                        options.interactiveListener.apply(req, arguments);
                    }
                    break;
                case 4:
                    // 完成
                    // 如果失败则抛出错误
                    try {
                        if (req.status && (req.status >= 200 && req.status < 300) || req.status === 304) {
                            // 针对Content-type的特殊侦听器
                            // 由于Content-Type头部中可能包含字符集，如：
                            // Content-Type: text/html; charset=ISO-8859-4
                            // 因此通过正则表达式提取出所需的部分
                            var contentType = req.getResponseHeader('Content-Type');
                            var mimeType = contentType.match(/\s*([^;]+)\s*(;|$)/i)[1];
                            switch (mimeType) {
                                case 'text/javascript':
                                case 'application/javascript':
                                    // 响应时javascript，因此以
                                    // req.responseText作为回调函数
                                    if (options.jsResponseListener) {
                                        options.jsResponseListener.call(req, req.responseText);
                                    }
                                    break;
                                case 'application/json':
                                    // 响应是JSON，因此需要用匿名函数对
                                    // req.responseText进行解析
                                    // 已返回作为回调参数的JSON对象
                                    if (options.jsonResponseListener) {
                                        var json;
                                        try {
                                            json = parseJSON(req.responseText);
                                        } catch (e) {
                                            json = false;
                                        }
                                        options.jsonResponseListener.call(req, json);
                                    }
                                    break;
                                case 'text/xml':
                                case 'application/xml':
                                case 'application/xhtml+xml':
                                    // 响应是XML，因此以
                                    // req.responseXML作为
                                    // 回调的参数
                                    // 此时是Document对象
                                    if (options.xmlResponseListener) {
                                        options.xmlResponseListener.call(req, req.responseText);
                                    }
                                    break;
                                case 'text/html':
                                    // 响应是HTML，因此以
                                    // req.responseText作为
                                    // 回调的参数
                                    if (options.htmlResponseListener) {
                                        options.htmlResponseListener.call(req, req.responseText);
                                    }
                                    break;
                                default:
                                    break;
                            }

                            // 针对响应成功完成的侦听器
                            if (options.completeListener) {
                                options.completeListener.apply(req, arguments);
                            }
                        } else {
                            // 相应完成但却存在错误
                            if (options.errorListener) {
                                options.errorListener.apply(req, arguments);
                            }
                        }
                    } catch (e) {
                        // 忽略错误
                    }
                    break;
            }
        };

        // 开启请求
        req.open(options.method, url, true);
        // 添加特殊的头部信息以标识请求
        req.setRequestHeader('X-ADS-Ajax-Request', 'AjaxRequest');
        return req;
    }

    window.ADS.getRequestObject = getRequestObject;

    // 通过简单的包装getRequestObject()和send()
    // 方法发送XMLHttpRequest对象的请求
    function ajaxRequest(url, options) {
        var req = getRequestObject(url, options);
        req.send(options.send);
        return req;
    }

    window.ADS.ajaxRequest = ajaxRequest;


    /**
     * 此处的XssHttpRequest对象在模拟了某些XMLHttpRequest对象属性的基础上，还添加了以下一些属性
     * responseJSON。 包含相应的结果，这个属性已经是一个js对象了，因此不需要再使用eval();
     * status. 在这里可能的值有如下两个
     *      1： 表示成功
     *      2： 表示存在错误
     * statusText。 包含错误的原因。
     * 可以通过在下列侦听器内使用this关键字来访问以上属性
     * loadedListener。 当对象处于载入完成状态时调用。
     * waitListener。 当对象等待响应时调用。
     * completeListener。 当对象取得成功的响应后调用。
     * errorListener。 当脚本载入外部脚本失败或载入的脚本格式不正确时调用。
     *
     * 为了保证对象正确运行，相应必须要调用GET变量中所引用的js函数，一般而言，最好的方式就是想这个函数中传递一个JSON对象，但如果你想传递XML文件或其他信息，也可以简单的将这些信息包含在JSON对象中，然后用过响应侦听器来按照需要解析这些信息。
     */
    // XssHttpRequest对象的计数器
    var XssHttpRequestCount = 0;
    // XssHttpRequest对象的一个
    // 跨站点<script>标签的实现
    var XssHttpRequest = function () {
        this.requestID = 'XSS_HTTP_REQUEST_' + (++XssHttpRequestCount);
    };
    XssHttpRequest.prototype = {
        url: null,
        scriptObject: null,
        responseJSON: null,
        status: 0,
        readyState: 0,
        timeout: 30000,
        onreadystatechange: function () {
        },
        setReadyState: function (newReadyState) {
            // 如果比当前状态更新
            // 则只更新就绪状态
            if (this.readyState < newReadyState || newReadyState === 0) {
                this.readyState = newReadyState;
                this.onreadystatechange();
            }
        },
        open: function (url, timeout) {
            this.timeout = timeout || this.timeout;
            // 将以革名为XSS_HTTP_REQUEST_CALLBACK
            // 的特殊变量附加给URL，其中包含本次请求的
            // 回调函数的名称
            this.url = url +
                ((url.indexOf('?') !== -1) ? '&' : '?') +
                'XSS_HTTP_REQUEST_CALLBACK=' +
                this.requestID +
                '_CALLBACK';
            this.setReadyState(0);
        },
        send: function () {
            var requestObject = this;
            // 创建一个载入外部数据的新script对象
            this.scriptObject = document.createElement('script');
            this.scriptObject.setAttribute('id', this.requestID);
            this.scriptObject.setAttribute('type', 'text/javascript');
            // 汕尾设置src属性，也先不降其添加到文档

            // 创建一个在给定的毫秒数之后触发的
            // setTimeout()方法。如果在给定的时间
            // 内脚本没有载入完成，则取消载入
            var timeoutWatcher = setTimeout(function () {
                // 在脚本晚于我们假定的停止时间之后载入的情况下
                // 通过一个空方法来重新为window方法赋值
                window[requestObject.requestID + '_CALLBACK'] = function () {
                };

                // 移除脚本以防止进一步载入
                requestObject.scriptObject.parentNode.removeChild(requestObject.scriptObject);

                // 将状态设置为错误
                requestObject.status = 2;
                requestObject.statusText = 'Timeout after: ' +
                    requestObject.timeout +
                    ' milliseconds.';

                // 更新就绪状态
                requestObject.setReadyState(2);
                requestObject.setReadyState(3);
                requestObject.setReadyState(4);
            }, this.timeout);

            // 在window对象中创建一个与
            // 请求中的回调方法匹配的方法
            // 在调用时负责处理请求的其他部分
            window[this.requestID + '_CALLBACK'] = function (JSON) {
                // 当脚本载入时将执行这个方法
                // 同时传入预期的JSON对象

                // 在请求载入成功时
                // 清除timeoutWatcher方法
                clearTimeout(timeoutWatcher);

                // 更新就绪状态
                requestObject.setReadyState(2);
                requestObject.setReadyState(3);

                // 将状态设置为成功
                requestObject.responseJSON = JSON;
                requestObject.status = 1;
                requestObject.statusText = 'Loaded.';

                // 更新就绪状态
                requestObject.setReadyState(4);
            };

            // 设置初始就绪状态
            this.setReadyState(1);

            // 现在再设置src属性并将其添加
            // 到文档头部。这样会载入脚本
            this.scriptObject.setAttribute('src', this.url);
            var head = document.getElementsByTagName('head')[0];
            head.appendChild(this.scriptObject);
        }
    };

    window.ADS.XssHttpRequest = XssHttpRequest;

    // 设置XssHttpRequest对象的不同部分
    function getXssRequestObject(url, options) {
        var req = new XssHttpRequest();

        options = options || {};
        // 默认中断时间为30秒
        options.timeout = options.timeout || 30000;
        req.onreadystatechange = function () {
            switch (req.readyState) {
                // 载入中
                case 1:
                    if (options.loadListener) {
                        options.loadListener.apply(req, arguments);
                    }
                    break;
                case 2:
                    // 载入完成
                    if (options.loadedListener) {
                        options.loadedListener.apply(req, arguments);
                    }
                    break;
                case 3:
                    // 交互
                    if (options.interactiveListener) {
                        options.interactiveListener.apply(req, arguments);
                    }
                    break;
                case 4:
                    // 完成
                    if (req.status === 1) {
                        if (options.completeListener) {
                            options.completeListener.apply(req, arguments);
                        }
                    } else {
                        if (options.errorListener) {
                            options.errorListener.apply(req, arguments);
                        }
                    }
                    break;
                default:
                    break;
            }
        };
        req.open(url, options.timeout);

        return req;

    }

    window.ADS.getXssRequestObject = getXssRequestObject;

    // 发送XssHttpRequest请求
    function xssRequest(url, options) {
        var req = getXssRequestObject(url, options);
        req.send(null);
        return req;
    }

    window.ADS.xssRequest = xssRequest;

    //跟踪hash地址变化

    /* 声称回调函数的一个辅助方法 */
    function makeCallback(method, target) {
        return function () {
            method.apply(target, arguments);
        };
    }

    /* 一个用来基于hash触发注册的方法的URL hash侦听器 */
    var actionPager = {
        // 前一个hash
        lastHash: '',
        // 为hash模式注册的方法列表
        callbacks: [],
        // Safari历史记录列表
        safariHistory: false,
        // 对为IE准备的iframe的引用
        msieHistory: false,
        // 应该被转换的链接的类名
        ajaxifyClassName: '',
        // 应用程序的根目录。当创建hash时
        // 它将是被清理后的URL
        ajaxifyRoot: '',

        /**
         * 初始化页面(pager)功能
         * @param {String} ajaxifyClass 预定义的类名，只有符合该类名的链接才具备功能，默认为 ADSActionLink
         * @param {String} ajaxifyRoot 预定义的根路径
         * @param {String} startingHash 预定义的hash值，默认为start
         * @example actionPager.init();
         */
        init: function (ajaxifyClass, ajaxifyRoot, startingHash) {

            this.ajaxifyClassName = ajaxifyClass || 'ADSActionLink';
            this.ajaxifyRoot = ajaxifyRoot || '';

            var ua = navigator.userAgent;
            if (/Safari/i.test(ua) && /Version\/3/.test(ua)) {
                this.safariHistory = [];
            } else if (/MSIE/i.test(ua) && (parseInt(ua.split('MSIE')[1],10) < 8)) {
                // 如果是MSIE 6/7，添加一个iframe以便
                // 跟踪重写（override）后退按钮
                this.msieHistory = document.createElement('iframe');
                this.msieHistory.setAttribute('id', 'msieHistory');
                this.msieHistory.setAttribute('name', 'msieHistory');
                this.msieHistory.setAttribute('src', 'fakepage');
                setStyleById(this.msieHistory, {
                    'width': '100px',
                    'height': '100px',
                    'border': '1px solid black',
                    'display': 'none',
                    'z-index': -1
                });
                document.body.appendChild(this.msieHistory);
                this.msieHistory = frames.msieHistory;
            }

            // 将链接转换为Ajax链接
            this.ajaxifyLinks();

            // 取得当前的地址
            var locat = this.getLocation();

            // 检测地址中是否包含hash（来自书签）
            // 或者是否已经提供了hash
            if (!locat.hash && !startingHash) {
                startingHash = 'start';
            }

            // 按照需要保存hash
            var ajaxHash = this.getHashFromURL(window.location.href) || startingHash;
            this.addBackButtonHash(ajaxHash);

            // 添加监视事件以观察地址栏中的变化
            var watcherCallback = makeCallback(this.watchLocationForChange, this);

            if (/MSIE/i.test(ua) && (parseInt(ua.split('MSIE')[1],10) < 8)) {
                window.setInterval(watcherCallback, 200);
            } else {
                addEvent(window, 'hashchange', watcherCallback);
            }

        },

        /**
         * 会自动将任何带标识的锚标签转换为页面（pager）可以识别的链接
         */
        ajaxifyLinks: function () {
            // 将链接转换为锚以便Ajax进行处理
            var links = getElementsByClassName(this.ajaxifyClassName, 'a');
            for (var i = 0, len = links.length; i < len; i++) {
                var curLink = links[i];
                if (hasClassName(curLink, 'ADSActionPagerModified')) {
                    continue;
                }

                // 将href属性转换为#value形式
                curLink.setAttribute('href', this.convertURLToHash(curLink.getAttribute('href')));
                addClassName(curLink, 'ADSActionPagerModified');

                // 注册单击事件以便在必要时添加历史纪录
                addEvent(curLink, 'click', function () {
                    if (this.href && this.href.indexOf('#') > -1) {
                        actionPager.addBackButtonHash(actionPager.getHashFromURL(this.href));
                    }
                });
            }
        },

        /**
         * 记录后退行为
         * @param {String} ajaxHash hash值
         * @return {Boolean}
         */
        addBackButtonHash: function (ajaxHash) {
            // 保存hash
            if (!ajaxHash) {
                return false;
            }
            if (this.safariHistory) {
                // 为Safari使用特殊数组
                if (this.safariHistory.length === 0) {
                    this.safariHistory[window.history.length] = ajaxHash;
                } else {
                    this.safariHistory[window.history.length + 1] = ajaxHash;
                }
                return true;
            } else if (this.msieHistory) {
                // 在MSIE中通过导航iframe
                this.msieHistory.document.execCommand('Stop');
                this.msieHistory.location.href = '/fakepage?hash=' +
                    ajaxHash +
                    '&title=' +
                    document.title;
                return true;
            } else {
                // 通过改变地址的值
                // 使用makeCallback包装函数
                // 以便在超时方法内部使this
                // 引用actionPager
                var timeoutCallback = makeCallback(function () {
                    if (this.getHashFromURL(window.location.href) !== ajaxHash) {
                        location.replace(location.href + '#' + ajaxHash);
                    }
                }, this);
                setTimeout(timeoutCallback, 200);
                return true;
            }
            return false;
        },

        /**
         * 间隔地检测hash的变化，还可执行注册的侦听器
         */
        watchLocationForChange: function () {
            var newHash;
            // 取得新的hash值
            if (this.safariHistory) {
                // 在Safari中从历史记录数组中取得
                if (this.safariHistory[history.length]) {
                    newHash = this.safariHistory[history.length];
                }
            } else if (this.msieHistory) {
                // 在MSIE中从iframe的地址中取得
                newHash = this.msieHistory.location.href.split('&')[0].split('=')[1];
            } else if (location.hash !== '') {
                // 对其他浏览器从window.location中取得
                newHash = this.getHashFromURL(window.location.href);
            }

            // 如果新hash与最后一次的hash不相同，则更新页面
            if (newHash && this.lastHash !== newHash) {
                if (this.msieHistory && this.getHashFromURL(window.location.href) !== newHash) {
                    // 修复MSIE中的地址栏
                    // 以便能适当地加上标签（或加入收藏夹）
                    location.hash = newHash;
                }

                // 在发生异常的情况下使用try/catch
                // 结构尝试执行任何注册的侦听器
                try {
                    if (this.callbacks.length) {
                        this.executeListeners(newHash);
                    }
                    // 在通过处理程序添加任何
                    // 新链接的情况下进行更新
                    this.ajaxifyLinks();
                } catch (ex) {
                    // 这里将捕获到回调函数中的任何异常JS
                    alert(ex);
                }

                // 将其保存为最后一个hash
                this.lastHash = newHash;
            }
        },

        /**
         * 用于根据特殊的hash来注册侦听器
         * @param {RegExp || String} regex 正则表达式
         * @param {Function} method 执行的方法
         * @param {Object || Element} context 执行环境，上下文
         */
        register: function (regex, method, context) {
            var obj = {'regex': regex};
            context = context || window;
            // 一个已经指定的环境
            obj.callback = function (matches) {
                method.apply(context, matches);
            };

            // 将侦听器添加到回调函数数则中
            this.callbacks.push(obj);
        },

        /**
         * 把链接的URL地址转换为hash值
         * @param {String} url
         * @return {*}
         */
        convertURLToHash: function (url) {
            if (!url) {
                // 没有url，因而返回一个'#'
                return '#';
            } else if (url.indexOf('#') > -1) {
                // 存在hash，因而返回它
                return '#' + url.split('#')[1];
            } else {
                // ie67会自动添加域名
                // 如果URL中包含域名（MSIE）则去掉它
                if (url.indexOf('://') > -1) {
                    url = url.match(/:\/\/[^\/]+(.*)/)[1];
                }
                // 按照init()约定去掉根目录
                return '#' + url.substring(this.ajaxifyRoot.length);
            }
        },

        /**
         * 从指定的URL中提取出hash值
         * @param url
         * @return {*}
         */
        getHashFromURL: function (url) {
            if (!url || url.indexOf('#') === -1) {
                return '';
            }
            return url.split('#')[1];
        },

        /**
         * 获取当前URL地址
         * @return {*}
         */
        getLocation: function () {
            // 检查hash
            if (!window.location.hash) {
                // 没有则生成一个
                var url = {
                    domain: null,
                    hash: null
                };
                if (window.location.href.indexOf('#') > -1) {
                    var parts = window.location.href.split('#')[1];
                    url.domain = parts[0];
                    url.hash = parts[1];
                } else {
                    url.domain = window.location;
                }
                return url;
            }
            return window.location;
        },

        /**
         * 执行侦听器
         * @param hash
         */
        executeListeners: function (hash) {
            var matches;
            // 执行与hash匹配的任何侦听器
            for (var i = 0, len = this.callbacks.length; i < len; i++) {
                if ((matches = hash.match(this.callbacks[i].regex))) {
                    this.callbacks[i].callback(matches);
                }
            }

        }
    };

    window.ADS.actionPager = actionPager;

    /* 一个复制对象的辅助方法 */
    function clone(myObj) {
        if (typeof myObj !== 'object') {
            return myObj;
        }
        if (myObj === null) {
            return myObj;
        }
        var myNewObj = {};
        for (var i in myObj) {
            myNewObj[i] = clone(myObj[i]);
        }
        return myNewObj;
    }

    /* 用于保存队列的数组 */
    var requestQueue = [];

    /**
     * 为ADS.ajaxRequest方法启用排队功能的包装对象
     * @param url
     * @param options
     * @param queue
     * @example
     *      ADS.ajaxRequestQueue('/your/script/', {
     *          completeListener: function(){
     *              alert(this.responseText);
     *          }
     *      }, 'Queue1');
     */
    function ajaxRequestQueue(url, options, queue) {
        queue = queue || 'default';

        // 这个对象将把可选的侦听器包装在另一个函数中
        // 因此，可选的对象必须唯一。否则，如果该方法
        // 被调用时使用的是共享的可选对象，那么会导致
        // 陷入递归中
        options = clone(options) || {};
        if (!requestQueue[queue]) {
            requestQueue[queue] = [];
        }

        // 当前一次请求完成时，需要使用completeListener
        // 调用队列中的下一次请求。如果完成侦听器已经
        // 有定义，那么需要首先调用它

        // 取得旧侦听器
        var userCompleteListener = options.completeListener;

        // 添加新侦听器
        options.completeListener = function () {
            // 如果存在旧的侦听器则首先调用它
            if (userCompleteListener) {
                // this引用的是情求对象
                userCompleteListener.apply(this, arguments);
            }

            // 从队列中移除这个请求
            requestQueue[queue].shift();

            // 调用队列中的下一项
            if (requestQueue[queue][0]) {
                // 请求保存在req属性中，但为防止它是
                // 一个POST请求，故也需包含send选项
                var q = requestQueue[queue][0].req.send(
                    requestQueue[queue][0].send
                );
            }
        };

        // 如果发生了错误，应该通过调用相应的
        // 错误处理方法取消队列中的其他请求

        // 取得旧侦听器
        var userErrorListener = options.errorListener;

        // 添加新侦听器
        options.errorListener = function () {
            if (userErrorListener) {
                userErrorListener.apply(this, arguments);
            }

            // 由于已经调用了错误侦听器
            // 股从队列中移除这个请求
            requestQueue[queue].shift();

            // 由于出错需要取消队列中的其余请求，但首先要调用
            // 每个请求的errorListener。通过调用队列中
            // 下一项的错误侦听器就会才清楚所有排队的请求，因为在
            // 链中的调研那个是一次发生的

            // 检测队列中是否还存在请求
            if (requestQueue[queue].length) {
                // 取得下一项
                var q = requestQueue[queue].shift();

                // 中断请求
                q.req.abort();

                // 伪造请求对象，以便errorListener
                // 认为请求已经完成并相应地运行

                var fakeRequest = {};

                // 将status设置为0，将readyState设置为4
                // 就好像请求虽然完成但却失败了一样
                fakeRequest.status = 0;
                fakeRequest.readyState = 4;

                fakeRequest.responseText = null;
                fakeRequest.responseXML = null;

                // 设置错误信息，以便需要时显示
                fakeRequest.statusText = 'A request in the queue received an error';

                // 调用状态改变，如果readyState是4，而
                // status不是200，则会调用errorListener
                q.error.apply(fakeRequest);
            }
        };

        // 将这个请求添加到队列中
        requestQueue[queue].push({
            req: getRequestObject(url, options),
            send: options.send,
            error: options.errorListener
        });

        // 如果队列的长度表明只有一个
        // 项（即第一个）则调用请求
        if (requestQueue[queue].length === 1) {
            ajaxRequest(url, options);
        }
    }

    window.ADS.ajaxRequestQueue = ajaxRequestQueue;

    //客户端检测
    var client = (function(){
        //呈现引擎
        var engine = {
            ie: 0,
            gecko: 0,
            webkit: 0,
            khtml: 0,
            opera: 0,
            ver: null           //具体版本号
        };

        //浏览器
        var browser = {
            //主要浏览器
            ie: 0,
            firefox: 0,
            kong: 0,
            opera: 0,
            chrome: 0,
            safari: 0,
            ver: null      //具体的版本
        };

        //平台，设备和操作系统
        var system = {
            win: false,
            mac: false,
            x11: false,

            //移动设备
            iphone: false,
            ipod: false,
            nokiaN: false,
            winMobile: false,
            macMobile: false,

            //游戏系统
            wii: false,
            ps: false
        };

        //在此检测呈现引擎，平台和设备
        var ua = navigator.userAgent;

        if (window.opera) {

            //第一步检测opera，因为它的用户代理字符串有可能完全模仿其他浏览器
            //要识别Opera，必须的检测window.opera对象
            engine.ver = browser.ver = window.opera.version();
            engine.opera = browser.opera = parseFloat(engine.ver);
        } else if (/AppleWebkit\/(\S+)/.test(ua)) {

            //第二个要检测的是Webkit，因为Webkit的永华代理字符串中包含“Gecko”和“KHTML”
            //Webkit的用户代理字符串中的“AppleWebkit”是独一无二的
            engine.ver = RegExp.$1;
            engine.webkit = parseFloat(engine.ver);

            //确定是Chrome还是Safari
            if (/Chrome\/(\S+)/.test(ua)) {
                browser.ver = RegExp.$1;
                browser.chrome = parseFloat(browser.ver);
            } else if (/Version\/(\S+)/.test(ua)) {
                browser.ver = RegExp.$1;
                browser.safari = parseFloat(browser.ver);
            } else {
                //近似地确定版本号
                var safariVersion = 1;
                if (engine.webkit < 100) {
                    safariVersion = 1;
                } else if (engine.webkit < 312) {
                    safariVersion = 1.2;
                } else if (engine.webkit < 412) {
                    safariVersion = 1.3;
                } else {
                    safariVersion = 2;
                }
                browser.safari = browser.ver = safariVersion;
            }

        } else if (/KHTML\/(\S+)/.test(ua) || /Konqueror\/([^;]+)/.test(ua)) {

            //接下来测试KHTML，KHTML的用户代理字符串也包含“Gecko”
            //使用Konqueror检测Konqueror3.1及更早版本
            engine.ver = browser.ver = RegExp.$1;
            engine.khtml = browser.kong = parseFloat(engine.ver);

        } else if (/rv:([^\)]+)\) Gecko\/\d{8}/.test(ua)) {

            //检测Gecko，Gecko版本号会出现在字符串"rv:"的后面
            engine.ver = RegExp.$1;
            engine.gecko = parseFloat(engine.ver);

            //确定是不是Firefox
            if (/Firefox\/(\S+)/.test(ua)) {
                browser.ver = RegExp.$1;
                browser.firefox = parseFloat(browser.ver);
            }

        } else if (/MSIE ([^;]+)/.test(ua)) {

            //检测IE，IE版本号位于字符串“MSIE”之后，一个分号的前面
            engine.ver = browser.ver = RegExp.$1;
            engine.ie = browser.ie = parseFloat(engine.ver);

        }

        //检测浏览器
        browser.ie = engine.ie;
        browser.opera = engine.opera;

        //识别平台
        var p = navigator.platform;
        system.win = p.indexOf("Win") > -1;
        system.mac = p.indexOf("Mac") > -1;
        system.x11 = (p.indexOf("x11") > -1) || (p.indexOf("Linux") > -1);

        //识别windows操作系统
        if (system.win) {
            if (/Win(?:dows )?([^do]{2})\s?(\d+\.\d+)?/.test(ua)) {
                if (RegExp.$1 === "NT") {
                    switch (RegExp.$2) {
                        case "5.0":
                            system.win = "2000";
                            break;
                        case "5.1":
                            system.win = "XP";
                            break;
                        case "6.0":
                            system.win = "Vista";
                            break;
                        case "6.1":
                            system.win = "WIN7";
                            break;
                        default:
                            system.win = "NT";
                            break;
                    }
                } else if (RegExp.$1 === "9x") {
                    system.win = "ME";
                } else {
                    system.win = RegExp.$1;
                }
            }
        }


        system.iphone = ua.indexOf('iPhone') > -1;
        system.ipod = ua.indexOf('iPod') > -1;
        system.ipad = ua.indexOf('iPad') > -1;
        system.nokiaN = ua.indexOf('NokiaN') > -1;

        // windows mobile
        if (system.win === 'CE') {
            system.winMobile = system.win;
        } else if (system.win === 'Ph') {
            if (/Windows Phone OS (\d+\.\d+)/.test(ua)) {
                system.win = 'Phone';
                system.winMobile = parseFloat(RegExp.$1);
            }
        }

        // 检测IOS版本
        if (system.mac && ua.indexOf('Mobile') > -1) {
            if (/CPU (?:iPhone )?OS (\d+_\d+)/.test(ua)) {
                system.ios = parseFloat(RegExp.$1.replace('_', '.'));
            } else {
                // 不能真正检测出来，所以只能猜测
                system.ios = 2;
            }
        }

        // 检测android版本
        if (/Android (\d+\.\d+)/.test(ua)) {
            system.android = parseFloat(RegExp.$1);
        }

        // 游戏系统
        system.wil = ua.indexOf('Wii') > -1;
        system.ps = /playstation/i.test(ua);

        // 返回这些对象
        return {
            engine: engine,
            browser: browser,
            system: system
        };
    })();

    window.ADS.client = client;

    //对非DOM元素实现自定义事件
    function EventTarget() {
        //存储事件处理程序的属性对象
        this.handlers = {};
    }

    EventTarget.prototype = {
        //重新将constructor指向EventTarget构造函数
        constructor: EventTarget,
        /**
         * 注册给定类型的事件处理程序
         * @param type 自定义的事件类型
         * @param handler 处理该事件类型的函数
         */
        addHandler: function (type, handler) {
            //如果handlers属性中没有存在一个针对该事件类型的数组
            //则创建一个新的。（一个事件类型可以对应多个事件处理函数，因此要用数组保存）
            //然后使用push()将该处理程序添加到数组的末尾
            if (typeof this.handlers[type] === "undefined") {
                this.handlers[type] = [];
            }
            this.handlers[type].push(handler);
        },
        /**
         * 触发事件
         * @param event 一个至少包含type属性的对象
         */
        fire: function (event) {
            //给event对象设置一个target属性
            if (!event.target) {
                event.target = this;
            }
            //如果该事件类型的执行函数存在，
            //调用各个函数，并给出event对象
            if (this.handlers[event.type] instanceof Array) {
                var handlers = this.handlers[event.type];
                for (var i = 0, len = handlers.length; i < len; i++) {
                    handlers[i](event);
                }
            }
        },
        /**
         * 注销事件类型的事件处理程序
         * @param type 事件类型
         * @param handler 执行的函数
         */
        removeHandler: function (type, handler) {
            if (this.handlers[type] instanceof Array) {
                var handlers = this.handlers[type];
                //搜索事件处理程序的数组找到要删除的处理程序的位置
                //找到了就退出循环，然后将该项目丛数组中删除
                for (var i = 0, len = handlers.length; i < len; i++) {
                    if (handlers[i] === handler) {
                        break;
                    }
                }
                handlers.splice(i, 1);
            }
        }
    };

    window.ADS.EventTarget = EventTarget;

    /**
     * 封装cookie的操作
     * @type {Object}
     */
    var CookieUtil = {
        /**
         * 根据cookie的名字获取相应的值
         * @param name cookie名字
         * @return {*}
         */
        get: function (name) {
            //对name进行URL编码
            var cookieName = encodeURIComponent(name) + '=',
                cookieStart = document.cookie.indexOf(cookieName),
                cookieValue = null;
            //找到cookieName
            if (cookieStart > -1) {
                //以cookieStart为起点找到最近的";"
                var cookieEnd = document.cookie.indexOf(';', cookieStart);
                //没找到";"，则是document.cookie的最后一个值
                if (cookieEnd === -1) {
                    cookieEnd = document.cookie.length;
                }
                //提取相应value字段
                cookieValue = decodeURIComponent(document.cookie.substring(cookieStart + cookieName.length, cookieEnd));
            }
            //返回
            return cookieValue;
        },
        /**
         * 设置一个cookie
         * @param name cookie名字
         * @param value 相应的值
         * @param expire 生存周期 Date
         * @param path 路径
         * @param domain 域名
         * @param secure Boolean
         */
        set: function (name, value, expire, path, domain, secure) {
            //必须先进行URL编码
            var cookieText = encodeURIComponent(name) + '=' + encodeURIComponent(value);
            if (expire instanceof Date) {
                //toGMTString()方法正确格式化Date对象
                cookieText += '; expire=' + expire.toGMTString();
            }
            if (path) {
                cookieText += '; path=' + path;
            }
            if (domain) {
                cookieText += '; domain=' + domain;
            }
            if (secure) {
                cookieText += '; secure';
            }
            document.cookie = cookieText;
        },
        /**
         * 删除cookie
         * @param name
         * @param path
         * @param domain
         * @param secure
         */
        unset: function (name, path, domain, secure) {
            this.set(name, '', new Date(0), path, domain, secure);
        }
    };

    window.ADS.CookieUtil = CookieUtil;

//子cookie的操作
//为了绕开浏览器的单域名下的cookie数限制
//子cookie是存放在单个cookie中的更小段的数据
    var SubCookieUtil = {
        /**
         * 获取单个子cookie的值
         * @param name cookie名称
         * @param subName 子cookie名称
         * @return {*}
         */
        get: function (name, subName) {
            var subCookies = this.getAll(name);
            if (subCookies) {
                return subCookies(subName);
            } else {
                return null;
            }
        },
        /**
         * 获取所有子cookie并将它们放入一个对象中返回
         * @param name cookie名称
         * @return {*} 返回对象或null
         */
        getAll: function (name) {
            var cookieName = encodeURIComponent(name) + "=",
                cookieStart = document.cookie.indexOf(cookieName),
                cookieValue = null,
                result = {};
            if (cookieStart > -1) {
                var cookieEnd = document.cookie.indexOf(";", cookieName);
                if (cookieEnd === -1) {
                    cookieEnd = document.cookie.length;
                }
                //没有进行解码，因为要对子cookie分离操作
                cookieValue = document.cookie.substring(cookieStart + cookieName.length, cookieEnd);
                //
                if (cookieValue.length > 0) {
                    //分离出子cookie的对象
                    var subCookies = cookieValue.split("&");
                    //遍历分隔出子cookie的名称和值，解码后返回对象
                    for (var i = 0, len = subCookies.length; i < len; i++) {
                        var parts = subCookies[i].split("=");
                        result[decodeURIComponent(parts[0])] = decodeURIComponent(parts[1]);
                    }
                    return result;
                }
            }
            //没找到，返回空
            return null;
        },
        /**
         * 存储单个子cookie
         * @param name cookie名称
         * @param subName 子cookie名称
         * @param value 子cookie值
         * @param expires 失效日期
         * @param path 路径
         * @param domain 域名
         * @param secure Boolean安全作用域
         */
        set: function (name, subName, value, expires, path, domain, secure) {
            //获取name名称的所有子cookie，没有则创建空对象
            var subcookies = this.getAll(name) || {};
            //给对象添加属性和值
            subcookies[subName] = value;
            //调用setAll()方法
            this.setAll(name, subcookies, expires, path, domain, secure);
        },
        /**
         * 存储所有子cookie
         * @param name cookie名称
         * @param subcookies 子cookie名称
         * @param expires 失效日期
         * @param path 路径
         * @param domain 域名
         * @param secure Boolean安全作用域
         */
        setAll: function (name, subcookies, expires, path, domain, secure) {
            var cookieText = encodeURIComponent(name) + "=";
            //创建数组，用于保存子cookie
            var subcookieParts = [];
            //遍历对象属性
            for (var subName in subcookies) {
                //如果存在，则把编码后的名称和值保存到数组
                if (subName.length > 0 && subcookies.hasOwnProperty(subName)) {
                    subcookieParts.push(encodeURIComponent(subName) + "=" + encodeURIComponent(subcookies[subName]));
                }
            }
            //存在子cookie
            if (subcookieParts.length > 0) {
                //连接子cookie
                cookieText += subcookieParts.join("& ");
                if (expires instanceof Date) {
                    cookieText += ";expires=" + expires.toGMTString();
                }
                if (path) {
                    cookieText += ";path=" + path;
                }
                if (domain) {
                    cookieText += ";domain=" + domain;
                }
                if (secure) {
                    cookieText += ";secure";
                }
            } else {
                //相当于删除cookie操作
                cookieText += ";expires=" + (new Date(0)).toGMTString();
            }
            document.cookie = cookieText;
        },
        /**
         * 删除单个子cookie的名称和值
         * @param name
         * @param subName
         * @param path
         * @param domain
         * @param secure
         */
        unset: function (name, subName, path, domain, secure) {
            var subcookies = this.getAll(name);
            if (subcookies) {
                //删除对应的属性和值
                delete subcookies[subName];
                //重新设置cookie
                this.setAll(name, subcookies, null, path, domain, secure);
            }
        },
        /**
         * 删除所有子cookie
         * @param name
         * @param path
         * @param domain
         * @param secure
         */
        unsetAll: function (name, path, domain, secure) {
            this.setAll(name, null, new Date(0), path, domain, secure);
        }
    };

    window.ADS.SubCookieUtil = SubCookieUtil;
})();

//重复一个字符串
if (!String.repeat) {
    String.prototype.repeat = function (times) {
        return new Array(times + 1).join(this);
    };
}

//清除结尾和开头处的空白符
if (!String.trim) {
    String.prototype.trim = function () {
        return this.replace(/^\s+|\s+$/g, '');
    };
}

// 扩展链式调用方法
Function.prototype.method = function (name, fn) {
    this.prototype[name] = fn;
    return this;
};

// 扩展数组方法
if (!Array.prototype.forEach) {
    Array.method('forEach', function (fn, thisObj) {
        var scope = thisObj || window;
        for (var i = 0, len = this.length; i < len; i++) {
            fn.call(scope, this[i], i, this);
        }
    });
}

if (!Array.prototype.filter) {
    Array.method('filter', function (fn, thisObj) {
        var scope = thisObj || window;
        var a = [];
        for (var i = 0, len = this.length; i < len; i++) {
            if (!fn.call(scope, this[i], i, this)) {
                continue;
            }
            a.push(this[i]);
        }
        return a;
    });
}

/* Object-oriented Helper functions. */
function clone(object) {
    function F() {
    }

    F.prototype = object;
    return new F();
}

function extend(subClass, superClass) {
    var F = function () {
    };
    F.prototype = superClass.prototype;
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;

    subClass.superclass = superClass.prototype;
    if (superClass.prototype.constructor === Object.prototype.constructor) {
        superClass.prototype.constructor = superClass;
    }
}

function augment(receivingClass, givingClass) {
    if (arguments[2]) { // Only give certain methods.
        for (var i = 2, len = arguments.length; i < len; i++) {
            receivingClass.prototype[arguments[i]] = givingClass.prototype[arguments[i]];
        }
    }
    else { // Give all methods.
        for (var methodName in givingClass.prototype) {
            if (!receivingClass.prototype[methodName]) {
                receivingClass.prototype[methodName] = givingClass.prototype[methodName];
            }
        }
    }
}