/* pageadmin cms js基础库 */
var frameui_basic = window.frameui_basic || {};

string.prototype.trim = function () //去除首尾空格
{
    return this.replace(/(^\s*)|(\s*$)/g, "");
}
string.prototype.ltrim = function () //去除左空格
{
    return this.replace(/(^\s*)/g, "");
}
string.prototype.rtrim = function () //去除右空格
{
    return this.replace(/(\s*$)/g, "");
}

string.prototype.strlength = function (bybyte) //获取字符长度,参数：bybyte表示是否按双字节截取
{
    if (bybyte) {
        return this.replace(/[^\x00-\xff]/g, "**").length;
    } else
    {
        return this.replace(/(\s*$)/g, "").length;
    }
}
string.prototype.left = function (len, bybyte) //左边截取字数,参数：bybyte表示是否按双字节截取
{
    var str = this;
    if (isnan(len) || len == null) {
        return str;
    }
    if (bybyte)
    {
        var r = /[^\x00-\xff]/g;
        if (str.replace(r, "**").length <= len) { return str; }
        var m = math.floor(len / 2);
        for (var i = m; i < str.length; i++) {
            if (str.substr(0, i).replace(r, "**").length >= len) {
                return str.substr(0, i);
            }
        }
    }
    else {
        if (parseint(len) < 0 || parseint(len) > str.length) {
            len = str.length;
        }
        return str.substr(0, len);
    }
    return str;
}

string.prototype.right = function (len, bybyte) //右边截取字段数,参数：bybyte表示是否按双字节截取
{
    var str = this;
    if (isnan(len) || len == null) {
        return str;
    }
    if (bybyte) {
        var r = /[^\x00-\xff]/g;
        if (str.replace(r, "**").length <= len) { return str; }
        var strlength = str.length;
        for (var i = 0; i < strlength; i++) {
            if (str.substr(strlength - i).replace(r, "**").length >= len) {
                return str.substr(strlength - i);
            }
        }
    } else
    {
        if (parseint(len) < 0 || parseint(len) > str.length) {
            len = str.length;
        }
        return str.substring(str.length - len, str.length);
    }
    return str;
}

//只对字符值进行比较，相同等返回true
function equals(x, y) {
    if (x == y) {
        return true;
    }
    else if ((typeof x == "object" && x != null) && (typeof y == "object" && y != null)) {
        x = json.stringify(x);
        y = json.stringify(y);
        if (x.length != y.length) {
            return false;
        }
        return x == y;
    }
    else {
        if (typeof x == "boolean" || typeof x == "number" || typeof x == "bigint") {
            x = x.tostring();
        }
        if (typeof y == "boolean" || typeof y == "number" || typeof y == "bigint") {
            y = y.tostring();
        }
        return x == y;
    }

}

//深拷贝
function deepcopy(source) {
    if (typeof source == "object" && source != null) {
        return json.parse(json.stringify(source));
    } else {
        return source;
    }
}

//判断字符串是否为空

function isnullorempty(str) {
    if (typeof str === "string") {
        return /^ *$/.test(str);
    }
    else if (typeof str === "function") {
        return false;
    }
    for (var key in str) { //可遍历的
        return false;
    }
    return typeof str !== "number" && typeof str !== "boolean";
}

function islstr(str) //是否由数字、字母和下划线组成 字母开头
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    var reg = /^[a-za-z][a-za-z0-9_]*$/;
    if (reg.test(str))
        return true;
    else
        return false;
}

function isstr(str) //是否由数字、字母和下划线组成
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    return (str.replace(/\w/g, "").length == 0);
}

function isnumeric(str, symbol) //验证数值类型
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    if (symbol == undefined) {
        symbol = "";
    }
    switch (symbol) {
        case "+":        //正数
            return /(^\+?|^\d?)\d*\.?\d+$/.test(str);
        case "-":        //负数
            return /^-\d*\.?\d+$/.test(str);
        case "i":        //整数
            return /(^-?|^\+?|\d)\d+$/.test(str);
        case "+i":        //正整数
            return /(^\d+$)|(^\+?\d+$)/.test(str);
        case "-i":        //负整数
            return /^[-]\d+$/.test(str);
        case "f":        //浮点数
            return /(^-?|^\+?|^\d?)\d*\.\d+$/.test(str);
        case "+f":        //正浮点数
            return /(^\+?|^\d?)\d*\.\d+$/.test(str);
        case "-f":        //负浮点数
            return /^[-]\d*\.\d$/.test(str);
        default: //缺省,包括正负数，小数
            if (isnan(str)) { return false; }
            else { return true; }
    }
}

function isint(str) //正负整数
{
    if (str == undefined) { return false; }
    return /(^\d+$)|(^\+?\d+$)/.test(str) || /^[-]\d+$/.test(str);
}

function isusername(str) //是否是用户名由数字、字母和下划线汉字组成,不能为纯数字，不能包含@,便于后台的
{
    if (isnullorempty(str)) { return false; }
    if (str.tostring().trim() == "") { return false; }
    if (str.indexof("@") > 0) //包含邮箱规则返回false
    {
        return false;
    }
    if (isnumeric(str)) { //全是数字则返回false
        return false;
    }
    var reg = /^[\u4e00-\u9fff\w]{2,16}$/;
    return reg.test(str);
    return true;
}


function ischinese(str) //是否为汉字
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    return /^[^\x00-\xff]*$/.test(str);
}

function includechinese(str) //是否包含汉字
{
    if (str == undefined) { return false; }
    return (str.length != str.replace(/[^\x00-\xff]/g, "**").length);
}

function isdate(str) //是否是日期
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    var reg1 = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
    var reg2 = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
    if (!reg1.test(str) && !reg2.test(str)) {
        return false;
    }
    return true;
}

function isdatetime(str) //是否是日期+时间格式
{
    if (str == undefined) { return false; }
    if (str.tostring().trim() == "") { return false; }
    var reg1 = /^(\d{1,2})\/(\d{1,2})\/(\d{4}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
    var reg2 = /^(\d{4})-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
    if (!reg1.test(str) && !reg2.test(str)) {
        return false;
    }
    return true;
}

function ismobile(mobile) //是否是手机号
{
    if (mobile == undefined) { return false; }
    var myreg = /^1[345678]\d{9}$/;
    if (!myreg.test(mobile)) { return false; }
    return true;
}

function isemail(str) //是否是邮箱号
{
    if (str == undefined) { return false; }
    var pattern = /^[a-za-z0-9_.-]+@[a-za-z0-9-]+(\.[a-za-z0-9-]+)*\.[a-za-z0-9]{2,6}$/;
    var flag = pattern.test(str.tostring().trim());
    if (!flag) {
        return false;
    }
    else {
        return true;
    }
}

function isip(str) //是否是ip地址
{
    if (str == undefined) { return false; }
    var respacecheck = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;
    if (respacecheck.test(str)) {
        str.match(respacecheck);
        if (regexp.$1 <= 255 && regexp.$1 >= 0
            && regexp.$2 <= 255 && regexp.$2 >= 0
            && regexp.$3 <= 255 && regexp.$3 >= 0
            && regexp.$4 <= 255 && regexp.$4 >= 0) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        return false;
    }
}

function isimage(path, extfilter) //是否是图片地址
{
    if (isnullorempty(path)) { return false; }
    if (extfilter == undefined) {
        extfilter = [".jpeg", ".gif", ".jpg", ".png", ".bmp"];
    }
    if (path.indexof(".") > -1) {
        var p = path.lastindexof(".");
        var strpostfix = path.substring(p, path.length);
        strpostfix = strpostfix.tolowercase();
        if (extfilter.indexof(strpostfix) > -1) {
            return true;
        }
    }
    return false;
}

//判断是否是手机浏览器
function ismobilebrowser() {
    var useragentinfo = navigator.useragent;
    var agents = ["android", "iphone",
        "symbianos", "windows phone",
        "ipad", "ipod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) {
        if (useragentinfo.indexof(agents[v]) > 0) {
            flag = true;
            break;
        }
    }
    return false;
}

function unique(value) //字符串用半角逗号隔开，过滤重复和空字符
{
    var arr = [];
    var type = typeof (value);
    if (isnullorempty(value)){
        return "";
    }
    if (array.isarray(value)){
        arr = value;
    }
    else if (type == "string"){
        arr = value.split(",");
    }
    else{
        return value;
    }
    var result = [], hash = {};
    for (var i = 0, elem; (elem = arr[i]) != null; i++) {
        if (!hash[elem] && !isnullorempty(elem)) {
            if (typeof elem == "string"){
                elem = elem.trim();
            }
            result.push(elem);
            hash[elem] = true;
        }
    }
    if (type == "string") {
       return result.join(",");
    }
    else {
        return result;
    }
}

function urlencode(str) //对字符串进行encodeuricomponent编码，方便传入后台
{
    if (str == undefined) { return ""; }
    return encodeuricomponent(str);
}

/*用浏览器内部转换器实现html转码*/
function htmlencode(html) {
    //1.首先动态创建一个容器标签元素，如div
    var temp = document.createelement("div");
    //2.然后将要转换的字符串设置为这个元素的innertext(ie支持)或者textcontent(火狐，google支持)
    (temp.textcontent != undefined) ? (temp.textcontent = html) : (temp.innertext = html);
    //3.最后返回这个元素的innerhtml，即得到经过html编码转换的字符串了
    var output = temp.innerhtml;
    temp = null;
    return output;
}
/*用浏览器内部转换器实现html解码*/
function htmldecode(text) {
    //1.首先动态创建一个容器标签元素，如div
    var temp = document.createelement("div");
    //2.然后将要转换的字符串设置为这个元素的innerhtml(ie，火狐，google都支持)
    temp.innerhtml = text;
    //3.最后返回这个元素的innertext(ie支持)或者textcontent(火狐，google支持)，即得到经过html解码的字符串了。
    var output = temp.innertext || temp.textcontent;
    temp = null;
    return output;
}


function replaceall(str, str1, str2) //替换所有对应的字符串，默认的replace只替换第一个
{
    if (str == undefined) { return ""; }
    while (str.indexof(str1) >= 0) {
        str = str.replace(str1, str2);
    }
    return str;
}

function numericformat(str) //格式化字符串，只保留数字
{
    if (str == undefined) { return ""; }
    return str.replace(/\d/g, "");
}

function strformat(str) //格式化字符串，只保留数字、字母部分
{
    if (str == undefined) { return ""; }
    return str.replace(/[\w]/g, '');
}

function chineseformat(str) //格式化字符串，只保留汉字
{
    if (str == undefined) { return ""; }
    return (str.replace(/[^\u4e00-\u9fa5]/g, ''));
}

function inputnumeric() //只能输入数字,onkeyup调用
{
    this.value = numericformat(this.value);
}

function inputchinese() //只能输入中文，,onkeyup调用
{
    this.value = chineseformat(this.value);
}
function inputstr()  //只能输入 字母，数字和 下划线,onkeyup调用
{
    this.value = strformat(this.value);
}


//html5本地储存，localstorage保存的值都是string类型,expires过期秒数，设置了值则会通过添加cookie来控制过期时间。
function setlocalstorage(name, value, expires) {
    if (expires == undefined) {
        expires = 0;//默认不过期，
    }
    if (typeof (value) == "object") {
        value = json.stringify(value);
    }
    if (issupportlocalstorage()) {
        localstorage.setitem(name, value);
        if (expires > 0) {
            setcookie("_localstoragekey_" + name, "1", expires);
        }
    }
    else {
        setcookie(name, value, expires);
    }
}
//html5本地储存,hassetexpires表示是否设置了过期时间
function getlocalstorage(name, hassetexpires) {
    if (!hassetexpires) {
        hassetexpires = false;
    }
    if (issupportlocalstorage()) {

        if (hassetexpires) {
            var localstoragekey = getcookie("_localstoragekey_" + name);
            if (localstoragekey == "") {
                removelocalstorage(name);
                return "";
            }
        }
        var strvalue = localstorage.getitem(name);
        if (strvalue == null) {
            strvalue = "";
        }
        return strvalue;
    }
    else {
        return getcookie(name);
    }
}

//删除本地储存
function removelocalstorage(name) {
    if (issupportlocalstorage()) {
        localstorage.removeitem(name);
        delcookie("_localstoragekey_" + name);
    }
    else {
        delcookie(name);
    }
}

function issupportlocalstorage() {
    try {
        return 'localstorage' in window && window['localstorage'] !== null;
    }
    catch (e) {
        return false;
    }
}

function setcookie(name, value, expires, path)//cookies设置,
{
    var argv = setcookie.arguments;
    var argc = setcookie.arguments.length;
    expires = (argc > 2) ? argv[2] : null;//第三个参数为过期时间
    path = (argc > 3) ? argv[3] : null;//第4个参数为路径,不设置则默认为当前路径
    if (expires != null) {
        if (typeof (expires) != "number") {
            expires = null;
        }
        var largeexpdate = new date();
        //largeexpdate.settime(largeexpdate.gettime() + (expires*1000*60*60*24));//expires为过期天数
        largeexpdate.settime(largeexpdate.gettime() + (expires * 1000)); //expires为过期秒数值
    }
    if (path != null) {
        if (path.trim() == "") {
            path = null;
        }
        path = ";path=" + path;
    }
    document.cookie = name + "=" + decodeuricomponent(value) + ((expires == null) ? "" : (";expires=" + largeexpdate.togmtstring() + "")) + path;
}

function getcookie(name)//cookies读取
{
    var search = name + "="
    if (document.cookie.length > 0) {
        offset = document.cookie.indexof(search)
        if (offset != -1) {
            offset += search.length
            end = document.cookie.indexof(";", offset)
            if (end == -1) end = document.cookie.length
            return unescape(document.cookie.substring(offset, end))
        }
        else return ""
    }
    else {
        return "";
    }
}

function delcookie(name)//删除cookie
{
    var exp = new date();
    exp.settime(exp.gettime() - 1);
    var cval = getcookie(name);
    if (cval != null)
        document.cookie = name + "=" + cval + ";expires=" + exp.togmtstring();
}
function removecookie(name)//删除cookie
{
    delcookie(name);
}

//监听事件
function addevent(obj, event, fn) {
    if (obj.attachevent) { //ie
        obj.attachevent("on" + event, function () {
            fn.call(obj);
        })
    } else {
        obj.addeventlistener(event, fn, false);
    }
}
//移除事件监听
function removeevent(obj, event, fn) {
    if (obj.removeeventlistener)
        obj.removeeventlistener(event, fn, false);
    else if (obj.detachevent)
        obj.detachevent("on" + event, fn);
    else obj["on" + type] = null;
}

//阻止浏览器的默认行为 
function stopdefault() {
    var e = window.event || arguments.callee.caller.arguments[0];
    //阻止默认浏览器动作(w3c) 
    if (e && e.preventdefault) {
        e.preventdefault();
    }
    //ie中阻止函数器默认动作的方式 
    else {
        window.event.returnvalue = false;
    } return false;
}

//停止冒泡
function stopbubble(e) {
    //var e = window.event || arguments.callee.caller.arguments[0];
    //如果提供了事件对象，则这是一个非ie浏览器 
    if (e && e.stoppropagation) {
        //因此它支持w3c的stoppropagation()方法 
        e.stoppropagation();
    }

    else {
        //否则，我们需要使用ie的方式来取消事件冒泡 
        window.event.cancelbubble = true;
    }
}

document.ready = (function () {
    var funcs = [];             //当获得事件时，要运行的函数
    var ready = false;          //当触发事件处理程序时,切换为true

    //当文档就绪时,调用事件处理程序
    function handler(e) {
        if (ready) return;       //确保事件处理程序只完整运行一次

        //如果发生onreadystatechange事件，但其状态不是complete的话,那么文档尚未准备好
        if (e.type === 'onreadystatechange' && document.readystate !== 'complete') {
            return;
        }

        //运行所有注册函数
        //注意每次都要计算funcs.length
        //以防这些函数的调用可能会导致注册更多的函数
        for (var i = 0; i < funcs.length; i++) {
            funcs[i].call(document);
        }
        //事件处理函数完整执行,切换ready状态, 并移除所有函数
        ready = true;
        funcs = null;
    }
    //为接收到的任何事件注册处理程序
    if (document.addeventlistener) {
        document.addeventlistener('domcontentloaded', handler, false);
        document.addeventlistener('readystatechange', handler, false);            //ie9+
        window.addeventlistener('load', handler, false);
    } else if (document.attachevent) {
        document.attachevent('onreadystatechange', handler);
        window.attachevent('onload', handler);
    }
    //返回whenready()函数
    return function whenready(fn) {
        if (ready) { fn.call(document); }
        else { funcs.push(fn); }
    }
})();

//动态加载js
function loadscript(scriptpath, callback) {
    var $head = document.getelementsbytagname("head")[0];
    var newscript = document.createelement('script');
    newscript.type = 'text/javascript';
    newscript.src = scriptpath;
    $head.appendchild(newscript);
    if (!/*@cc_on!@*/false) {
        newscript.onload = function () {
            callback && callback.call();
        }
    }
    else {
        newscript.onreadystatechange = function () {
            if (script.readystate == "loaded" || script.readstate == 'complate') {
                callback && callback.call();
            }
        }
    }
}

//获取页面窗体尺寸
function clientsize() {
    if (window.innerheight !== undefined) {
        return {
            "width": window.innerwidth,
            "height": window.innerheight
        }
    } else if (document.compatmode === "css1compat") {
        return {
            "width": document.documentelement.clientwidth,
            "height": document.documentelement.clientheight
        }
    } else {
        return {
            "width": document.body.clientwidth,
            "height": document.body.clientheight
        }
    }
}

function extend() {
    var length = arguments.length;
    var target = arguments[0] || {};
    if (typeof target != "object" && typeof target != "function") {
        target = {};
    }
    if (length == 1) {
        return target;
    }
    for (var i = 1; i < length; i++) {
        var source = arguments[i];
        for (var key in source) {
            // 使用for in会遍历数组所有的可枚举属性，包括原型。
            if (object.prototype.hasownproperty.call(source, key)) {
                target[key] = source[key];
            }
        }
    }
    return target;
}

//生成guid
function guid() {
    this.date = new date();
    /* 判断是否初始化过，如果初始化过以下代码，则以下代码将不再执行，实际中只执行一次 */
    if (typeof this.newguid != 'function') {
        /* 生成guid码 */
        guid.prototype.newguid = function () {
            this.date = new date();
            var guidstr = '';
            sexadecimaldate = this.hexadecimal(this.getguiddate(), 16);
            sexadecimaltime = this.hexadecimal(this.getguidtime(), 16);
            for (var i = 0; i < 9; i++) {
                guidstr += math.floor(math.random() * 16).tostring(16);
            }
            guidstr += sexadecimaldate;
            guidstr += sexadecimaltime;
            while (guidstr.length < 32) {
                guidstr += math.floor(math.random() * 16).tostring(16);
            }
            return this.formatguid(guidstr);
        }

        /*
         * 功能：获取当前日期的guid格式，即8位数的日期：19700101
         * 返回值：返回guid日期格式的字条串
         */
        guid.prototype.getguiddate = function () {
            return this.date.getfullyear() + this.addzero(this.date.getmonth() + 1) + this.addzero(this.date.getday());
        }

        /*
         * 功能：获取当前时间的guid格式，即8位数的时间，包括毫秒，毫秒为2位数：12300933
         * 返回值：返回guid日期格式的字条串
         */
        guid.prototype.getguidtime = function () {
            return this.addzero(this.date.gethours()) + this.addzero(this.date.getminutes()) + this.addzero(this.date.getseconds()) + this.addzero(parseint(this.date.getmilliseconds() / 10));
        }

        /*
        * 功能: 为一位数的正整数前面添加0，如果是可以转成非nan数字的字符串也可以实现
         * 参数: 参数表示准备再前面添加0的数字或可以转换成数字的字符串
         * 返回值: 如果符合条件，返回添加0后的字条串类型，否则返回自身的字符串
         */
        guid.prototype.addzero = function (num) {
            if (number(num).tostring() != 'nan' && num >= 0 && num < 10) {
                return '0' + math.floor(num);
            } else {
                return num.tostring();
            }
        }

        /* 
         * 功能：将y进制的数值，转换为x进制的数值
         * 参数：第1个参数表示欲转换的数值；第2个参数表示欲转换的进制；第3个参数可选，表示当前的进制数，如不写则为10
         * 返回值：返回转换后的字符串
         */
        guid.prototype.hexadecimal = function (num, x, y) {
            if (y != undefined) {
                return parseint(num.tostring(), y).tostring(x);
            } else {
                return parseint(num.tostring()).tostring(x);
            }
        }

        /*
         * 功能：格式化32位的字符串为guid模式的字符串
         * 参数：第1个参数表示32位的字符串
         * 返回值：标准guid格式的字符串
         */
        guid.prototype.formatguid = function (guidstr) {
            var str1 = guidstr.slice(0, 8) + '-',
                str2 = guidstr.slice(8, 12) + '-',
                str3 = guidstr.slice(12, 16) + '-',
                str4 = guidstr.slice(16, 20) + '-',
                str5 = guidstr.slice(20);
            return str1 + str2 + str3 + str4 + str5;
        }
    }
}
var guidinstance;
function guid() {
    if (guidinstance == undefined) {
        guidinstance = new guid();
    }
    return guidinstance.newguid();
}


//转对象,支持字符串和对象参数
function objectparse(obj) {
    var thetype = typeof (obj);
    if (thetype == "undefined") {
        obj = {};
    }
    else if (thetype == "string") {
        try {
            var str = obj.trim();
            if (str.indexof("{") == 0 || str.indexof("[") == 0) {
                obj = eval("(" + str + ")");
            }
            else {
                obj = eval("(({" + str + "}))");
            }
        } catch (err) {
            alert(obj + "的objectparse转换失败，请检测格式!");
            throw new error("objectparse error!");
            //alert("错误信息: " + err.message );
            //obj = {};
        } finally {
        }
    }
    else if (thetype == "object") {
        return obj;
    }
    else {
        obj = {};
    }
    return obj;
}

//检测字符串是否是json格式
function isjson(str) {
    if (typeof str == 'string') {
        try {
            var obj = json.parse(str);
            if (typeof obj == 'object' && obj) {
                return true;
            } else {
                return false;
            }

        } catch (e) {
            return false;
        }
    }
}

function jsonparse(data) //转json，支持普通字符串，也支持js对象
{
    var thetype = typeof (data);
    if (data == undefined) {
        return undefined;
    }
    if (thetype == "object") {
        return data;
    }
    else if (thetype == "string") {
        try {
            var str = data.trim();
            if (str == "{}") {
                return undefined;
            }
            if (str.indexof("{") == 0 || str.indexof("[") == 0) //json对象
            {
                data = json.parse(str);
            }
            else {
                return data;
            }
        } catch (err) {
            alert(data + "的jsonparse转换失败，请检测格式!");
            //alert("错误信息: " + err.message );
            data = undefined;
        } finally {
        }
    }
    return data;
}

//对象转字符串，普通js对象会转成json格式字符串
function jsontostring(obj) {
    if (typeof (obj) == "object") {
        obj = json.stringify(obj)
    }
    return obj;
}

function jsonformat(s) {
    var newstr = "";
    for (var i = 0; i < s.length; i++) {
        c = s.charat(i);
        switch (c) {
            case '\"':
                newstr += "\\\"";
                break;
            case '\\':
                newstr += "\\\\";
                break;
            case '/':
                newstr += "\\/";
                break;
            case '\b':
                newstr += "\\b";
                break;
            case '\f':
                newstr += "\\f";
                break;
            case '\n':
                newstr += "\\n";
                break;
            case '\r':
                newstr += "\\r";
                break;
            case '\t':
                newstr += "\\t";
                break;
            default:
                newstr += c;
        }
    }
    return newstr;
}

function multipleselecttoinput(jqobj, tojqobj) //把多选select的值转到input表单中
{
    if (jqobj.length == 0) { alert("对象不存在!"); return; }
    if (tojqobj.length == 0) { alert("目标对象不存在!"); return; }
    var vals = "";
    var options = jqobj.children("option");
    for (k = 0; k < options.length; k++) {
        var val = options.eq(k).val();
        if (vals != "") {
            vals += ",";
        }
        if (val != "") {
            vals += val;
        }
    }
    tojqobj.val(vals);
}


//获取时间差，根据类型
function getdatediff(starttime, endtime, difftype) {
    starttime = starttime.replace(/-/g, "/");  //将xxxx-xx-xx的时间格式，转换为 xxxx/xx/xx的格式 
    endtime = endtime.replace(/-/g, "/");
    difftype = difftype.tolowercase();  //将计算间隔类性字符转换为小写 
    var stime = new date(starttime); //开始时间 
    var etime = new date(endtime); //结束时间 
    var divnum = 1;  //作为除数的数字 
    switch (difftype) {
        case "second":
            divnum = 1000;
            break;
        case "minute":
            divnum = 1000 * 60;
            break;
        case "hour":
            divnum = 1000 * 3600;
            break;
        case "day":
            divnum = 1000 * 3600 * 24;
            break;
        default:
            break;
    }
    return parseint((etime.gettime() - stime.gettime()) / parseint(divnum));
}


//获取时间差,结果为，3天，5小时，40分钟，50秒
function gettimediff(st, et) {
    var rv;
    var st = new date(st.replace(/-/g, '/'));			//开始时间转换为时间对象
    var et = new date(et.replace(/-/g, '/'));			//结束时间转换为时间对象
    var dt = (et - st) / 1000;					//得到时间差，转换为秒

    var rd = math.floor(dt / (60 * 60 * 24));			//得到天数
    var rh = math.floor((dt % (60 * 60 * 24)) / (60 * 60));		//得到小时
    var rm = math.floor(((dt % (60 * 60 * 24)) % (60 * 60)) / 60); 	//得到分钟
    var rs = (((dt % (60 * 60 * 24)) % (60 * 60)) % 60);		//得到秒
    rd = rd ? (rd + '天') : '';
    rh = rh ? (rh + '小时') : '';
    rm = rm ? (rm + '分钟') : '';
    rs = rs ? (rs + '秒') : '';
    rv = rd + rh + rm + rs;
    if (rv == "") {
        rv = "0秒";
    }
    return rv;
}

function datetostr(datetime) {
    var year = datetime.getfullyear();
    var month = datetime.getmonth() + 1;//js从0开始取
    var date = datetime.getdate();
    var hour = datetime.gethours();
    var minutes = datetime.getminutes();
    var second = datetime.getseconds();
    if (month < 10) {
        month = "0" + month;
    }
    if (date < 10) {
        date = "0" + date;
    }
    if (hour < 10) {
        hour = "0" + hour;
    }
    if (minutes < 10) {
        minutes = "0" + minutes;
    }
    if (second < 10) {
        second = "0" + second;
    }
    var time = year + "-" + month + "-" + date + " " + hour + ":" + minutes + ":" + second; //2009-06-12 17:18:05
    return time;
}

//数字转中文
function moneytochinese(money) {
    var cnnums = new array("零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"); //汉字的数字
    var cnintradice = new array("", "拾", "佰", "仟"); //基本单位
    var cnintunits = new array("", "万", "亿", "兆"); //对应整数部分扩展单位
    var cndecunits = new array("角", "分", "毫", "厘"); //对应小数部分单位
    var cninteger = "整"; //整数金额时后面跟的字符
    var cnintlast = "元"; //整型完以后的单位
    var maxnum = 999999999999999.9999; //最大处理的数字

    var integernum; //金额整数部分
    var decimalnum; //金额小数部分
    var chinesestr = ""; //输出的中文金额字符串
    var parts; //分离金额后用的数组，预定义

    if (money == "") {
        return "";
    }
    money = parsefloat(money);
    //alert(money);
    if (money >= maxnum) {
        this.alert('超出最大处理数字');
        return "";
    }
    if (money == 0) {
        chinesestr = cnnums[0] + cnintlast + cninteger;
        //document.getelementbyid("show").value=chinesestr;
        return chinesestr;
    }
    money = money.tostring(); //转换为字符串
    if (money.indexof(".") == -1) {
        integernum = money;
        decimalnum = '';
    } else {
        parts = money.split(".");
        integernum = parts[0];
        decimalnum = parts[1].substr(0, 4);
    }
    if (parseint(integernum, 10) > 0) {//获取整型部分转换
        zerocount = 0;
        intlen = integernum.length;
        for (i = 0; i < intlen; i++) {
            n = integernum.substr(i, 1);
            p = intlen - i - 1;
            q = p / 4;
            m = p % 4;
            if (n == "0") {
                zerocount++;
            } else {
                if (zerocount > 0) {
                    chinesestr += cnnums[0];
                }
                zerocount = 0; //归零
                chinesestr += cnnums[parseint(n)] + cnintradice[m];
            }
            if (m == 0 && zerocount < 4) {
                chinesestr += cnintunits[q];
            }
        }
        chinesestr += cnintlast;
        //整型部分处理完毕
    }
    if (decimalnum != '') {//小数部分
        declen = decimalnum.length;
        for (i = 0; i < declen; i++) {
            n = decimalnum.substr(i, 1);
            if (n != '0') {
                chinesestr += cnnums[number(n)] + cndecunits[i];
            }
        }
    }
    if (chinesestr == '') {
        chinesestr += cnnums[0] + cnintlast + cninteger;
    }
    else if (decimalnum == '') {
        chinesestr += cninteger;
    }
    return chinesestr;

}

/*获取url参数*/
function request(param, url) //获取url中参数
{
    if (param == undefined) {
        return "";
    }

    if (url == null) { url = location.href; }
    var parastring = url.substring(url.indexof("?") + 1, url.length).split("&");
    var paraobj = {}
    var returnvalue = "";
    for (var i = 0; i < parastring.length; i++) {
        var item = parastring[i].split("=");
        if (item.length == 2 && param.tolowercase() == item[0].tolowercase()) {
            if (returnvalue != "") {
                returnvalue += ",";
            }
            returnvalue += item[1];
        }
    }
    if (typeof (returnvalue) == "undefined") {
        return "";
    }
    else {
        return decodeuricomponent(returnvalue);
    }
}

///获取url中参数,toobject:是否转为对象
function getquerystring(toobject) {
    //取得查询字符串并去掉开头的问号
    var qs = (location.search.length > 0 ? location.search.substring(1) : ""),
        //保存数据的对象
        args = {},
        params = [],
        //取得每一项
        items = qs.length ? qs.split("&") : [],
        item = null,
        name = null,
        value = null,
        //在 for 循环中使用
        i = 0,
        len = items.length;
    //逐个将每一项添加到 args 对象中
    for (i = 0; i < len; i++) {
        item = items[i].split("=");
        name = item[0];
        value = item[1];
        if (name.length) {
            if (toobject) {
                name = decodeuricomponent(name);
                value = decodeuricomponent(value);
                args[name] = value;
            }
            else {
                name = encodeuricomponent(name);
                value = encodeuricomponent(value);
                params.push(name + '=' + value);
            }
        }
    }
    if (toobject) {
        return args;
    }
    else {
        return params.join('&');
    }
}


if (!array.prototype.map) //低版本ie兼容
    array.prototype.map = function (fn, scope) {
        var result = [], ri = 0;
        for (var i = 0, n = this.length; i < n; i++) {
            if (i in this) {
                result[ri++] = fn.call(scope, this[i], i, this);
            }
        }
        return result;
    };

if (!array.prototype.foreach) { //低版本ie兼容
    array.prototype.foreach = function foreach(callback, thisarg) {
        var t, k;
        if (this == null) {
            throw new typeerror("this is null or not defined");
        }
        var o = object(this);
        var len = o.length >>> 0;
        if (typeof callback !== "function") {
            throw new typeerror(callback + " is not a function");
        }
        if (arguments.length > 1) {
            t = thisarg;
        }
        k = 0;
        while (k < len) {

            var kvalue;
            if (k in o) {
                kvalue = o[k];
                callback.call(t, kvalue, k, o);
            }
            k++;
        }
    };
}

//根据条件查找集合中符合条件的数据
if (!array.prototype.find) {
    array.prototype.find = function (predicate) {
        'use strict';
        if (this == null) {
            throw new typeerror("this is null or not defined");
        }
        if (typeof predicate !== 'function') {
            throw new typeerror('predicate must be a function');
        }
        var list = object(this);
        var length = list.length >>> 0;
        var thisarg = arguments[1];
        var value;

        for (var i = 0; i < length; i++) {
            value = list[i];
            if (predicate.call(thisarg, value, i, list)) {
                return value;
            }
        }
        return undefined;
    };
}

//根据条件查找位置
if (!array.prototype.findindex) {
    array.prototype.findindex = function (predicate) {
        'use strict';
        if (this == null) {
            throw new typeerror("this is null or not defined");
        }
        if (typeof predicate !== 'function') {
            throw new typeerror('predicate must be a function');
        }
        var list = object(this);
        var length = list.length >>> 0;
        var thisarg = arguments[1];
        var value;

        for (var i = 0; i < length; i++) {
            value = list[i];
            if (predicate.call(thisarg, value, i, list)) {
                return i;
            }
        }
        return -1;
    };
}
//根据条件移除
if (!array.prototype.remove) {
    array.prototype.remove = function (predicate) {
        if (this == null) {
            throw new typeerror("this is null or not defined");
        }
        if (typeof predicate !== 'function') {
            throw new typeerror('predicate must be a function');
        }
        var list = object(this);
        var thisarg = arguments[1];
        var item;
        for (var i = 0; i < list.length; i++) {
            item = list[i];
            if (predicate.call(thisarg, item, i, list)) {
                list.splice(i,1);
            }
        }
    };
}
//es6的 incluses
if (!array.prototype.includes) {
    object.defineproperty(array.prototype, 'includes', {
        value: function (valuetofind, fromindex) {
            if (this == null) {
                throw new typeerror('"this" is null or not defined');
            }
            // 1. let o be ? toobject(this value).
            var o = object(this);
            // 2. let len be ? tolength(? get(o, "length")).
            var len = o.length >>> 0;
            // 3. if len is 0, return false.
            if (len === 0) {
                return false;
            }
            // 4. let n be ? tointeger(fromindex).
            //    (if fromindex is undefined, this step produces the value 0.)
            var n = fromindex | 0;
            // 5. if n ≥ 0, then
            //  a. let k be n.
            // 6. else n < 0,
            //  a. let k be len + n.
            //  b. if k < 0, let k be 0.
            var k = math.max(n >= 0 ? n : len - math.abs(n), 0);
            function samevaluezero(x, y) {
                return x === y || (typeof x === 'number' && typeof y === 'number' && isnan(x) && isnan(y));
            }
            // 7. repeat, while k < len
            while (k < len) {
                // a. let elementk be the result of ? get(o, ! tostring(k)).
                // b. if samevaluezero(valuetofind, elementk) is true, return true.
                if (samevaluezero(o[k], valuetofind)) {
                    return true;
                }
                // c. increase k by 1. 
                k++;
            }
            // 8. return false
            return false;
        }
    });
}

//如果没有加载jquery，则加载ajax.js
if (window.jquery == undefined) {
   document.write("<script src=\"/frameui/1.0/ajax.js\"></script>");
}

function ajax(params, completecallback)
{
    //对httpcode进行处理
    function httpcodehandle(responsedata) {
        if (isnullorempty(responsedata)) { return;}
        var stopexecute = false;//是否终止调用方继续执行
        var httpcode = responsedata.httpcode;
        var msg = responsedata.msg;
        if (httpcode == undefined) {
            return;
        }
        if (!msg) {
            msg = "对不起，权限不足！";
        }
        var redirecturl;
        var data = responsedata.data;
        if (data) {
            redirecturl = data.redirecturl;//获取跳转地址
        }
        if (httpcode == 401 || httpcode == 403) //401：未登录或登录超时 ，403：没有权限操作
        {
            if (redirecturl != undefined && params.type.tolowercase() == "get") {
                window.location.replace(redirecturl);
            }
            else {
                if (vue && element) {
                    new vue({
                        created: function () {
                            vue.$notify({
                                title: '提示',
                                message: msg,
                                type: 'error',
                                position: 'top-left'
                            });
                        }
                    })
                }
                else {
                    alert(msg);
                }
            }
            stopexecute = true;
        }
        return stopexecute;
    }
    var defaultparams = {
        url: "",
        data: {},
        headers: {},
        type: "get",
        async: true,
        cache: false,
        xhrfields: { withcredentials: true },
        ifmodified: true,
        datatype: "json",
        traditional:false, //进行深度序列化
        timeout: 0,//单位为秒，0代表永远不超时
        jsonp: "jsonpcallback",//服务端用于接收callback调用的function名的参数  
        contenttype: "application/x-www-form-urlencoded;charset=utf-8", //可选：application/json;charset=utf-8,application/x-www-form-urlencoded;charset=utf-8
        beforesend: function (xhr) { },
        success: function (data, xhr) { },
        error: function (xhr) { },
        complete: function (xhr) { }
    };
    var params = extend(defaultparams, params);
    if (params.contenttype==false) {
        //上传fordata时需要设置contenttype为flase
    } else
    {
        if (params.contenttype.indexof("json") > 0) {
            params.data = json.stringify(params.data);
        }
    }
    return $.ajax(params).done(function (res) {
        httpcodehandle(res);
    }).fail(function () {
        console.log("请求出错或未返回任何数据!")
    });
}