/**
 * 刷新iframe高度
 */
function flushHeight() {
    if (window.parent.flashheight) {
        window.parent.flashheight()
    }
}

/**
 * 关闭弹窗,刷新页面
 * @param index
 */
function reload(index) {
    layer.close(index);
    window.location.reload();
}

/**
 * 普通alert方法
 */
function alertModel(text) {
    layer.open({
        title: '提示'
        , content: text
    });
}

/**
 * alert弹窗,带刷新
 */
function alertModelFlush(text) {
    layer.open({
        title: '提示'
        , content: text,
        yes: function (index) {
            reload(index);
        },
        cancel: function (index) {
            reload(index);
        }
    });
}

/**
 * 带回调的confirm
 * @param text
 * @param submitCallBack
 */
function confirmModel(text, submitCallBack, closeCallBack) {
    layer.confirm(text, {
        icon: 3, title: '提示',
        btn: ['确定', '取消'],
        cancel: function (index, layero) {
            console.log('关闭x号');
        }
    }, function (index) {
        layer.close(index);
        if (submitCallBack) {
            submitCallBack();
        }
    }, function (index) {
        layer.close(index);
        if (closeCallBack) {
            closeCallBack();
        }
    });
}

function getBirthdayFromIdCard(idCard) {
    var birthday = "";
    if(idCard != null && idCard != ""){
        if(idCard.length == 15){
            birthday = "19" + idCard.substr(6,6);
        } else if(idCard.length == 18){
            birthday = idCard.substr(6,8);
        }

        birthday = birthday.replace(/(.{4})(.{2})/,"$1-$2-");
    }
    return birthday;
}

(function ($) {
    $.extend({
        /**
         * example:  $.ajaxCallBackFunc(url,data,beforBack,callback);
         * 普通ajax
         * @param url
         * @param data            参数json
         * @param beforBack        回调前  可用于判断参数
         * @param callback        回调后
         */
        "ajaxCallBackFunc": function (url, data, beforBack, callback) {
            var bdata = {"url": url, "data": data};
            var fl = beforBack(bdata);
            if (!fl) {
                return false;
            }
            var async = true && data.async;
            $.ajax({
                url: bdata.url,
                type: "post",
                async: async,
                data: bdata.data,
                dataType: 'json',
                success: function (backData) {
                    if (callback) {
                        bdata.backData = backData;
                        callback(bdata);
                    }
                },
                error: function () {
                    if (callback) {
                        callback(bdata);
                    }
                }
            });
        },
        /**
         * example: $.contextAjaxCallBackFunc(url,data,beforBack,callback)
         * ajax设置  contentType: "application/json" 参数只能是json字符串
         * @param url
         * @param data
         * @param beforBack
         * @param callback
         */
        "contextAjaxCallBackFunc": function (url, data, beforBack, callback) {
            var bdata = {"url": url, "data": data};
            if (beforBack) {
                var fl = beforBack(bdata);
                if (!fl) {
                    return false;
                }
            }
            var async = true && data.async;
            $.ajax({
                url: bdata.url,
                type: "post",
                async: async,
                data: JSON.stringify(bdata.data),
                contentType: "application/json",
                dataType: 'json',
                success: function (backData) {
                    if (callback) {
                        bdata.backData = backData;
                        callback(bdata);
                    }
                },
                error: function () {
                    if (callback) {
                        callback(bdata);
                    }
                }
            });
        },
        /**
         * 构建一个form表单进行提交
         * @param method
         * @param action
         */
        "formSubmit": function (method, action) {
            var dlform = document.createElement('form');
            dlform.style.display = "none";
            dlform.method = Tools.isNull(method) ? 'post' : method;
            dlform.action = Tools.isNull(action) ? '#' : action;
            //dlform.target = 'callBackTarget';
            //暂时不需要隐藏的输入框
            /*var hdnFilePath = document.createElement('input');
            hdnFilePath.type = 'hidden';
            hdnFilePath.name = 'filePath';
            hdnFilePath.value = filePath;
            dlform.appendChild(hdnFilePath);*/
            document.body.appendChild(dlform);
            dlform.submit();
            document.body.removeChild(dlform);
        }, "alert": function (text) {

        }
    });
    $.fn.extend({
        LineProgressbar: function (options) {

        }
    });
})(jQuery);

var Tools = {
    hiddenInput: '<input type="hidden" name="%s" value="%s" id="%s">',
    slice: Array.prototype.slice,
    /**
     * 判断字符是否为空
     * @param str
     * @returns {Boolean}
     */
    isNull: function (str) {
        var args = arguments;
        if (args.length == 1) {
            return str == null || $.trim(str) == '';
        } else {
            for (var i = 0; i < args.length; i++) {
                if (Tools.isNull(arguments[i])) {
                    return true;
                }
            }
        }
    },
    /**
     * 把%s替换为传入的值     example:Tools.printf(Tools.hiddenInput, 'test', '123','hideId');
     * @param str
     * @returns
     */
    printf: function (str) {
        var args = arguments
            , flag = true
            , i = 1;
        str = str.replace(/%s/g, function () {
            var arg = args[i++];
            if (Tools.isNull(arg) || typeof arg === 'undefined') {
                //flag = false;
                return '';
            }
            return arg;
        });
        //return flag ? str : '';
        return str;
    },
    /**
     * 根据字符串获取func
     * */
    getFunc: function (str, obj) {
        var func = obj;
        if (Tools.isNull(str) || typeof str != 'string') return str; // 空的或者不是str返回
        if (!func[str]) {  //空的
            func = window;
            if (!func[str]) {
                var strArray = str.split(".");
                if (strArray.length > 1) {
                    $.each(strArray, function (key, value) {
                        func = func[value];
                    })
                    return func;
                } else {
                    return str;
                }
            } else {
                return func[str];
            }
        } else {
            return func[str];
        }

    },
    /**
     * 随机生成一串
     * @returns {String}
     */
    guid: function () {
        var id = []
            , i = 30;
        while (--i >= 0) {
            id.push(Math.floor(Math.random() * 16.0).toString(16));
        }
        return id.join('');
    },
    /**
     * 获取Bool类型
     * @param str 需要转换的字符串
     * @param def  定义空字符返回类型
     * @returns
     */
    getBool: function (str, def) {
        return (Tools.isNull(str) ? (def == null ? false : def) : (str == 'true' ? true : false));
    },
    /**
     * 获取字符串如果是空取默认
     * @param str
     * @param def
     * @returns
     */
    getStr: function (str, def) {
        return (Tools.isNull(str) ? (def == null ? '' : def) : str);
    }, match: {
        /**
         * 获取字符串中{}的信息
         */
        match_1: /\{.+?\}/g,
        /**
         * 获取{}
         */
        match_2: /\{|\}/g,
        /**
         * 判断jQuery写法(可能不是很严谨)
         */
        match_3: /\#|\[|\]|\:|\=|\-/g
    },
    format: {
        yMd: 'yyyy-MM-dd',
        yMdhms: 'yyyy-MM-dd hh:mm:ss',
        hm: 'hh:mm'
    },
    /**
     * 对象转换
     * @param self 内部对象*
     * @param name 转换对象名称
     * @param args 参数列表
     * @param defaultValue 默认返回值
     * @param tarObj 取值的目标对象 如果为空默认的是windows
     */
    convertObj: function (name, tarObj) {
        var func = null;
        tarObj = tarObj ? tarObj : window;

        if (!Tools.isNull(name) && name.indexOf('#') != -1) {
            return null;
        } else if (typeof name === 'string') {
            var names = name.split('.');
            if (names.length > 1) {
                func = tarObj
                $.each(names, function (i, f) {
                    func = func[f];
                });
                return func;
            } else {
                func = tarObj[name];
                return func;
            }
        } else if (typeof name === 'function') {
            return func;
        }
        console.error('convertObj => %s is not find!', name);
        return null;
    },
    /**
     * Json转换
     */
    toJson: function (data) {
        return eval('(' + data + ')');
    },
    /**
     * 循环取值
     */
    getDataValueByKey: function (data, key) {
        var array = key.split('.');
        for (var i in array) {
            data = data[array[i]];
            if (data) {
                return data;
            }
        }
        return data;
    },
    /**
     *获取一个 隐藏的input
     */
    getHideInput: function (name, value, id) {
        id = Tools.isNull(id) ? "" : id;
        return Tools.printf(Tools.hiddenInput, name, value, id);
    },
    /**
     * 数字转换成大写
     * @param num
     * @returns
     */
    numberConvert: function (num) {
        var N = [
            "零", "一", "二", "三", "四", "五", "六", "七", "八", "九"
        ];
        var str = num.toString();
        var len = num.toString().length;
        var C_Num = [];
        for (var i = 0; i < len; i++) {
            C_Num.push(N[str.charAt(i)]);
        }
        return C_Num.join('');
    },
    /**
     * 获取字符在字符串中出现的次数
     * @param re        字符串
     * @param s            字符
     * @returns
     */
    getCharCount: function (re, s) {
        re = eval("/" + re + "/ig")
        return s.match(re).length;
    },
    /**
     * 获得数组    传入 例： 1,2,3   返回 [1,2,3]
     */
    getArray: function () {
        return Tools.slice.call(arguments);
    },
    /**ie
     * （伪）数组转换为数组        传入伪数组
     */
    getArgumentsArray: function (obj) {
        return Tools.slice.call(obj);
    },
    /**
     * 验证是否是数组（前提是toString()方法没有被重写过）
     * @returns {Boolean}
     */
    isArray: function (obj) {
        return Object.prototype.toString.call(obj) === '[object Array]';
    },
    /**
     * 获取数组中的最大值   参数   [1,2,3]或者1,2,3
     * @param obj
     * @returns {Number}
     */
    getMaxNum: function (obj) {
        var maxNum = 0;
        if (Tools.isArray(obj)) {
            maxNum = Math.max.apply(Math, obj);
        } else {
            var arr = Tools.getArgumentsArray(arguments);	//arguments为伪数组
            maxNum = Math.max.apply(Math, arr);
        }
        return maxNum;
    },
    /**
     * 获取数组中的最小值   参数   [1,2,3]或者1,2,3
     * @param obj
     * @returns {Number}
     */
    getMinNum: function (obj) {
        var minNum = 0;
        if (Tools.isArray(obj)) {
            minNum = Math.min.apply(Math, obj);
        } else {
            var arr = Tools.getArgumentsArray(arguments);	//arguments为伪数组
            minNum = Math.min.apply(Math, arr);
        }
        return minNum;
    },
    /**
     * 对象深拷贝
     * @param obj
     * @returns
     */
    deepCopy: function (obj) {
        // 只拷贝对象
        if (typeof obj !== 'object') return;
        // 根据obj的类型判断是新建一个数组还是一个对象
        var newObj = obj instanceof Array ? [] : {};
        for (var key in obj) {
            // 遍历obj,并且判断是obj的属性才拷贝
            if (obj.hasOwnProperty(key))
                newObj[key] = typeof obj[key] === 'object' ? Tools.deepCopy(obj[key]) : obj[key];
        }
        return newObj;
    }
}
//日期的工具类
var DateUtil = {
    /**
     * 日期对象转换为指定格式的字符串
     * @param formatStr 日期格式,yyyy-MM-dd HH:mm:ss等,如果为空则默认为yyyy-MM-dd HH:mm:ss
     * @param date Date日期对象,如果为空，则默认当前时间
     * @returns {*|string}
     */
    dateToStr: function (formatStr, date) {
        if (typeof arguments[0] == 'undefined') {
            formatStr = "yyyy-MM-dd HH:mm:ss";
            date = new Date();
        } else {
            if (typeof arguments[0] == 'string') {
                formatStr = arguments[0];
            } else {
                formatStr = "yyyy-MM-dd HH:mm:ss";
                date = arguments[0];
            }
        }
        if (typeof arguments[1] == 'undefined') {
            date = new Date();
        } else {
            if (typeof arguments[1] == 'string') {
                formatStr = arguments[1];
            } else {
                date = arguments[1];
            }
        }
        var str = formatStr;
        var Week = ['日', '一', '二', '三', '四', '五', '六'];
        str = str.replace(/yyyy|YYYY/, date.getFullYear());
        str = str.replace(/yy|YY/, (date.getYear() % 100) > 9 ? (date.getYear() % 100).toString() : '0' + (date.getYear() % 100));
        str = str.replace(/MM/, date.getMonth() > 9 ? (date.getMonth() + 1) : '0' + (date.getMonth() + 1));
        str = str.replace(/M/g, date.getMonth());
        str = str.replace(/w|W/g, Week[date.getDay()]);

        str = str.replace(/dd|DD/, date.getDate() > 9 ? date.getDate().toString() : '0' + date.getDate());
        str = str.replace(/d|D/g, date.getDate());

        str = str.replace(/hh|HH/, date.getHours() > 9 ? date.getHours().toString() : '0' + date.getHours());
        str = str.replace(/h|H/g, date.getHours());
        str = str.replace(/mm/, date.getMinutes() > 9 ? date.getMinutes().toString() : '0' + date.getMinutes());
        str = str.replace(/m/g, date.getMinutes());

        str = str.replace(/ss|SS/, date.getSeconds() > 9 ? date.getSeconds().toString() : '0' + date.getSeconds());
        str = str.replace(/s|S/g, date.getSeconds());

        return str;
    },
    /**
     * 字符串时间转换为日期时间
     * @param dateStr 格式为yyyy-MM-dd HH:mm:ss，必须按年月日时分秒的顺序，中间分隔符不限制
     */
    strToDate: function (dateStr) {
        var data = dateStr;
        var reCat = /(\d{1,4})/gm;
        var t = data.match(reCat);
        t[1] = t[1] - 1;
        eval('var d = new Date(' + t.join(',') + ');');
        return d;
    },
    /**
     * 获取当前日期字符串，格式为yyyy-MM-dd
     * @returns {*|string}
     */
    getNowDateStr: function () {
        var date = new Date();
        var dateStr = this.dateToStr("yyyy-MM-dd", date);
        return dateStr;
    },
    /**
     * 获取当前时间字符串，格式为yyyy-MM-dd HH:mm:ss
     * @returns {*|string}
     */
    getNowTimeStr: function () {
        var date = new Date();
        var dateStr = this.dateToStr("yyyy-MM-dd HH:mm:ss", date);
        return dateStr;
    },
    /**
     * 指定日期是星期几
     * @param date Date日期对象,如果为空，则默认当前时间
     */
    getWeek: function (date) {
        date = arguments[0] || new Date();
        var a = ['日', '一', '二', '三', '四', '五', '六'];
        var week = a[date.getDay()];
        return week;
    },
    /**
     * 增加年数(返回Date类型日期)
     * @param date 字符串类型日期或者Date类型日期
     * @param addYears
     * @returns {Date}
     */
    addYear: function (date, addYears) {
        var a = new Date();
        if (typeof date == "string") {
            a = new Date(Date.parse(date.replace(/-/g, "/")));
        } else {
            a = date;
        }
        a.setFullYear(a.getFullYear() + addYears);
        return a;
    },
    /**
     * 增加月数(返回Date类型日期)
     * @param date 字符串类型日期或者Date类型日期
     * @param addMonths
     * @returns {Date}
     */
    addMonth: function (date, addMonths) {
        var a = new Date();
        if (typeof date == "string") {
            a = new Date(Date.parse(date.replace(/-/g, "/")));
        } else {
            a = date;
        }
        a.setMonth(a.getMonth() + addMonths);
        return a;
    },
    /**
     * 增加天数(返回Date类型日期)
     * @param date 字符串类型日期或者Date类型日期
     * @param addDays
     * @returns {Date}
     */
    addDay: function (date, addDays) {
        var a = new Date();
        if (typeof date == "string") {
            a = new Date(Date.parse(date.replace(/-/g, "/")));
        } else {
            a = date;
        }
        a.setDate(a.getDate() + addDays);
        return a;
    }, formatDate: function (date) {
        console.log(date);
        var d = new Date(date);
        var time = d.toLocaleString();
        return time;
    }, myformatter: function (date) {
        //获取年份
        var y = date.getFullYear();
        //获取月份
        var m = date.getMonth() + 1;
        return y + '-' + m;
    },
    /**
     * 获取两个日期相差的天数       sDate1和sDate2是2002-12-18格式
     * @param sDate1
     * @param sDate2
     * @returns
     */
    DateDiff: function (sDate1, sDate2) {
        var aDate, oDate1, oDate2, iDays
        aDate = sDate1.split("-")
        oDate1 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0])    //转换为12-18-2002格式
        aDate = sDate2.split("-")
        oDate2 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0])
        iDays = parseInt(Math.abs(oDate1 - oDate2) / 1000 / 60 / 60 / 24)    //把相差的毫秒数转换为天数
        return iDays
    }
};

var ValidateUtil = {
    match: {
        //手机号码正则
        match_mo: /^1[3456789]\d{9}$/,
        //身份证号码正则
        match_idCard: /^(^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$)|(^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[Xx])$)$/,
        //邮箱正则
        match_email: /^([a-zA-Z]|[0-9])(\w|\-)+@[a-zA-Z0-9]+\.([a-zA-Z]{2,4})$/,
        //正整数
        match_number: /^\+?[0-9]*$/
    }, isMobile: function (mobile) {
        return ValidateUtil.match.match_mo.test(mobile);
    }, isIdCard: function (idCard) {
        //如果通过该验证，说明身份证格式正确，但准确性还需计算
        if (ValidateUtil.match.match_idCard.test(idCard)) {
            if (idCard.length == 18) {
                var idCardWi = new Array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2); //将前17位加权因子保存在数组里
                var idCardY = new Array(1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2); //这是除以11后，可能产生的11位余数、验证码，也保存成数组
                var idCardWiSum = 0; //用来保存前17位各自乖以加权因子后的总和
                for (var i = 0; i < 17; i++) {
                    idCardWiSum += idCard.substring(i, i + 1) * idCardWi[i];
                }
                var idCardMod = idCardWiSum % 11;//计算出校验码所在数组的位置
                var idCardLast = idCard.substring(17);//得到最后一位身份证号码
                //如果等于2，则说明校验码是10，身份证号码最后一位应该是X
                if (idCardMod == 2) {
                    if (idCardLast == "X" || idCardLast == "x") {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    //用计算出的验证码与最后一位身份证号码匹配，如果一致，说明通过，否则是无效的身份证号码
                    if (idCardLast == idCardY[idCardMod]) {
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        } else {
            return false;
        }
    }, isEmail: function (email) {
        return ValidateUtil.match.match_email.test(email);
    }, isNumber: function (num) {
        return ValidateUtil.match.match_number.test(num);
    }, validate: function (arr) {
        var twiceArrFlag = Tools.isArray(arr[0]);
        if (!twiceArrFlag) {
            if (arr.length == 2) {
                if (ValidateUtil.isNull($('#' + arr[0]).val())) {
                    alertModel(Tools.printf(ValidateUtil.getMsgByFuncNameAndElement(arr[0], 'isNull'), arr[1]));
                    return false;
                } else {
                    return true;
                }
            } else if (arr.length == 3) {
                var checkFlag = true;
                var rules = arr[2].toString();
                if (rules.indexOf(',') > 0) {
                    var ruleArr = rules.split(',');
                    for (var i = 0; i < ruleArr.length; i++) {
                        var funcName = ruleArr[i];
                        var func = Tools.getFunc(funcName, ValidateUtil);
                        var value = $('#' + arr[0]).val();
                        var checkFlag;
                        if (funcName != 'isNull') {
                            //符合返回false
                            checkFlag = !func(value);
                        } else {
                            //如果是空返回true
                            checkFlag = func(value);
                        }
                        if (checkFlag) {
                            alertModel(Tools.printf(ValidateUtil.getMsgByFuncNameAndElement(arr[0], funcName), arr[1]));
                            checkFlag = false;
                            break;
                        } else {
                            checkFlag = true;
                        }
                    }
                    return checkFlag;
                } else {
                    var func = Tools.getFunc(rules, ValidateUtil);
                    var checkFlag;
                    if (rules != 'isNull') {
                        checkFlag = !func($('#' + arr[0]).val());
                    } else {
                        checkFlag = func($('#' + arr[0]).val());
                    }
                    if (checkFlag) {
                        alertModel(Tools.printf(ValidateUtil.getMsgByFuncNameAndElement(arr[0], rules), arr[1]));
                        return false;
                    } else {
                        return true;
                    }
                }
            }
        } else {
            var flag = true;
            for (var i = 0; i < arr.length; i++) {
                if (!ValidateUtil.validate(arr[i])) {
                    flag = false;
                    break;
                }
            }
            return flag;
        }
    }, getMsgByFuncNameAndElement: function (element, funcName) {
        var msg = '';
        var $obj = $('#' + element);
        //输入框   函数是isNull或者函数为空
        var type = $obj.attr('type');
        var isCheckFlag = (type != 'file' && type != 'checkbox' && type != 'radio');
        var isNuFlag = (funcName == 'isNull' || Tools.isNull(funcName));
        var isPlease = ($obj.is('input') || $obj.is('textarea'));
        if (isPlease && isCheckFlag && isNuFlag) {
            msg = '请输入%s';
        } else if ($obj.is('input') && isCheckFlag && funcName != 'isNull') {
            msg = '请输入正确的%s';
        } else {
            msg = '请选择%s';
        }
        return msg;
    }, isNull: function (str) {
        return Tools.isNull(str);
    }
}

var NumberUtil = {
    /**
     * 保留小数  返回number
     * @param x        数字字符串
     * @param n        保留的位数
     * @returns
     */
    toDecimal: function (x, n) {
        var f = parseFloat(x);
        if (isNaN(f)) {
            return;
        }
        f = Math.round(x * (Math.pow(10, n))) / Math.pow(10, n);
        return f;
    }
}

/**
 * ----------------------------------------------------原型扩展与重写---------------------------------------------------
 */

/**
 * 重写Date的toLocaleString方法    yyyy-MM-dd hh:mm:ss格式
 * @returns {String}
 */
Date.prototype.toLocaleString = function () {
    return this.getFullYear() + "-" + (this.getMonth() + 1) + "-" + this.getDate() + " " + this.getHours() + ":" + this.getMinutes() + ":" + this.getSeconds();
};
/**
 * 重写 Date的format方法  日期格式化
 * @param format
 * @returns
 */
Date.prototype.format = function (format) {
    /*
	 * eg:format="yyyy-MM-dd hh:mm:ss";
	 */
    var o = {
        "M+": this.getMonth() + 1,
        // month
        "d+": this.getDate(),
        // day
        "h+": this.getHours(),
        // hour
        "m+": this.getMinutes(),
        // minute
        "s+": this.getSeconds(),
        // second
        "q+": Math.floor((this.getMonth() + 3) / 3),
        // quarter
        "S": this.getMilliseconds()
    }

    if (/(y+)/.test(format)) {
        format = format.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    }

    for (var k in o) {
        if (new RegExp("(" + k + ")").test(format)) {
            format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
        }
    }
    return format;
}



/**
 * 返回获取数组中最大值
 */
Array.prototype.max = function () {
    var max = this[0];
    var len = this.length;
    for (var i = 1; i < len; i++) {
        if (this[i] > max) {
            max = this[i];
        }
    }
    return max;
}

/**
 * 返回获取数组中最小值
 */
Array.prototype.min = function () {
    var min = this[0];
    var len = this.length;
    for (var i = 1; i < len; i++) {
        if (this[i] < min) {
            min = this[i];
        }
    }
    return min;
}
/**
 * 去除数组中重复元素
 * @returns {Array}
 */
Array.prototype.removeSame = function () {
    var r = [];
    for (var i = 0, l = this.length; i < l; i++) {
        for (var j = i + 1; j < l; j++)
            if (this[i] === this[j]) j = ++i;
        r.push(this[i]);
    }
    return r;
}

/**
 * 扩展push方法
 * @param arr
 */
Array.prototype.pushAll = function (arr) {
    for (var i = 0; i < arr.length; i++)
        this.push(arr[i]);
}


$.isIE = function () {
    return !!window.ActiveXObject || "ActiveXObject" in window;
}

/**
 * IE8及以下返回 0
 * IE8以上返回 1
 * @returns {number}
 */
function isIE() {
    var isIE = 1;
    var browInfo = window.navigator.userAgent;
    if (browInfo.indexOf("MSIE") >= 1) {
        var num = parseFloat(browInfo.split('MSIE')[1].split(';')[0]);
        if (!num || num >= 9.0) {
            //ie版本9.0以上可以走pdf.js预览
        } else {
            //ie版本9.0以下转图片预览
            isIE = 0;
        }
    }
    return isIE;
}