/* pageadmin cms js基础库 */
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.length = function () //获取字符长度,中文站两个字符
{
    return this.replace(/[^\x00-\xff]/g, "**").length;
}

string.prototype.left = function (len) //左边截取字段数
{
    var str = this;
    if (isnan(len) || len == null) {
        len = str.length;
    }
    else {
        if (parseint(len) < 0 || parseint(len) > str.length) {
            len = str.length;
        }
    }
    return str.substr(0, len);
}

string.prototype.right = function (len) //右边截取字段数
{
    var str = this;
    if (isnan(len) || len == null) {
        len = str.length;
    }
    else {
        if (parseint(len) < 0 || parseint(len) > str.length) {
            len = str.length;
        }
    }
    return str.substring(str.length - len, str.length);
}

//只对字符值进行比较，相同等返回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));
    }
}

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);
}

function isusername(str) //是否是用户名由数字、字母和下划线汉字组成,不能为纯数字，不能包含@,便于后台的
{
    if (str == undefined) { 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,15}$/;
    return reg.test(str);
}


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) //是否是图片地址
{
    if (path == undefined) { return false; }
    var strfilter = ".jpeg|.gif|.jpg|.png|.bmp|"
    if (path.indexof(".") > -1) {
        var p = path.lastindexof(".");
        var strpostfix = path.substring(p, path.length) + '|';
        strpostfix = strpostfix.tolowercase();
        if (strfilter.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(str) //字符串用半角逗号隔开，过滤重复和空字符
{
    if (str == undefined) { return ""; }
    var arr = str.split(",");
    var result = [], hash = {};
    for (var i = 0, elem; (elem = arr[i]) != null; i++) {
        if (!hash[elem] && elem != "") {
            result.push(elem);
            hash[elem] = true;
        }
    }
    return result;
}

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

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" + type, 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.call();
        }
    }
    else {
        newscript.onreadystatechange = function () {
            if (script.readystate == "loaded" || script.readstate == 'complate') {
                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;
}


//转对象,支持字符串和对象参数
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;
}

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 decodeuri(returnvalue);
    }
}

function ajax(params, completecallback) {
    var result;
    var defaultparams = {
        url: "",
        data: {},
        headers: {},
        type: "get",
        async: true,
        cache: false,
        ifmodified: true,
        datatype: "json",
        traditional: true, //不进行深度序列化
        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);
    var async = params.async;
    var type = (params.type || 'get').touppercase();
    var cache = params.cache;
    var headers = params.headers;
    var error = params.error;
    if (array.isarray(params.data)) {
        params.data = { data: json.stringify(params.data)};
    }
    if (params.datatype == "jsonp") {
        jsonp();
    }
    else {
        json();
    }
    function json() { // ajax请求   
        var xhr = null;
        // 第一步：实例化xmlhttprequest对象   
        if (window.xmlhttprequest) {
            // code for ie7, firefox, opera, etc.
            xhr = new xmlhttprequest();
        } else {
            xhr = new activexobjcet("microsoft.xmlhttp");//ie6及其以下版本      
        };

        /*第二步：指定请求
        * open([请求方式],[url],[boolean(同步或异步请求，默认false)]);
        * 调用open()方法并不会真正发送请求，而只是启动一个请求以备发送。
        * 
        * 第三步：设置请求头(post请求)
        * 第四步：发送请求
        * */

        if (params.type.tolowercase() == "get") {
            // 三个参数：请求方式、请求地址(get方式时，传输数据是加在地址后的)、是否异步请求(同步请求的情况极少)；
            xhr.open(params.type, geturl(), async);
            setheader();
            xhr.send(null);
        } else {
            xhr.open(params.type, params.url, async);
            setheader();
            var serverdata = params.data;
            if (params.contenttype.indexof("json") > 0)
            {
                serverdata = json.stringify(serverdata);
            }
            else
            {
                serverdata = formatparams(serverdata);
            }
            xhr.send(serverdata);
        }
        function setheader()
        {
            for (var name in headers) {
                xhr.setrequestheader(name, headers[name]);
            }
            xhr.setrequestheader("x-requested-with", "xmlhttprequest");//兼容mvc的isajaxrequest 
            if (!headers.hasownproperty("content-type") && params.type=="post") {
                xhr.setrequestheader('content-type', params.contenttype);
            }
        }

        // 第五步：监听响应，只要readystate的值变化，就会调用readystatechange事件 
        function statechange() {
            //readystate属性表示请求/响应过程的当前活动阶段，4为完成，已经接收到全部响应数据
            if (xhr.readystate == 4) {
                var status = xhr.status;
                if (status >= 200 && status < 300) {    //status：响应的http状态码，以2开头的都是成功
                    // 判断接受数据的内容类型  
                    var type = xhr.getresponseheader('content-type');
                    if (type==undefined)
                    {
                       result = xhr.responsetext;
                    }
                    else if(type.indexof('xml')!== -1 && xhr.responsexml) {
                        result = xhr.responsexml; //document对象响应   
                    }
                    else{
                        result =jsonparse(xhr.responsetext); //字符串响应   
                    };
                    params.success && params.success(result, xhr);  // 成功回调函数  
                    params.complete && params.complete(xhr);
                    completecallback && completecallback(xhr);
                }
                else {
                    params.error && params.error(xhr);
                    params.complete && params.complete(xhr);
                    completecallback && completecallback(xhr);
                    throw "ajax请求：" + params.url + "出现" + xhr.status + "错误";
                }
            }
        };
        if (params.timeout) {
            settimeout(function () {
                xhr.abort();
            }, params.timeout * 1000);
        }
        if (async)
        {
            xhr.onreadystatechange = statechange;
        }
        else
        {
          statechange();
        }
        return result;
    }
    // jsonp请求   
    function jsonp(params) {
        //创建script标签并加入到页面中   
        var callbackname = params.jsonp;
        var head = document.getelementsbytagname('head')[0];
        // 设置传递给后台的回调参数名   
        params.data['callback'] = callbackname;
        var script = document.createelement('script');
        head.appendchild(script);
        //创建jsonp回调函数   
        window[callbackname] = function (json) {
            head.removechild(script);
            cleartimeout(script.timer);
            window[callbackname] = null;
            result = json;
            params.success && params.success(json);
            params.complete && params.complete(json);
            completecallback && completecallback(json);
        };
        //发送请求   
        script.src = geturl();
        //为了得知此次请求是否成功，设置超时处理   
        if (params.timeout * 1000) {
            script.timer = settimeout(function () {
                window[callbackname] = null;
                head.removechild(script);
                params.error && params.error({
                    message: '超时'
                });
            }, params.timeout);
        }
    };
    //格式化参数
    function geturl() {
        var url = params.url;
        var pararmstring = formatparams(params.data);
        if (url.indexof("?") > 0)
        {
           url += "&";
        }
        else
        {
            url += "?";
        }
        return url + pararmstring;
    }
    //格式化参数
    function formatparams(data) {
        var arr = [];
        for (var name in data) {
            var val = data[name];
            if (val == null || val == undefined)
            {
                val = "";
            }
            arr.push(encodeuricomponent(name) + '=' + encodeuricomponent(val));
        };
        // 添加一个随机数参数，防止缓存   
        if (!cache) {
            arr.push('_r=' + random());
        }
        return arr.join('&');
    }
    // 获取随机数   
    function random() {
        return math.floor(math.random() * 10000 + 500);
    }
    return result;
}

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++;
        }
    };
}

//根据值删除，只对值类型有效
array.prototype.remove = function (val) {
    for (var i = 0; i < this.length; i++)
    {
        var item = this[i];
        if (equals(item, val))
        {
            this.splice(i, 1);
        }
    }
};

//数组中是否包含对应值,只对值类型有效
array.prototype.contains = function (val) {
    if (val == undefined || val == null)
    {
        val = "";
    }
    for (var i = 0; i < this.length; i++) {
        if (equals(this[i],val)){
            return true;
        }
    }
    return false
};

//json数组中查找
array.prototype.searchkey = function (key, keyvalue, searchkey) {
    for (var i = 0; i < this.length; i++) {
        if (this[i][key] == keyvalue) {
            return this[i][searchkey];
        }
        else if (array.isarray(this[i]["children"])) {
            var findvalue;
            findvalue = this[i]["children"].searchkey(key, keyvalue, searchkey);
            if (findvalue != null) {
                return findvalue;
            }
        }
    }
    return null;
};