/**
 *feng_zhuang_ku_1.0版本，js封装库，2016/12/29日：林贵秀
 **/


/** 前台调用
 * 每次调用$()创建库对象,使其每次调用都是独立的对象
 * $()创建库对象,有一个可选参数，参数有两种方式，1是传入的this，2是传入的字符串
 * 可选参数说明：
 * 传入的this，this，就是当前对象本身
 *
 * 传入的字符串，代表获取元素选择器
 * 参数是元素选择器(id值、class值、标签名称)其中一样的字符串方式，或者是其中几样的字符串组合方式
 * 获取一个元素传参方式 ‘#xxx‘( 表示获取id)，‘.xxx‘(表示获取class)，‘xxx‘(表示获取标签)
 * 从父元素向下获取组合方式按照，一个元素传参方式加上空格，如: (‘#sdf .hjk p‘)表示获取id为sdf元素下的class为hjk下的p元素
 *
 * 传入一个匿名函数，表示是dom页面文档加载，在匿名函数里写代码，表示等待页面文档加载完毕后执行函数里的代码
 * 加载dom页面文档结构后执行函数，不等待图片，音频视频等文件加载
 **/
var $ = function (args) {
    return new feng_zhuang_ku(args);
};

/**
 *定义封装库构造函数，类库
 **/
function feng_zhuang_ku(args) {
    /** jie_dian属性，创建数组，初始化，保存获取到的元素节点，返回数组
     **/
    this.jie_dian = [];
    if (typeof args == ‘string‘) {                      //如果传入的是字符串，说明是获取元素选择器
        if (args.indexOf(‘ ‘) != -1) {
            /**从父元素向下获取组合方式**/
            var fen_ge = args.split(‘ ‘);                //将接收的组合式元素名称分割成数组
            var lin_shi = [];                            //保存临时对象的数组，解决被覆盖问题
            var fu_yuan_su = [];                         //保存父元素的数组
            for (var i = 0; i < fen_ge.length; i++) {
                if (fu_yuan_su.length == 0)fu_yuan_su.push(document);               //如果没有父节点，就把document放入父节点
                switch (fen_ge[i].charAt(0)) {                                     //判断字符串的第一个字符是什么
                    case ‘#‘:                                                      //说明是id
                        lin_shi = [];                                              //清理临时数组，以便父节点失效，子节点有效
                        lin_shi.push(this.huo_qu_id(fen_ge[i].substring(1)));      //去除第一个字符，获取到传入的id元素，保存到临时数组
                        fu_yuan_su = lin_shi;                                      //将临时节点数组放入父节点数字
                        break;                                                     //说明是class
                    case ‘.‘:
                        lin_shi = [];                                                                   //清理临时数组，以便父节点失效，子节点有效
                        for (var f = 0; f < fu_yuan_su.length; f++) {                                  //根据父节点的长度循环
                            var tempss = this.huo_qu_class(fen_ge[i].substring(1), fu_yuan_su[f]);     //获取到父节点下的子节点
                            for (var n = 0; n < tempss.length; n++) {                      //循环子节点，将每次循环的子节点添加到临时数组
                                lin_shi.push(tempss[n]);
                            }
                        }
                        fu_yuan_su = lin_shi;                                               //将临时节点数组放入父节点数字
                        break;
                    default:                                                               //说明是标签
                        lin_shi = [];                                                       //清理临时数组，以便父节点失效，子节点有效
                        for (var j = 0; j < fu_yuan_su.length; j++) {                      //根据父节点的长度循环
                            var temps = this.huo_qu_name(fen_ge[i], fu_yuan_su[j]);        //获取到父节点下的子节点
                            for (var k = 0; k < temps.length; k++) {                       //循环子节点，将每次循环的子节点添加到临时数组
                                lin_shi.push(temps[k]);
                            }
                        }
                        fu_yuan_su = lin_shi;                                               //将临时节点数组放入父节点数字
                }
            }
            this.jie_dian = lin_shi;                                            //将临时数组放入jie_dian数组
        } else {
            /**一个元素传参方式**/
            switch (args.charAt(0)) {                                           //判断字符串的第一个字符是什么
                case ‘#‘:                                                       //说明是id
                    this.jie_dian.push(this.huo_qu_id(args.substring(1)));      //去除第一个字符，获取到传入的id元素
                    break;
                case ‘.‘:                                                       //说明是class
                    this.jie_dian = this.huo_qu_class(args.substring(1));       //去除第一个字符，获取到传入的class元素
                    break;
                default:                                                        //说明是标签
                    this.jie_dian = this.huo_qu_name(args);                     //获取到传入的标签元素
            }
        }
    } else if (typeof args == ‘object‘) {                                       //如果传入的是对象，说明是this，就是当前对象本身
        if (args != undefined) {
            this.jie_dian[0] = args;
        }
    } else if (typeof args == ‘function‘) {
        this.dom_dom(args);
    }
}



/**█████████████████████████████████████████████████封装库█████████████████████████████████████████████████████████**/

/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃获取元素标签开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
 /**获取元素标签说明：
 * jie_dian属性，保存获取到的元素节点，返回数组,
 *
 * huo_qu_id()方法,通过id获取元素标签，参数是id值，将获取到的元素对象返回给方法本身，无法连缀
 * huo_qu_name()方法，通过标签名称获取相同标签名的元素，
 * huo_qu_class()方法，获取相同class属性的节点，返回包含相同class属性的节点数组，返回给方法本身,无法连缀
 * hq_form_name()方法，获取表单里，指定name值的元素节点，也就是获取表单里指定名称的元素节点，在form元素对象下使用
 * hq_value()方法，获取和设置表单里节点的value属性值
 * huo_qu_name_zhi()方法，通过元素name值获取指定元素，适用于获取表单元素,
 * shang_jd()方法，获取当前节点同级的上一个节点
 * xia_jd()方法，获取当前节点同级的下一个节点
 * hq_jd()方法,多个节点时，获取某一个节点，并返回这个节点对象,参数是节点索引
 * sh_jd()方法,多个节点时，获取首个节点，并返回这个节点对象,无参
 * w_jd()方法,多个节点时，获取末个节点，并返回这个节点对象,无参
 * guo_lv_jie_dian()方法，多个节点时，获取某一个节点，并且feng_zhuang_ku对象
 * jd_length()方法，获取一个节点集合的长度
 * hq_suo_yin()方法，获取一个节点在，父节点下，子节点集合里的索引，也就是在集合里的下标
 * hq_shu_xing_zhi()方法，获取或设置一个节点的属性值
 * huo_qu_zi_jie_dian()方法，获取一个元素下的子元素
 * dom_dom()方法，加载dom页面文档结构后执行函数，不等待图片，音频视频等文件加载
 **/

/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃元素节点操作开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
/**元素节点操作说明：
 * c_css()方法，给获取到的元素设置ss样式,或者获取css样式，
 * shzh_tou_ming_du()方法，给元素设置透明度
 * wen_ben()方法，给获取到的元素设置文本，或者获取文本
 * wen_ben_guo_lv()方法，给获取到的元素设置文本，或者获取文本，会过滤html标签
 * tian_jia_class()方法，给获取到的元素添加class属性，参数是class属性值，可以连缀
 * yi_chu_class()方法，给获取到的元素移除class属性，参数是要移除的class属性值，可以连缀
 * she_zhi_link_css()方法，设置link连接、或style内嵌、中的CSS样式
 * yi_chu_link_css()方法，移除link连接、或style内嵌、中的CSS样式
 * tuo_zhuai()方法，将一个弹窗元素实现拖拽功能
 **/
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃元素事件开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
/**元素事件说明：
 * shu_biao_yi_ru_yi_chu()方法，给元素设置鼠标移入移出事件，接收两个参数，参数是移入和移出时的执行函数(包含代码)
 * xian_shi()方法，设置元素显示,无参
 * yin_cang()方法，设置元素隐藏,无参
 * yuan_su_shi_jian()方，给元素添加一个元素事件
 * on_click()方法，给获取到的元素添加一个点击事件，参数是一个匿名函数（包含函数功能），
 * dian_ji_qie_huan()方法，设置点击切换，将元素设置成点击切换，也就是点击目标元素后，循环执行方法里的函数
 * yuan_su_ju_zhong()方法，将获取到的区块元素居中到页面，
 * chuang_kou_shi_jian()方法，浏览器窗口事件，当窗口的大小变化时触发函数
 * zhe_zhao_suo_ping()方法，将一个区块元素设置成遮罩锁屏区块
 * jie_chu_suo_ping()方法，将一个锁屏区块元素解除锁屏，
 **/
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃元素动画开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
/**
 * 元素动画说明
 * yi_dong_tou_ming()方法，将一个元素，
 *
 **/
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃插件入口开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/

/** 插件入口，简单的理解就是通过extend()方法，向此基础库添加一个原型方法
 **/
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃ajax通讯▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
/**
 * ajax()方法，ajax通讯方法，跨页面向动态页面发送或获取数据
 **/
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃表单序列化▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/
/**
 * xu_lie_biao_dan()方法，表单序列化方法，将自动获取指定表单里面的各项字段name值和value值，无法连缀
 **/
/**█████████████████████████████████████████████████封装库██████████████████████████████████████████████████████████**/




/**------------------------------------------------获取元素标签开始--------------------------------------------**/

/** huo_qu_id()方法,通过id获取元素标签，参数是id值，将获取到的元素对象返回给方法本身，无法连缀
 **/
feng_zhuang_ku.prototype.huo_qu_id = function (id) {
    return document.getElementById(id);
};

/** huo_qu_name()方法，通过标签名称获取相同标签名的元素，返回包含相同标签名的元素数组，返回给方法本身
 * 两个参数：获取指定元素下的相同标签元素，参数1标签名称，参数2是要获取元素的父元素
 * 一个参数：获取页面所有相同标签元素，参数是标签名称
 **/
feng_zhuang_ku.prototype.huo_qu_name = function (tag, parentnode) {
    var node = null;
    var lin_shi = [];
    if (parentnode != undefined) {
        node = parentnode;
    } else {
        node = document;
    }
    var tags = node.getElementsByTagName(tag);
    for (var i = 0; i < tags.length; i++) {
        lin_shi.push(tags[i]);
    }
    return lin_shi;
};

/** huo_qu_class()方法，获取相同class属性的节点，返回包含相同class属性的节点数组，返回给方法本身,无法连缀
 * 一个参数：获取整个页面指定的class属性节点，参数是class属性值
 * 两个参数：获取指定元素区下的class属性节点，参数1是class属性值，参数2是要获取class属性节点的父元素节点
 **/
feng_zhuang_ku.prototype.huo_qu_class = function (name, parentnode) {
    var node = null;
    var lin_shi = [];
    if (parentnode != undefined) {
        node = parentnode;
    } else {
        node = document;
    }
    var all = node.getElementsByTagName(‘*‘);
    for (var i = 0; i < all.length; i++) {
        if ((new RegExp(‘(\\s|^)‘ + name + ‘(\\s|$)‘)).test(all[i].className)){
            lin_shi.push(all[i]);
        }
    }
    return lin_shi;
};

/** hq_form_name()方法，获取表单里，指定name值的元素节点，也就是获取表单里指定名称的元素节点，在form元素对象下使用
 *  参数是要获取表单里的元素name值，也就是名称
 *  返回表单里有相同name值的节点集合
 **/
feng_zhuang_ku.prototype.hq_form_name = function (name) {
    for (var i = 0; i < this.jie_dian.length; i++){
        this.jie_dian[i] = this.jie_dian[i][name];
    }
    return this;
};

/** hq_value()方法，获取和设置表单里节点的value属性值
 *  无参为获取表单里节点的value属性值
 *  有参为设置表单里节点的value属性值，参数是要设置的value属性值
 **/
feng_zhuang_ku.prototype.hq_value = function (str) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (arguments.length == 0) {
            return this.jie_dian[i].value;
        }
        this.jie_dian[i].value =http://www.mamicode.com/ str;
    }
    return this;
};

/** huo_qu_name_zhi()方法，通过元素name值获取指定元素，参数是元素name值，返回元素相同name值对象集合，
 * 循环元素集合，将每次循环到的元素对象添加到 jie_dian属性，适用于获取表单元素
 **/
feng_zhuang_ku.prototype.huo_qu_name_zhi = function (name) {
    var name_zhi = document.getElementsByName(name);
    for (var i = 0; i < name_zhi.length; i++) {
        this.jie_dian.push(name_zhi[i]);
    }
    return this;
};

/** shang_jd()方法，获取当前节点同级的上一个节点
 **/
feng_zhuang_ku.prototype.shang_jd = function () {
    for (var i = 0; i < this.jie_dian.length; i ++) {
        this.jie_dian[i] = this.jie_dian[i].previousSibling;
        if (this.jie_dian[i] == null) throw new Error(‘找不到上一个同级元素节点！‘);
        if (this.jie_dian[i].nodeType == 3) this.shang_jd();
    }
    return this;
};

/** xia_jd()方法，获取当前节点同级的下一个节点
 **/
feng_zhuang_ku.prototype.xia_jd = function () {
    for (var i = 0; i < this.jie_dian.length; i ++) {
        this.jie_dian[i] = this.jie_dian[i].nextSibling;
        if (this.jie_dian[i] == null) throw new Error(‘找不到下一个同级元素节点！‘);
        if (this.jie_dian[i].nodeType == 3) this.xia_jd();
    }
    return this;
};

/** hq_jd()方法,多个节点时，获取某一个节点，并返回这个节点对象,参数是节点索引
 **/
feng_zhuang_ku.prototype.hq_jd = function (num) {
    return this.jie_dian[num];
};

/** sh_jd()方法,多个节点时，获取首个节点，并返回这个节点对象,无参
 **/
feng_zhuang_ku.prototype.sh_jd = function () {
    return this.jie_dian[0];
};

/** w_jd()方法,多个节点时，获取末个节点，并返回这个节点对象,无参
 **/
feng_zhuang_ku.prototype.w_jd = function () {
    return this.jie_dian[this.jie_dian.length - 1];
};

/** guo_lv_jie_dian()方法，多个节点时，获取某一个节点，并且feng_zhuang_ku对象
 * 参数是要获取jie_dian属性里的对象索引
 **/
feng_zhuang_ku.prototype.guo_lv_jie_dian = function (num) {
    var element = this.jie_dian[num];
    this.jie_dian = [];
    this.jie_dian[0] = element;
    return this;
};

/** jd_length()方法，获取一个节点集合的长度
 **/
feng_zhuang_ku.prototype.jd_length = function () {
    return this.jie_dian.length;
};

/** hq_suo_yin()方法，获取一个节点在，父节点下，子节点集合里的索引，也就是在集合里的下标
 **/
feng_zhuang_ku.prototype.hq_suo_yin = function () {
    var children = this.jie_dian[0].parentNode.children;
    for (var i = 0; i < children.length; i++){
        if (this.jie_dian[0] == children[i]) return i;
    }
};

/** hq_shu_xing_zhi()方法，获取或设置一个节点的属性值
 * 1个参数，获取属性值，参数是属性名称
 * 2个参数，设置属性值，第1个属性名称，第2个属性值
 **/
feng_zhuang_ku.prototype.hq_shu_xing_zhi = function (shu_xing, zhi) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (arguments.length == 1) {
            return this.jie_dian[i].getAttribute(shu_xing);
        } else if (arguments.length == 2){
            this.jie_dian[i].setAttribute(shu_xing,zhi);
        }
    }
    return this;
};

/** huo_qu_zi_jie_dian()方法，获取一个元素下的子元素
 * 注意首先要获取到父元素，在使用huo_qu_zi_jie_dian()方法
 * 参数是要获取的，子元素(id值、class值、标签名称)其中一样的字符串方式，
 * 传参方式 ‘#xxx‘( 表示获取id)，‘.xxx‘(表示获取class)，‘xxx‘(表示获取标签)
 **/
feng_zhuang_ku.prototype.huo_qu_zi_jie_dian = function (str) {
    var lin_shi = [];                                               //临时数组
    for (var i = 0; i < this.jie_dian.length; i++) {               //根据父元素的长度，循环出父元素
        switch (str.charAt(0)) {                                   //判断字符串的第一个字符是什么
            case ‘#‘:                                              //说明是id
                lin_shi.push(this.huo_qu_id(str.substring(1)));    //获取到父元素下的子元素id等于str的标签，将它添加到临时数组
                break;
            case ‘.‘:                                                     //说明是class
                var tempss = this.huo_qu_class(str.substring(1), this.jie_dian[i]);
                for (var k = 0; k < tempss.length; k++) {
                    lin_shi.push(tempss[k]);
                }
                break;
            default:                                                      //说明是标签名称
                var temps = this.huo_qu_name(str, this.jie_dian[i]);
                for (var j = 0; j < temps.length; j++) {
                    lin_shi.push(temps[j]);
                }
        }
    }
    this.jie_dian = lin_shi;                                               //将临时数组替换成节点数组
    return this;
};

/**  dom_dom()方法，加载dom页面文档结构后执行函数，不等待图片，音频视频等文件加载
 *  参数是页面文档加载后要执行的函数
 **/
feng_zhuang_ku.prototype.dom_dom = function (fn) {
    dom_jia_zai(fn);
    return this;
};

/**------------------------------------------------获取元素标签结束--------------------------------------------**/



/**------------------------------------------------元素节点操作开始--------------------------------------------**/

/** c_css()方法，给获取到的元素设置ss样式,或者获取css样式，
 * 两个参数：设置样式，参数1样式名称，参数2样式值,设置的行内样式
 * 一个参数：获取样式，参数是样式名称，无法连缀，获取即可用获取行内也可以获取连接
 **/
feng_zhuang_ku.prototype.c_css = function (attr, value) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (arguments.length == 1) {
            return getStyle(this.jie_dian[i], attr); //getStyle()函数库函数，跨浏览器获取元素Style，样式指定属性
        } else {
            this.jie_dian[i].style[attr] = value;
        }
    }
    return this;
};

/** shzh_tou_ming_du()方法，给元素设置透明度
 *  参数是要设置的透明度值，为百分比值，如10%，就是10
 **/
feng_zhuang_ku.prototype.shzh_tou_ming_du = function (zhi) {
    for (var i = 0; i < this.jie_dian.length; i++){
        this.jie_dian[i].style.opacity = zhi / 100;
        this.jie_dian[i].style.filter = ‘alpha(opacity=‘+ zhi +‘)‘;
    }
    return this;
};

/** wen_ben()方法，给获取到的元素设置文本，或者获取文本
 * 有参：设置文本，参数是要设置的文本字符串。
 * 无参：获取文本。无法连缀
 **/
feng_zhuang_ku.prototype.wen_ben = function (str) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (arguments.length == 0) {
            return this.jie_dian[i].innerHTML;
        }
        this.jie_dian[i].innerHTML = str;
    }
    return this;
};

/** wen_ben_guo_lv()方法，给获取到的元素设置文本，或者获取文本，会过滤html标签
 * 有参：设置文本，参数是要设置的文本字符串。如果有html标签会自动转换成字符串形式在设置
 * 无参：获取文本。如果有html标签获取后会自动过滤html标签，无法连缀
 **/
feng_zhuang_ku.prototype.wen_ben_guo_lv = function (str) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (arguments.length == 0) {
            if(typeof this.jie_dian[i].innerText == ‘string‘){
                return this.jie_dian[i].innerText;
            }else if (typeof this.jie_dian[i].textContent == ‘string‘){
                return this.jie_dian[i].textContent;
            }
        }else if (typeof this.jie_dian[i].innerText == ‘string‘){
            this.jie_dian[i].innerText = str;
        }else if (typeof this.jie_dian[i].textContent == ‘string‘){
            this.jie_dian[i].textContent = str;
        }
    }
    return this;
};

/** tian_jia_class()方法，给获取到的元素添加class属性，参数是class属性值，可以连缀
 **/
feng_zhuang_ku.prototype.tian_jia_class = function (classname) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (hasClass(this.jie_dian[i], classname)) {   //hasClass()函数库函数，判断一个元素的class属性值是否存在
            this.jie_dian[i].className += ‘ ‘ + classname;
        }
    }
    return this;
};

/** yi_chu_class()方法，给获取到的元素移除class属性，参数是要移除的class属性值，可以连缀
 **/
feng_zhuang_ku.prototype.yi_chu_class = function (classname) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        if (hasClass(this.jie_dian[i], classname)) {
            this.jie_dian[i].className = this.jie_dian[i].className.replace(new RegExp(‘(\\s|^)‘ + classname + ‘(\\s|$)‘), ‘ ‘);
        }
    }
    return this;
};

/** she_zhi_link_css()方法，设置link连接、或style内嵌、中的CSS样式
 * 在Web应用中，很少用到添加CSS规则和移除CSS规则，一般只用行内和Class；因为添加和删除原本的规则会破坏整个CSS的结构，所以使用需要非常小心。
 * 直接在库对象下使用  如：$().she_zhi_link_css()
 * 四个参数：
 * 参数1，样式表索引位置，就是要操作的样式表位置索引，第几个样式表【数值】
 * 参数2，要添加的选择器名称，【字符串】
 * 参数3，要添加的样式名称和值，如：background:#ff2a16 【字符串】
 * 参数4，将样式和选择器添加到样式表什么位置，【数值】
 **/
feng_zhuang_ku.prototype.she_zhi_link_css = function (num, selectorText, cssText, position) {
    var sheet = document.styleSheets[num];
    if (typeof sheet.insertRule != ‘undefined‘) {
        sheet.insertRule(selectorText + "{" + cssText + "}", position);
    } else if (typeof sheet.addRule != ‘undefined‘) {
        sheet.addRule(selectorText, cssText, position);
    }
    return this;
};

/** yi_chu_link_css()方法，移除link连接、或style内嵌、中的CSS样式
 * 在Web应用中，很少用到添加CSS规则和移除CSS规则，一般只用行内和Class；因为添加和删除原本的规则会破坏整个CSS的结构，所以使用需要非常小心。
 * 直接在库对象下使用
 * 两个参数：
 * 参数1，样式表索引位置，就是要操作的样式表位置索引，第几个样式表【数值】
 * 参数2，删除样式表里的第几个选择器【数值】
 **/
feng_zhuang_ku.prototype.yi_chu_link_css = function (num, position) {
    var sheet = document.styleSheets[num];
    if (typeof sheet.deleteRule != ‘undefined‘) {
        sheet.deleteRule(position);
    } else if (typeof sheet.removeRule) {
        sheet.removeRule(position);
    }
    return this;
};


/** tuo_zhuai()方法，将一个弹窗元素实现拖拽功能
 * 注意：有参设置拖拽点区块，只有弹窗的这个拖拽点区块才能拖拽，无参整个弹窗可以拖拽
 * 注意：一般需要在css文件将弹窗元素里的某一个区块光标设置成提示可以拖拽，如：cursor: move; （设置拖拽点）
 * 有一个参数，参数是弹窗元素里的拖拽点区块的字符串class值（设置拖拽点的class值）设置后弹窗元素里的这个拖拽点区块才能拖拽
 **/
feng_zhuang_ku.prototype.tuo_zhuai = function (tuo_zhuai_dian) {
    if (this.jie_dian.length == 1) {
        var yan_su = null;
        var sum = arguments.length;
        for (var i = 0; i < this.jie_dian.length; i++) {
            yan_su = this.jie_dian[i];
        }
        addEvent(yan_su, ‘mousedown‘, function (e) {
            if (trim(yan_su.innerHTML).length == 0)e.preventDefault();
            var e1 = getEvent(e);  //getEvent()函数库函数，跨浏览器获取事件对象,事件event对象,
            var diffx = e1.clientX - yan_su.offsetLeft;
            var diffy = e1.clientY - yan_su.offsetTop;
            if (sum == 1) {
                if (e.target.className === tuo_zhuai_dian) {
                    addEvent(document, ‘mousemove‘, move);
                    addEvent(document, ‘mouseup‘, up);
                }
            } else if (sum == 0) {
                addEvent(document, ‘mousemove‘, move);
                addEvent(document, ‘mouseup‘, up);
            }
            function move(e) {
                var e2 = getEvent(e);
                var left = e2.clientX - diffx;
                var top = e2.clientY - diffy;
                if (left < 0) {
                    left = 0;
                }else if(left <= gun_dong_tiao_wei_zhi().left){
                    left = gun_dong_tiao_wei_zhi().left;
                }else if (left > getInner().width + gun_dong_tiao_wei_zhi().left - yan_su.offsetWidth) {
                    left = getInner().width + gun_dong_tiao_wei_zhi().left - yan_su.offsetWidth;
                }
                if (top < 0) {
                    top = 0;
                }else if(top <= gun_dong_tiao_wei_zhi().top){
                    top = gun_dong_tiao_wei_zhi().top;
                }else if (top > getInner().height + gun_dong_tiao_wei_zhi().top - yan_su.offsetHeight) {
                    top = getInner().height + gun_dong_tiao_wei_zhi().top - yan_su.offsetHeight;
                }
                yan_su.style.left = left + ‘px‘;
                yan_su.style.top = top + ‘px‘;
                if (typeof yan_su.setCapture != ‘undefined‘) {
                    yan_su.setCapture();
                }
            }

            function up() {
                removeEvent(document, ‘mousemove‘, move);
                removeEvent(document, ‘mouseup‘, up);
                if (typeof yan_su.releaseCapture != ‘undefined‘) {
                    yan_su.releaseCapture();
                }
            }
        });
    } else {
        alert("将一个弹窗元素实现拖拽功能,只能设置一个弹窗元素，目前jie_dian数组里是多个元素请检查！")
    }
    return this;
};
/**------------------------------------------------元素节点操作结束--------------------------------------------**/


/**------------------------------------------------元素事件开始--------------------------------------------**/

/** shu_biao_yi_ru_yi_chu()方法，给元素设置鼠标移入移出事件，接收两个参数，参数是移入和移出时的执行函数(包含代码)
 *参数1是移入时的执行函数(包含代码)
 *参数2是移出时的执行函数(包含代码)
 **/
feng_zhuang_ku.prototype.shu_biao_yi_ru_yi_chu = function (yi_ru, yi_chu) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        addEvent(this.jie_dian[i], ‘mouseover‘, yi_ru);
        addEvent(this.jie_dian[i], ‘mouseout‘, yi_chu);
    }
    return this;
};

/** xian_shi()方法，设置元素显示,无参
 **/
feng_zhuang_ku.prototype.xian_shi = function () {
    for (var i = 0; i < this.jie_dian.length; i++) {
        this.jie_dian[i].style.display = ‘block‘;
    }
    return this;
};

/** yin_cang()方法，设置元素隐藏,无参
 **/
feng_zhuang_ku.prototype.yin_cang = function () {
    for (var i = 0; i < this.jie_dian.length; i++) {
        this.jie_dian[i].style.display = ‘none‘;
    }
    return this;
};

/** yuan_su_shi_jian()方，给元素添加一个元素事件
 *  两个参数，参数1事件名称不加on，参数2事件函数
 **/
feng_zhuang_ku.prototype.yuan_su_shi_jian = function (ming_cheng,fn) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        addEvent(this.jie_dian[i],ming_cheng, fn);
    }
    return this;
};

/** on_click()方法，给获取到的元素添加一个点击事件，参数是一个匿名函数（包含函数功能），
 * 循环jie_dian属性里的节点，将每次循环的节点添加元素点击事件
 **/
feng_zhuang_ku.prototype.on_click = function (fu) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        addEvent(this.jie_dian[i], ‘click‘, fu);
    }
    return this;
};

/** dian_ji_qie_huan()方法，设置点击切换，将元素设置成点击切换，也就是点击目标元素后，循环执行方法里的函数
 * 参数是点击后要执行的函数，可以是多个函数，点击一次循环执行一个函数，从第一个开始，循环完毕后再次循环从第一个开始
 **/
feng_zhuang_ku.prototype.dian_ji_qie_huan = function () {
    for (var i = 0; i < this.jie_dian.length; i++) {
        (function (jiedian, args) {
            var count = 0;                                          //计数器
            addEvent(jiedian, ‘click‘, function () {                //给对象添加点击事件
                args[count++ % args.length].call(this);             //点击后计数器数值求于作为下标执行传入的函数，计数器在累加,将对象传入
            });
        })(this.jie_dian[i], arguments);                            //通过arguments接收传入方法的函数
    }
    return this;
};

/** yuan_su_ju_zhong()方法，将获取到的区块元素居中到页面，
 * 注意：使用此方法时，首先要在css里将目标区块设置成(绝对定位,position: absolute;)
 **/
feng_zhuang_ku.prototype.yuan_su_ju_zhong = function () {
    if (this.jie_dian.length == 1) {
        var yan_su = null;
        for (var i = 0; i < this.jie_dian.length; i++) {
            yan_su = this.jie_dian[i];
        }
        var y_style = getStyle(yan_su, ‘display‘); //getStyle()函数库函数，跨浏览器获取元素Style，样式指定属性
        if (y_style === "none") {
            yan_su.style.display = "block";
        }
        var width = yan_su.offsetWidth;
        var height = yan_su.offsetHeight;
        if (y_style === "none") {
            yan_su.style.display = "none";
        }
        var chang_w = getInner().width;
        var chang_h = getInner().height;
        var top = (chang_h - height) / 2 + gun_dong_tiao_wei_zhi().top;
        var left = (chang_w - width) / 2 + gun_dong_tiao_wei_zhi().left;
        for (var ii = 0; ii < this.jie_dian.length; ii++) {
            this.jie_dian[ii].style.top = top + ‘px‘;
            this.jie_dian[ii].style.left = left + ‘px‘;
        }
    } else {
        alert("区块元素页面居中,只能设置一个区块元素，目前jie_dian数组里是多个元素请检查！")
    }
    return this;
};

/** chuang_kou_shi_jian()方法，浏览器窗口事件，当窗口的大小变化时触发函数
 * 接收一个参数，就是触发时要执行的函数（包含函数功能）
 **/
feng_zhuang_ku.prototype.chuang_kou_shi_jian = function (fn) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        var yan_su = this.jie_dian[i];
    }
    addEvent(window, ‘resize‘, function () {
        fn();
        if (yan_su.offsetLeft > getInner().width + gun_dong_tiao_wei_zhi().left - yan_su.offsetWidth) {
            yan_su.style.left = getInner().width + gun_dong_tiao_wei_zhi().left - yan_su.offsetWidth + ‘px‘;
            if (yan_su.offsetLeft <= 0 + gun_dong_tiao_wei_zhi().width){
                yan_su.style.left = 0 + gun_dong_tiao_wei_zhi().left + ‘px‘;
            }
        }
        if (yan_su.offsetTop > getInner().height + gun_dong_tiao_wei_zhi().top - yan_su.offsetHeight) {
            yan_su.style.top = getInner().height + gun_dong_tiao_wei_zhi().top - yan_su.offsetHeight + ‘px‘;
            if (yan_su.offsetTop <= 0 + gun_dong_tiao_wei_zhi().top){
                yan_su.style.top = 0 + gun_dong_tiao_wei_zhi().top + ‘px‘;
            }
        }
    });
    return this;
};

/** zhe_zhao_suo_ping()方法，将一个区块元素设置成遮罩锁屏区块
 * 注意：一般需要在css文件将元素设置成隐藏
 **/
feng_zhuang_ku.prototype.zhe_zhao_suo_ping = function () {
    if (this.jie_dian.length == 1) {
        var yan_su = null;
        for (var i = 0; i < this.jie_dian.length; i++) {
            yan_su = this.jie_dian[i];
        }
        fixedScroll.top = gun_dong_tiao_wei_zhi().top;
        fixedScroll.left = gun_dong_tiao_wei_zhi().left;
        var chang_w = getInner().width;  //getInner()函数库函数，跨浏览器获取浏览器视窗大小
        var chang_h = getInner().height;
        yan_su.style.width = chang_w + gun_dong_tiao_wei_zhi().left + ‘px‘;
        yan_su.style.height = chang_h + gun_dong_tiao_wei_zhi().top + ‘px‘;
        yan_su.style.position = ‘absolute‘;
        yan_su.style.top = ‘0‘;
        yan_su.style.left = ‘0‘;
        var y_style = getStyle(yan_su, ‘display‘); //getStyle()函数库函数，跨浏览器获取元素Style，样式指定属性
        if (y_style === "block") {
            addEvent(window, ‘scroll‘, fixedScroll);  //定位滚动条
            gdt_cao_zuo(‘y‘);  //隐藏滚动条
        }
    } else {
        alert("遮罩锁屏区块,只能设置一个区块元素，目前jie_dian数组里是多个元素请检查！")
    }
    return this;
};

/** jie_chu_suo_ping()方法，将一个锁屏区块元素解除锁屏
 * 注意：一般需要在css文件将元素设置成隐藏
 **/
feng_zhuang_ku.prototype.jie_chu_suo_ping = function () {
    for (var i = 0; i < this.jie_dian.length; i++) {
        this.jie_dian[i].style.display = ‘none‘;
    }
    removeEvent(window, ‘scroll‘, fixedScroll);  //删除定位滚动条
    gdt_cao_zuo(‘x‘);  //显示滚动条
    return this;
};

/**------------------------------------------------元素事件结束--------------------------------------------**/


/**------------------------------------------------元素动画开始--------------------------------------------**/
/**
 * 元素动画说明
 * yi_dong_tou_ming()方法，将一个元素，
 * 1，x将元素横向左移动或者右移动
 * 2, y将元素竖向上移动或者下移动
 * 3，w将元素动画增加或者减少宽度
 * 4，h将元素动画增加或者减少高度
 * 5，o将元素动画增加或者减少透明度
 * 注意：也可以写其他css属性名称（全称），来动画增加或者减少css属性的数值，必须是值为数值的css属性，如：font-size
 * *******************************************
 *
 **/




/** yi_dong_tou_ming()方法，动态改变css属性说明
 * * yi_dong_tou_ming()方法，将一个元素，进行一下动画操作
 * 1，x将元素横向左移动或者右移动
 * 2, y将元素竖向上移动或者下移动
 * 3，w将元素动画增加或者减少宽度
 * 4，h将元素动画增加或者减少高度
 * 5，o将元素动画增加或者减少透明度
 * 注意：也可以写其他css属性名称（全称），来动画增加或者减少css属性的数值，必须是值为数值的css属性，如：font-size
 * *************************************
 *  x将元素横向左移动或者右移动，首先将目标设置定位，position:absolute;
 *  o将元素动画增加或者减少透明度，结合css里元素原始透明度filter: alpha(opacity=0);opacity: 0;
 *  *************************************
 *  yi_dong_tou_ming()方法，参数说明
 *  参数是一个对象如下
 *  yi_dong_tou_ming({
            ‘attr‘:‘x‘,        【为动画方式】，   x.为横向移动，y.为竖向移动，w.为增加宽度动画，h.为增加高度动画，o.为透明度动画，【必填】
                                                  注意：也可以写其他css属性名称（全称），来动画增加或者减少css属性的数值，必须是值为数值的css属性，如：font-size
                                                  o.为透明度动画,设置透明度动画时，必须先在css里设置初始透明度如：opacity:1;filter:alpha(opacity=100);
                                                  否则IE9以下无法实现透明度动画

            ‘type‘:‘1‘,        【动画模式】，     0.匀速模式，1.缓冲模式【可选，默认缓冲】
            ‘speed‘:6,         【缓冲速度】，     动画模式为缓冲时设置，【可选，默认为6】,以此值改变跨度.每一次动画动态增加或者减少，实现缓冲效果

            ‘start‘:50,        【动画起始位置】， 起始的像素或者透明度【可选，默认为对象原始位置】一般不需要传
                                                  注意：动画起始位置，一般按钮动画使用，如果是鼠标触动动画，会不停的初始化，因为鼠标一动就改变了动画起始位置

            ‘target‘:100,      【目标量】，       就是在原始的像素或者透明度上，增加或者减少到目标量的像素或者透明度【可先，注意目标量不填，增量必填】
            ‘alter‘:50,        【增量】，         就是在对象原始的像素或者透明度上，增加或者减少像素或者透明度【可先，注意增量不填，目标量必填】
            ‘step‘:7,          【跨度】，         每一次动画增加或者减少的，像素或者透明度,【可选，默认20】
            ‘danwei‘:‘em‘,     【属性值单位】     danwei.为属性值单位，也就是以什么单位来计算css属性，如是px还是em等，不传默认px
            ‘t‘:50 ,           【每次动画时间】， 也就是多少毫秒执行一次动画【可选，默认10】
            fn:function () {   【回调函数，列队】， 回调函数，用于动画执行完毕后执行函数，在回调函数里在写入动画，就是列队动画，也就是一个动画执行完毕后执行第二个动画

            }
            mul:{              【同步动画对象】，用于同时要执行多个动画，同步动画属性，属性值为对象，对象里面是，动画方式:目标量，组合的键值对，只能动画方式加目标量的键值对
                                同步动画，除了动画方式和目标量外，其他的都是在同步动画对象外设置，因为他们是统一的其他参数
                ‘w‘:101,
                ‘h‘:500,
                ‘o‘:30
            }
        });
 **/
feng_zhuang_ku.prototype.yi_dong_tou_ming = function (obj) {
    for (var i = 0; i < this.jie_dian.length; i++) {
        var element = this.jie_dian[i];
         // attr，为动画方式，
         // x.为横向移动
         // y.为竖向移动
         // w.为增加宽度动画
         // h.为增加高度动画
         // o.为透明度动画
        var attr = obj[‘attr‘] == ‘x‘ ? ‘left‘ : obj[‘attr‘] == ‘y‘ ? ‘top‘ :
            obj[‘attr‘] == ‘w‘ ? ‘width‘ : obj[‘attr‘] == ‘h‘ ? ‘height‘ :
                obj[‘attr‘] == ‘o‘ ? ‘opacity‘ : obj[‘attr‘] != undefined ? obj[‘attr‘] : ‘left‘;

        // start.为动画起始位置，
        // 如果输入了动画起始位置，值就为输入的起始位置，移动动画是像素值（如100），透明度动画是透明度百分比（如50）
        // 如果没输入，默认移动动画获取的对象原始像素位置，透明度动画获取的对象原始透明度，除以100等于原始透明度百分比
        var start = obj[‘start‘] != undefined ? obj[‘start‘] :
            attr == ‘opacity‘ ? parseFloat(getStyle(element, attr)) * 100 :
                parseInt(getStyle(element, attr));

         // t.为每次动画时间，也就是多少毫秒执行一次动画
         // 不传默认，是10毫秒执行一次动画
        var t = obj[‘t‘] != undefined ? obj[‘t‘] : 10;

         // step.为跨度，每一次动画增加或者减少的，像素或者透明度
        var step = obj[‘step‘] != undefined ? obj[‘step‘] : 20;

        // danwei.为属性值单位，也就是以什么单位来计算css属性，如是px还是em等，不传默认px
        var danwei = obj[‘danwei‘] != undefined ? obj[‘danwei‘] : ‘px‘;

         // alter.为增量，就是在对象原始的像素或者透明度上，增加或者减少像素或者透明度
        var alter = obj[‘alter‘];

         // target.为目标量，就是在原始的像素或者透明度上，增加或者减少到目标量的像素或者透明度
         // 注意，增量，是在原始上增加或者减少多少，目标量是在原始的基础上增加或者减少到目标
        var target = obj[‘target‘];

        //mul,接收的，obj对象里的mul属性，而mul属性是一个对象，由动画方式加目标量组合的键值对，也就是要同步动画的参数
        var mul = obj[‘mul‘];    //接收同步动画（参数对象）

         // speed.为缓冲速度，动画模式为缓冲时，以此值改变step.每一次动画动态增加或者减少，实现缓冲效果
         // 不传，默认为6
        var speed = obj[‘speed‘] != undefined ? obj[‘speed‘] : 6;

         // type.为动画模式，匀速为匀速模式，缓冲为缓冲模式
         // 不传，默认为缓冲模式
        var type = obj[‘type‘] == 0 ? ‘constant‘ : obj[‘type‘] == 1 ? ‘buffer‘ : ‘buffer‘;

        if (alter != undefined && target == undefined) {
            target = alter + start;
        } else if (alter == undefined && target == undefined && mul == undefined) {
            throw new Error(‘alter增量，或target目标量，或者同步动画对象，必须传一个！‘);
        }
        if (start > target) step = -step;

        if (!isNaN(start)) {
            if (attr == ‘opacity‘) {
                element.style.opacity = parseInt(start) / 100;
                element.style.filter = ‘alpha(opacity=‘ + parseInt(start) + ‘)‘;
            } else {
                element.style[attr] = start + danwei;
            }
        }

        if (mul == undefined){      //判断如果同步动画对象没有传，说明是单个动画
            mul = {};               //创建mul对象
            mul[attr] = target;     //将单个动画的，动画方式当作对象键，将目标量当作值，组合成键值对到对象里
        }

        clearInterval(element.timer);                            //给对每个象创建定时器并停止定时器
        element.timer = setInterval(function () {               //将对象下的定时器开启
            //创建一个布尔值，这个值可以了解对个动画是否执行完毕
            var flag = true;    //表示都执行完毕了

            //循环同步动画对象
            for (var i in mul) {
                attr = i == ‘x‘ ? ‘left‘ : i == ‘y‘ ? ‘top‘ :
                    i == ‘w‘ ? ‘width‘ : i == ‘h‘ ? ‘height‘ :
                        i == ‘o‘ ? ‘opacity‘ : i != undefined ? i : ‘left‘;            //得到同步动画对象里的，动画方式
                target = mul[i];                                                       //得到同步动画对象里的，目标量

                if (type == ‘buffer‘) {
                    step = attr == ‘opacity‘ ? (target - parseFloat(getStyle(element, attr)) * 100) / speed :
                    (target - parseInt(getStyle(element, attr))) / speed;
                    step = step > 0 ? Math.ceil(step) : Math.floor(step);
                }
                if (attr == ‘opacity‘) {
                    if (step == 0) {
                        setOpacity();
                    } else if (step > 0 && Math.abs(parseFloat(getStyle(element, attr)) * 100 - target) <= step) {
                        setOpacity();
                    } else if (step < 0 && (parseFloat(getStyle(element, attr)) * 100 - target) <= Math.abs(step)) {
                        setOpacity();
                    } else {
                        var temp = parseFloat(getStyle(element, attr)) * 100;
                        element.style.opacity = parseInt(temp + step) / 100;
                        element.style.filter = ‘alpha(opacity=‘ + parseInt(temp + step) + ‘)‘;
                    }
                    //判断目标值不等于元素当前值，说明动画还没到达目标值，将flag修改成false
                    if (parseInt(target) !=  parseInt(parseFloat(getStyle(element, attr)) * 100)) flag = false;
                } else {
                    if (step == 0) {
                        setTarget();
                    } else if (step > 0 && Math.abs(parseInt(getStyle(element, attr)) - target) <= step) {
                        setTarget();
                    } else if (step < 0 && (parseInt(getStyle(element, attr)) - target) <= Math.abs(step)) {
                        setTarget();
                    } else {
                        element.style[attr] = parseInt(getStyle(element, attr)) + step + danwei;
                    }
                    //判断目标值不等于元素当前值，说明动画还没到达目标值，将flag修改成false
                    if (parseInt(target) != parseInt(getStyle(element, attr))) flag = false;
                }
            }
            //判断flag = true;了说明元素的当前值已经达到目标值，可以停止定时器了
            if (flag) {
                clearInterval(element.timer);       //停止定时器
                if (obj.fn != undefined)obj.fn();   //判断如果传入了回调函数，动画执行完毕后执行回调函数,列队动画
            }
        }, t);
        function setTarget() {
            element.style[attr] = target + danwei;
        }
        function setOpacity() {
            element.style.opacity = parseInt(target) / 100;
            element.style.filter = ‘alpha(opacity=‘ + parseInt(target) + ‘)‘;
        }
    }
    return this;
};
/**------------------------------------------------元素动画结束--------------------------------------------**/


/**------------------------------------------------插件入口开始--------------------------------------------**/
/** 插件入口，简单的理解就是通过extend()方法，向此基础库添加一个原型方法
 *  此extend()方法，一般是给插件文件使用的，插件就是通过extend()方法，将插件方法添加到基础库原型的
 *  接收两个参数
 *  参数1是传入要添加的方法名称
 *  参数2是此方法的执行函数（包含代码）
 *  使用方法：$().ext_end(方法名称，方法匿名函数)
 *
 **/
feng_zhuang_ku.prototype.ext_end = function (name, fn) {
    feng_zhuang_ku.prototype[name] = fn;
};
/**------------------------------------------------插件入口结束--------------------------------------------**/


/**------------------------------------------------ajax通讯开始--------------------------------------------**/

/** ajax()方法，ajax通讯方法，跨页面向动态页面发送或获取数据
 *  参数是一个对象{}，如下
 *  $().ajax({
            method:‘post‘,                  【method】属性，通讯模式，post为post模式，get为get模式
            url:‘hj.php‘,                   【url】属性，发送数据或请求数据的url地址
            data:{                          【data】属性，是发送内容，是一个对象，里面是键值对形式的发送数据对象
                ‘name‘:‘lee‘,
                ‘age‘:100
            },
            success:function (text) {       【success】属性，是一个回调函数，函数参数是text，会接收到发送或者获取到的数据
                alert(text);
            },
            async:true                      【async】属性，请求方式，true异步方式，false同步方式
        });
 **/
feng_zhuang_ku.prototype.Ajax = function (obj) {
    //注意：引入了开源库json2，如果浏览器版本太低不支持JSON对象，通过一个开源库json2来模拟执行，如果支持JSON对象就用JSON对象
    //开源库json2写在函数库里
    //创建XHR对象
    var xhr = (function () {
        if (typeof XMLHttpRequest != ‘undefined‘) {           //判断是否可以直接创建XHR对象，w3c
            return new XMLHttpRequest();                      //如果可以就直接创建XHR对象
        } else if (typeof ActiveXObject != ‘undefined‘) {     //判断IE低版本的3种模式是否支持
            var version = [
                ‘MSXML2.XMLHttp.6.0‘,
                ‘MSXML2.XMLHttp.3.0‘,
                ‘MSXML2.XMLHttp‘
            ];
            for (var i = 0; version.length; i++) {
                try {
                    return new ActiveXObject(version[i]);
                } catch (e) {
                    //跳过
                }
            }
        } else {
            throw new Error(‘您的系统或浏览器不支持XHR对象！‘);   //如果都不支持报错
        }
    })();  //自我执行闭包里的函数,创建XHR对象

    //接收对象url地址
    obj.url = obj.url + ‘?rand=‘ + Math.random();                 //组合对象传进来的通讯url地址

    //接收对象传来的内容，进行名值对编码
    obj.data = http://www.mamicode.com/(function (data) {
        var arr = [];
        for (var i in data) {
            arr.push(encodeURIComponent(i) + ‘=‘ + encodeURIComponent(data[i]));
        }
        return arr.join(‘&‘);  //将数组格式化分隔符后返回
    })(obj.data);  //自我执行闭包里的函数

    //判断请求方式来
    if (obj.method === ‘get‘) obj.url += obj.url.indexOf(‘?‘) == -1 ? ‘?‘ + obj.data : ‘&‘ + obj.data;

    //判断发送模式如果是异步
    if (obj.async === true) {
        //添加一个加载事件
        xhr.onreadystatechange = function () {
            //判断已经接受到全部响应数据，而且可以使用
            if (xhr.readyState == 4) {
                callback();
            }
        };
    }
    xhr.open(obj.method, obj.url, obj.async);
    if (obj.method === ‘post‘) {
        xhr.setRequestHeader(‘Content-Type‘, ‘application/x-www-form-urlencoded‘);
        xhr.send(obj.data);
    } else {
        xhr.send(null);
    }
    if (obj.async === false) {
        callback();
    }
    function callback() {
        if (xhr.status == 200) {
            obj.success(xhr.responseText);            //回调传递参数
        } else {
            alert(‘获取数据错误！错误代号：‘ + xhr.status + ‘，错误信息：‘ + xhr.statusText);
        }
    }
    return this;
};
/**------------------------------------------------ajax通讯结束--------------------------------------------**/


/**------------------------------------------------表单序列化开始--------------------------------------------**/

/** xu_lie_biao_dan()方法，表单序列化方法，将自动获取指定表单里面的各项字段name值和value值，无法连缀
 *  参数是要获取指定表单的原生态对象
 *  返回，包含表单数据的对象，如，{表单数据}
 **/
feng_zhuang_ku.prototype.xu_lie_biao_dan = function (form) {
    var parts = {};
            for (var i = 0; i < form.elements.length; i++) {    //根据表单字段长度循环
                var filed = form.elements[i];                   //得到没一项表单的字段
                switch (filed.type) {                           //判断得到字段的属性
                    case undefined:
                    case ‘submit‘:
                    case ‘reset‘:
                    case ‘file‘:
                    case ‘button‘:
                        break;                                   //如果是以上几种的一种直接跳出
                    case ‘radio‘:
                    case ‘checkbox‘:
                        if (!filed.selected) break;              //如果是以上两种，判断是否被勾选，没勾选直接跳出
                    case ‘select-one‘:
                    case ‘select-multiple‘:
                        for (var j = 0; j < filed.options.length; j++) {     //下拉选项
                            var option = filed.options[j];
                            if (option.selected) {
                                var optvalue = http://www.mamicode.com/‘‘;
                                if (option.hasAttribute) {                   //非ie
                                    optvalue = http://www.mamicode.com/(option.hasAttribute(‘value‘) ? option.value : option.text);             //value值存在取value值，value值不存在取text值
                                } else {  //ie
                                    optvalue = http://www.mamicode.com/(option.attributes(‘value‘).specified ? option.value : option.text);     //value值存在取value值，value值不存在取text值
                                }
                                parts[filed.name] = optvalue;                                                           //如果不是以上情况，将表单字段的name值加上value值，添加到对象
                            }

                        }
                        break;
                    default:
                        parts[filed.name] = filed.value;                                                                //如果不是以上情况，将表单字段的name值加上value值，添加到对象
                }
            }
            return parts;
};

/**------------------------------------------------表单序列化结束--------------------------------------------**/







/**█████████████████████████████████████████████████函数库██████████████████████████████████████████████████████**/

/** 函数库说明：
 * sys浏览器检测对象，对象下有8个属性
 * dom_jia_zai()函数，DOM页面加载函数，等待页面结构加载完毕后就执行函数，不需要等待页面音频视频等文件加载完毕，提高加载速度
 * addEvent()函数库函数，跨浏览器添加事件绑定,注意：传入事件名称时不要on
 * removeEvent()函数库函数，跨浏览器删除事件绑定,注意：传入事件名称时不要on
 * getInner()函数库函数，跨浏览器获取浏览器视窗大小
 * gun_dong_tiao_wei_zhi()函数库函数，获取滚动条头部与浏览器头部的位置，获取底部滚动条与浏览器左边的位置
 * ju_li_liu_lan_qi_tou()函数库函数，跨浏览器获取当前元素的头部与浏览器头部的位置是多少
 * getStyle()函数库函数，跨浏览器获取元素Style，样式指定属性
 * hasClass()函数库函数，判断一个元素的class属性值是否存在
 * yuan_su_da_xiao()函数库函数，获取指定元素的绝对大小（包含边框）
 * getEvent()函数库函数，跨浏览器获取事件对象,事件event对象,
 * preDef()函数库函数，阻止事件默认行为,
 * trim()函数库函数，删除字符串的前后空格
 * scrollTop()函数库函数，滚动条清零，使滚动条无法下拉
 * gdt_cao_zuo()函数库函数，显示和隐藏浏览器滚动条
 * fixedScroll()函数库函数，定位滚动条
 * pd_shuzu()函数库函数，判断一个类容是否存在一个数组中，返回布尔值
 * sh_jd_suo_yin()函数库函数，获取当前节点的上一个节点，在父元素的索引
 * xia_jd_suo_yin()函数库函数，获取当前节点的下一个节点，在父元素的索引
 **/
/**-----------------------------------------------------------------------------------------------------------------**/

/** sys浏览器检测对象，对象下有8个属性
 * liu_lan_qi属性，检测浏览器名称和版本号，如：alert(sys.liu_lan_qi);
 * xi_tong属性，检测浏览器运行环境，如：alert(sys.xi_tong);
 * ie属性，检测IE浏览器的版本号，返回IE浏览器的版本号
 * firefox属性，检测firefox浏览器的版本号，返回firefox浏览器的版本号
 * chrome属性，检测chrome浏览器的版本号，返回chrome浏览器的版本号
 * opera属性，检测opera浏览器的版本号，返回opera浏览器的版本号
 * safari属性，检测safari浏览器的版本号，返回safari浏览器的版本号
 * webkit属性，检测webkit浏览器的版本号，返回webkit浏览器的版本号
 **/
(function () {                       //闭包，自我执行
    window.sys = {};                  //全局变量对象，保存浏览器信息
    var ua = navigator.userAgent.toLowerCase();           //获取浏览器信息，并转化成小写
    var s = [];                                           //浏览器信息数组
    /**判断IE浏览器**/
    if ((/msie ([\d.]+)/).test(ua)) {                      //IE10以下判断字段为：msie x版本号
        s = ua.match(/msie ([\d.]+)/);                    //如果有获取到msie x版本号返回数组
        sys.liu_lan_qi = ‘浏览器为IE：‘ + s[1];            //向sys对象添加liu_lan_qi属性，属性值等于获取到的数组第二个元素
        sys.ie = s[1];
    } else if ((/trident/).test(ua)) {                      //ie10以上判断字段为：trident
        s = ua.match(/rv:([\d.]+)/);                      //如果有获取到trident字段返回数组
        sys.liu_lan_qi = ‘浏览器为IE：‘ + s[1];
        sys.ie = s[1];
    }
    /**判断火狐浏览器**/
    if ((/firefox\/([\d.]+)/).test(ua)) {                  //火狐判断字段为：firefox
        s = ua.match(/firefox\/([\d.]+)/);
        sys.liu_lan_qi = ‘浏览器为firefox：‘ + s[1];
        sys.firefox = s[1];
    }
    /**判断谷歌浏览器**/
    if ((/chrome\/([\d.]+)/).test(ua)) {                    //谷歌判断字段为：chrome
        s = ua.match(/chrome\/([\d.]+)/);
        sys.liu_lan_qi = ‘浏览器为chrome：‘ + s[1];
        sys.chrome = s[1];
    }
    /**判断Opera浏览器**/
    if ((/opera\/.*version\/([\d.]+)/).test(ua)) {         //谷歌判断字段为：opera 与 version
        s = ua.match(/opera\/.*version\/([\d.]+)/);
        sys.liu_lan_qi = ‘浏览器为Opera：‘ + s[1];
        sys.opera = s[1];
    }
    /**判断safari浏览器**/
    if ((/version\/([\d.]+).*safari/).test(ua)) {         //谷歌判断字段为：version 与 safari
        s = ua.match(/version\/([\d.]+).*safari/);
        sys.liu_lan_qi = ‘浏览器为Opera：‘ + s[1];
        sys.safari = s[1];
    }
    /**判断webkit浏览器**/
    if ((/webkit/).test(ua)) {                  //webkit判断字段为：webkit
        s = ua.match(/webkit\/([\d.]+)/);
        sys.liu_lan_qi = ‘浏览器为webkit：‘ + s[1];
        sys.webkit = s[1];
    }
    /**判断系统**/
    if (Boolean(navigator.platform)) {
        sys.xi_tong = ‘环境系统为：‘ + navigator.platform;
    } else {
        alert("无法检测到环境系统")
    }
})();

/** dom_jia_zai()函数，DOM页面加载函数，等待页面结构加载完毕后就执行函数，不需要等待页面音频视频等文件加载完毕，提高加载速度
 * 参数是页面结构加载完毕后要执行的函数
 * 一般前写前台js文件时，使用此方法加载DOM页面后执行代码，提高速度
 **/
function dom_jia_zai(fn) {
    var isReady = false;
    var timer = null;

    function doReady() {
        if (timer) clearInterval(timer);
        if (isReady) return;
        isReady = true;
        fn();
    }

    if ((sys.opera && sys.opera < 9) || (sys.firefox && sys.firefox < 3) || (sys.webkit && sys.webkit < 525)) {
        timer = setInterval(function () {
            if (document && document.getElementById && document.getElementsByTagName && document.body) {
                doReady();
            }
        }, 1);
    } else if (document.addEventListener) {//W3C
        addEvent(document, ‘DOMContentLoaded‘, function () {
            fn();
            removeEvent(document, ‘DOMContentLoaded‘, arguments.callee);
        });
    } else if (sys.ie && sys.ie < 9) {
        var timer = null;
        timer = setInterval(function () {
            try {
                document.documentElement.doScroll(‘left‘);
                doReady();
            } catch (e) {
            }
        }, 1);
    }
}


/** addEvent()函数库函数，跨浏览器添加事件绑定,注意：传入事件名称时不要on
 * 接收3个参数
 * 参数1要绑定事件的元素对象，
 * 参数2事件名称，也就是什么事件，注意：传入事件名称时不要on
 * 参数3接收的事件执行函数
 * 注意：一个元素对象，执行了多个相同的事件函数时只执行一次，其他的会被忽略，注意是相同的事件函数
 * 说明：
 * 事件函数里的this，代表绑定事件元素对象本身
 * 事件函数里有一个可选参数e,e接收的元素event对象，传入addEvent()后跨浏览器获取到元素event对象，将元素event对象赋值给e
 * 所以事件函数里的e,代表元素event对象，前提是首先要在事件函数传参e后，再在事件函数里调用e,得到元素event对象
 * e.preventDefault()方法，在事件函数里写e.preventDefault()方法，兼容浏览器阻止事件元素对象默认行为，前提在事件函数要传参e
 * e.stopPropagation()方法，在事件函数里写e.stopPropagation()方法，阻止元素对象的父级元素事件冒泡行为，前提在事件函数要传参e
 * e.target属性，在事件函数里写e.target属性，获取到事件对象元素的标签节点（包含一个事件对象里的子节点）
 **/
function addEvent(obj, type, fn) {
    if (typeof obj.addEventListener != ‘undefined‘) {
        obj.addEventListener(type, fn, false);
    } else {
        if (!obj.events) obj.events = {};                               //创建一个存放事件的哈希表(散列表)
        if (!obj.events[type]) {                                        //第一次执行时执行
            obj.events[type] = [];                                      //创建一个存放事件处理函数的数组
            if (obj[‘on‘ + type]) obj.events[type][0] = fn;             //把第一次的事件处理函数先储存到第一个位置上
        } else {
            if (addEvent.equal(obj.events[type], fn)) return false;    //同一个注册函数进行屏蔽，不添加到计数器中
        }
        obj.events[type][addEvent.ID++] = fn;                           //从第二次开始我们用事件计数器来存储
        obj[‘on‘ + type] = addEvent.exec;                               //执行事件处理函数
    }
}
/*-------------------------------------------------------------------------------------*/
//为每个事件分配一个计数器
//JS一切皆为对象，所以addEvent.ID语法正确，实际上是个全局变量
addEvent.ID = 1;
addEvent.exec = function (event) {                          //执行事件处理函数
    var e = event || addEvent.fixEvent(window.event);
    var es = this.events[e.type];
    for (var i in es) {
        es[i].call(this, e);
    }
};
addEvent.equal = function (es, fn) {                        //同一个注册函数进行屏蔽
    for (var i in es) {
        if (es[i] == fn) return true;
    }
    return false;
};
addEvent.fixEvent = function (event) {                      //把IE常用的Event对象配对到W3C中去
    event.preventDefault = addEvent.fixEvent.preventDefault;
    event.stopPropagation = addEvent.fixEvent.stopPropagation;
    event.target = event.srcElement;
    return event;
};
addEvent.fixEvent.preventDefault = function () {            //IE阻止默认行为
    this.returnValue = http://www.mamicode.com/false;
};
addEvent.fixEvent.stopPropagation = function () {           //IE取消冒泡
    this.cancelBubble = true;
};
/*---------------------------------------------------------------------------------------*/


/** removeEvent()函数库函数，跨浏览器删除事件绑定,注意：传入事件名称时不要on
 * 接收3个参数
 * 参数1接收事件绑定时的元素对象
 * 参数2接收事件绑定时的事件名称，也就是什么事件，注意：传入事件名称时不要on
 * 参数3接收事件绑定时的执行函数
 **/
function removeEvent(obj, type, fn) {
    if (typeof obj.removeEventListener != ‘undefined‘) {
        obj.removeEventListener(type, fn, false);
    } else {
        if (obj.events) {
            for (var i in obj.events[type]) {
                if (obj.events[type][i] == fn) {
                    delete obj.events[type][i];
                }
            }
        }
    }
}

/** getInner()函数库函数，跨浏览器获取浏览器视窗大小
 * 返回一个对象，里面有两个属性
 * width属性，代表浏览器视窗宽度
 * height属性，代表浏览器视窗高度
 **/
function getInner() {
    if (typeof window.innerWidth != ‘undefined‘) {
        return {
            width: window.innerWidth,
            height: window.innerHeight
        }
    } else {
        return {
            width: document.documentElement.clientWidth,
            height: document.documentElement.clientHeight
        }
    }
}

/** gun_dong_tiao_wei_zhi()函数库函数，获取滚动条头部与浏览器头部的位置，获取底部滚动条与浏览器左边的位置
 * 无参
 * 返回一个对象
 * 对象有两个属性
 * top，返回，滚动条头部与浏览器头部的位置
 * left，返回，滚动条底部与浏览器底部的位置
 **/
function gun_dong_tiao_wei_zhi() {
    return{
        top:document.documentElement.scrollTop || document.body.scrollTop,
        left:document.documentElement.scrollLeft || document.body.scrollLeft
    };
}

/** ju_li_liu_lan_qi_tou()函数库函数，跨浏览器获取当前元素的头部与浏览器头部的位置是多少
 *  参数是要获取的元素对象
 **/
function ju_li_liu_lan_qi_tou(element) {
    var top = element.offsetTop;
    var parent = element.offsetParent;
    while (parent != null){
        top += parent.offsetTop;
        parent = parent.offsetParent;
    }
    return top;
}

/** getStyle()函数库函数，跨浏览器获取元素Style，样式指定属性
 * 两个参数
 * 参数1接收元素对象
 * 参数2接收css样式名称
 * 返回指定元素的指定样式值
 **/
function getStyle(jie_dian, attr) {
    var value;
    if (typeof window.getComputedStyle != ‘undefined‘) {//W3C
        value = http://www.mamicode.com/window.getComputedStyle(jie_dian, null)[attr];
    } else if (typeof jie_dian.currentStyle != ‘undeinfed‘) {//IE
        value =http://www.mamicode.com/ jie_dian.currentStyle[attr];
    }
    return value;
}

/** hasClass()函数库函数，判断一个元素的class属性值是否存在
 * 两个参数
 * 参数1接收元素对象
 * 参数2接收class属性值
 * 返回指定元素的class属性值是否存在，
 **/
function hasClass(jie_dian, className) {
    return jie_dian.className.match(new RegExp(‘(\\s|^)‘ + className + ‘(\\s|$)‘));
}

/** yuan_su_da_xiao()函数库函数，获取指定元素的绝对大小（包含边框）
 * 接收一个参数，参数是元素对象
 * 返回一个对象，里面有两个属性
 * width属性，元素的宽度
 * height属性，元素的高度
 **/
function yuan_su_da_xiao(jie_dian) {
    return {
        width: jie_dian.offsetWidth,
        height: jie_dian.offsetHeight
    }
}

/** getEvent()函数库函数，跨浏览器获取事件对象,事件event对象,
 * 这个对象包含着所有与事件有关的信息。包括导致事件的元素、事件的类型、以及其它与特定事件相关的信息。
 * 接收一个参数，参数是事件函数的形式参数，也就是事件函数的形式参数接收到的event对象
 * 返回event对象,
 **/
function getEvent(event) {
    return event || window.event;
}

/** preDef()函数库函数，阻止事件默认行为,
 * 接收一个参数，参数是事件函数的形式参数，也就是事件函数的形式参数接收到的event对象
 **/
function preDef(event) {
    var e = getEvent(event);
    if (typeof e.preventDefault != ‘undefined‘) {//W3C
        e.preventDefault();
    } else {//IE
        e.returnValue = http://www.mamicode.com/false;
    }
}

/** trim()函数库函数，删除字符串的前后空格
 * 接收一个参数，参数是要删除前后空格的字符串
 **/
function trim(str) {
    return str.replace(/(^\s*)|(\s*$)/g, ‘‘);
}

/** scrollTop()函数库函数，滚动条清零，使滚动条无法下拉
 * 无参
 **/
function scrollTop() {
    document.documentElement.scrollTop = 0;
    document.body.scrollTop = 0;
}

/** gdt_cao_zuo()函数库函数，显示和隐藏浏览器滚动条
 * 有参，x为显示滚动条，y为隐藏滚动条
 **/
function gdt_cao_zuo(zhi) {
    if (zhi == ‘x‘){
        parseFloat(sys.firefox) < 4 ? document.body.style.overflow = ‘auto‘ : document.documentElement.style.overflow = ‘auto‘;
    }else if(zhi == ‘y‘){
        parseFloat(sys.firefox) < 4 ? document.body.style.overflow = ‘hidden‘ : document.documentElement.style.overflow = ‘hidden‘;
    }else {
        alert(‘gdt_cao_zuo()函数库函数,参数不正确‘);
    }
}

/** fixedScroll()函数库函数，定位滚动条
 *  fixedScroll.left参数，是外部通过fixedScroll属性方式传递的，如外部fixedScroll.left = getScroll().left;
 **/
function fixedScroll() {
    setTimeout(function () {
        window.scrollTo(fixedScroll.left, fixedScroll.top);
    }, 100);
}

/** pd_shuzu()函数库函数，判断一个类容是否存在一个数组中，返回布尔值
 * 参数1判断的数组，参数2判断的内容
 **/
function pd_shuzu(shuzu, value) {
    for (var i in shuzu) {
        if (shuzu[i] === value) return true;
    }
    return false;
}

/** sh_jd_suo_yin()函数库函数，获取当前节点的上一个节点，在父元素的索引
 *  参数1，当前元素在父元素的索引
 *  参数2，父元素原生对象
 *  如果当前索引是开始位置0，返回的总索引减一
 *  如果当前索引是结束位置，返回的当前索引减一
 **/
function sh_jd_suo_yin(suoy,fjid) {
    var length = fjid.children.length;    //获取父节点里所有子节点的长度
    if (suoy == 0) return length - 1;
    return parseInt(suoy) - 1;
}

/** xia_jd_suo_yin()函数库函数，获取当前节点的下一个节点，在父元素的索引
 *  参数1，当前元素在父元素的索引
 *  参数2，父元素原生对象
 *  如果当前索引是开始位置0，返回的当前索引减一
 *  如果当前索引是结束位置，返回0
 **/
function xia_jd_suo_yin(suoy,fjid) {
    var length = fjid.children.length;    //获取父节点里所有子节点的长度
    if (suoy == length - 1) return 0;
    return parseInt(suoy) + 1;
}

/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃开源库json2开始▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/

/** json2.js 开源库json2，
 *  如果浏览器版本太低不支持JSON对象，通过一个开源库json2.js来模拟执行，如果支持JSON对象就用JSON对象
 **/

if (typeof JSON !== ‘object‘) {
    JSON = {};
}
(function () {
    ‘use strict‘;
    function f(n) {
        return n < 10 ? ‘0‘ + n : n;
    }

    if (typeof Date.prototype.toJSON !== ‘function‘) {
        Date.prototype.toJSON = function (key) {
            return isFinite(this.valueOf())
                ? this.getUTCFullYear() + ‘-‘ +
            f(this.getUTCMonth() + 1) + ‘-‘ +
            f(this.getUTCDate()) + ‘T‘ +
            f(this.getUTCHours()) + ‘:‘ +
            f(this.getUTCMinutes()) + ‘:‘ +
            f(this.getUTCSeconds()) + ‘Z‘
                : null;
        };
        String.prototype.toJSON =
            Number.prototype.toJSON =
                Boolean.prototype.toJSON = function (key) {
                    return this.valueOf();
                };
    }
    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
        gap,
        indent,
        meta = {    // table of character substitutions
            ‘\b‘: ‘\\b‘,
            ‘\t‘: ‘\\t‘,
            ‘\n‘: ‘\\n‘,
            ‘\f‘: ‘\\f‘,
            ‘\r‘: ‘\\r‘,
            ‘"‘: ‘\\"‘,
            ‘\\‘: ‘\\\\‘
        },
        rep;

    function quote(string) {
        escapable.lastIndex = 0;
        return escapable.test(string) ? ‘"‘ + string.replace(escapable, function (a) {
            var c = meta[a];
            return typeof c === ‘string‘
                ? c
                : ‘\\u‘ + (‘0000‘ + a.charCodeAt(0).toString(16)).slice(-4);
        }) + ‘"‘ : ‘"‘ + string + ‘"‘;
    }

    function str(key, holder) {
        var i,          // The loop counter.
            k,          // The member key.
            v,          // The member value.
            length,
            mind = gap,
            partial,
            value = holder[key];
        if (value && typeof value =http://www.mamicode.com/== ‘object‘ &&"color: #0000ff">typeof value.toJSON === ‘function‘) {
            value = value.toJSON(key);
        }
        if (typeof rep === ‘function‘) {
            value = rep.call(holder, key, value);
        }
        switch (typeof value) {
            case ‘string‘:
                return quote(value);
            case ‘number‘:
                return isFinite(value) ? String(value) : ‘null‘;
            case ‘boolean‘:
            case ‘null‘:
                return String(value);
            case ‘object‘:
                if (!value) {
                    return ‘null‘;
                }
                gap += indent;
                partial = [];
                if (Object.prototype.toString.apply(value) === ‘[object Array]‘) {
                    length = value.length;
                    for (i = 0; i < length; i += 1) {
                        partial[i] = str(i, value) || ‘null‘;
                    }
                    v = partial.length === 0
                        ? ‘[]‘
                        : gap
                        ? ‘[\n‘ + gap + partial.join(‘,\n‘ + gap) + ‘\n‘ + mind + ‘]‘
                        : ‘[‘ + partial.join(‘,‘) + ‘]‘;
                    gap = mind;
                    return v;
                }
                if (rep && typeof rep === ‘object‘) {
                    length = rep.length;
                    for (i = 0; i < length; i += 1) {
                        if (typeof rep[i] === ‘string‘) {
                            k = rep[i];
                            v = str(k, value);
                            if (v) {
                                partial.push(quote(k) + (gap ? ‘: ‘ : ‘:‘) + v);
                            }
                        }
                    }
                } else {
                    for (k in value) {
                        if (Object.prototype.hasOwnProperty.call(value, k)) {
                            v = str(k, value);
                            if (v) {
                                partial.push(quote(k) + (gap ? ‘: ‘ : ‘:‘) + v);
                            }
                        }
                    }
                }
                v = partial.length === 0
                    ? ‘{}‘
                    : gap
                    ? ‘{\n‘ + gap + partial.join(‘,\n‘ + gap) + ‘\n‘ + mind + ‘}‘
                    : ‘{‘ + partial.join(‘,‘) + ‘}‘;
                gap = mind;
                return v;
        }
    }

    if (typeof JSON.stringify !== ‘function‘) {
        JSON.stringify = function (value, replacer, space) {
            var i;
            gap = ‘‘;
            indent = ‘‘;
            if (typeof space === ‘number‘) {
                for (i = 0; i < space; i += 1) {
                    indent += ‘ ‘;
                }
            } else if (typeof space === ‘string‘) {
                indent = space;
            }
            rep = replacer;
            if (replacer && typeof replacer !== ‘function‘ &&
                (typeof replacer !== ‘object‘ ||
                typeof replacer.length !== ‘number‘)) {
                throw new Error(‘JSON.stringify‘);
            }
            return str(‘‘, {‘‘: value});
        };
    }
    if (typeof JSON.parse !== ‘function‘) {
        JSON.parse = function (text, reviver) {
            var j;

            function walk(holder, key) {
                var k, v, value =http://www.mamicode.com/ holder[key];
                if (value && typeof value =http://www.mamicode.com/== ‘object‘) {
                    for (k in value) {
                        if (Object.prototype.hasOwnProperty.call(value, k)) {
                            v = walk(value, k);
                            if (v !== undefined) {
                                value[k] = v;
                            } else {
                                delete value[k];
                            }
                        }
                    }
                }
                return reviver.call(holder, key, value);
            }

            text = String(text);
            cx.lastIndex = 0;
            if (cx.test(text)) {
                text = text.replace(cx, function (a) {
                    return ‘\\u‘ +
                        (‘0000‘ + a.charCodeAt(0).toString(16)).slice(-4);
                });
            }
            if (/^[\],:{}\s]*$/
                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, ‘@‘)
                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ‘]‘)
                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ‘‘))) {
                j = eval(‘(‘ + text + ‘)‘);
                return typeof reviver === ‘function‘
                    ? walk({‘‘: j}, ‘‘)
                    : j;
            }
            throw new SyntaxError(‘JSON.parse‘);
        };
    }
}());
/**▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃开源库json2结束▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃**/

/**█████████████████████████████████████████████████函数库██████████████████████████████████████████████████████**/