MyException - 我的异常网
当前位置:我的异常网» JavaScript » js常用工具库XCLJsTool v1.0公布

js常用工具库XCLJsTool v1.0公布

www.MyException.Cn  网友分享于:2014-12-23  浏览:0次
js常用工具库XCLJsTool v1.0发布

最近有空,整了一个js的工具库,还没有正式用于项目中,自己也没有时间写测试用例,想了一下,还是贴出来给大家看看,如果有问题,请留言,非常感谢!项目我放在了github上面,会经常更新的,过段时间会发布一版!


/**
 * 欢迎使用本程序,您可以任意修改、复制、分享本程序所有代码,只需要保留本注释即可,谢谢!
 * 项目地址:<span style="color:#ff0000;">https://github.com/xucongli1989/XCLJsTool</span>
 * By:XCL @ 2014.11 in Shanghai China
 * 使用说明:
 * 本程序部分功能依赖于jquery插件,本项目中使用的是jquery-1.11.1
 */

(function (win){
    "use strict";
    
    if(win.XCLJsTool){
        return win.XCLJsTool;
    }
    
    var doc = win.document;
    var $ = $ || win.jQuery || {};

    var XCLJsTool={
        Version:"1.0",
        /**
         * 公共model
         */
        Models:{},
        /**
         * 公共方法
         */    
        Common:{},
        /**
         * Dom操作
         */    
        Dom:{},
        /**
         * 正则相关
         */    
        Regex:{},
        /**
         * 字符串操作相关
         */    
        String:{},
        /**
         * Cookie操作相关
         */    
        Cookie:{},
        /**
         * Http操作相关
         */    
        Http:{},
        /**
         * Ajax操作相关
         */    
        Ajax:{},
        /**
         * 数据处理操作相关
         */    
        Data:{},
        /**
         * 日期时间处理相关
         */    
        Date:{},
        /**
         * 事件相关
         */
        Events:{},
        /**
         * 浏览器相关
         */
        Browser:{},
        /**
         * 移动端相关
         */
        Mobile:{},
        /**
         * 数学计算相关
         */
        Math:{},
        /**
         * 随机数相关
         */
        Random:{},
        /**
         * 数组相关
         */
        Array:{}
    };


    XCLJsTool.Models={
        /**
         * key value 模型
         * @param {string} key
         * @param {object} value
         */
        Dictionary:function(key,value){
            this.key=key;
            this.value=value;
        }
    };



    XCLJsTool.Common = {
        /**
         * 向document输出字符串
         * @param {string} str
         */
        Write: function (str) {
            doc.write(str);
        }
    };

    XCLJsTool.Dom = {
        /**
         * 根据id,获取或设置指定元素的value
         * @param {string} id 元素的id值
         * @value {string} value 要设置的value值(可选)
         */
        Val: function (id,value) {
            var obj = doc.getElementById(id);
            if(arguments.length===1){
                if (obj) {
                    return obj.value;
                }
                return null;
            }else if(arguments.length===2){
                if (obj) {
                    obj.value = val;
                }                
            }
        },
        /**
         * 根据指定value,选中select对象中option
         * @param {object} $selectObj
         * @param {string} val
         */
        SelectOption: function ($selectObj, val) {
            $selectObj.find("option[value='" + val + "']").prop({ "selected": true });
        },
        /**
         * 向form追加hidden,key为name和id
         * @param {object} $container 被追加的容器(默认为form对象)
         * @param {json array} data json数组,如[{key:key1,value:value1},{key:key2,value:value2}]
         */
        AddHiddens:function($container,data){
            $container=$container || $("form");
            if(data && data.length>0){
                var html="";
                for(var i=0;i<data.length;i++){
                    html+=(XCLJsTool.String.Format("<input type='hidden' name='{0}' id='{0}' value='{1}' />",data[i].key,data[i].value));
                }
                $container.append(html);
            }
        }
    };

    /**
     * 正则常量
     */
    XCLJsTool.Regex.Regexs = {
        /**
         * Email
         * @type RegExp
         */
        Email: /^(?:\w+\.?)*\w+@(?:\w+\.)+\w+$/,
        /**
         * Url
         * @type RegExp
         */
        Url: /(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/,
        /**
         * 中文
         * @type RegExp
         */
        Chinese: /[\u4e00-\u9fa5]/,
        /**
         * 双字节
         * @type RegExp
         */
        DoubleByte: /[^\x00-\xff]/,
        /**
         * 负整数
         * @type RegExp
         */
        NegativeInt: /^-[0-9]*[1-9][0-9]*$/,
        /**
         * 非负整数
         * @type RegExp
         */
        NotNegativeInt: /^d+$/,
        /**
         * 正整数
         * @type RegExp
         */
        PositiveInt: /^[0-9]*[1-9][0-9]*$/,
        /**
         * 非正整数
         * @type RegExp
         */
        NotPositiveInt: /^((-d+)|(0+))$/,
        /**
         * 整数
         * @type RegExp
         */
        Int: /^-?d+$/,
        /**
         * 非负浮点
         * @type RegExp
         */
        NotNegativeFloat: /^d+(.d+)?$/,
        /**
         * 正浮点
         * @type RegExp
         */
        PositiveFloat: /^((0-9)+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*)$/,
        /**
         * 非正浮点
         * @type RegExp
         */
        NotPositiveFloat: /^((-d+.d+)?)|(0+(.0+)?)$/,
        /**
         * 负浮点数
         * @type RegExp
         */
        NegativeFloat:/^(-(((0-9)+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*)))$/,
        /**
         * 英文字母
         * @type RegExp
         */
        English:/^[A-Za-z]+$/,
        /**
         * 英文大写字母
         * @type RegExp
         */
        EnglishUpper:/^[A-Z]+$/,
        /**
         * 英文小写字母
         * @type RegExp
         */
        EnglishLower:/^[a-z]+$/,
        /**
         * 英文字母+数字组合
         * @type RegExp
         */
        EnglishOrNumber:/^[A-Za-z0-9]+$/,
        /**
         * 英文字母+数字+下划线组合
         * @type RegExp
         */
        EnglishOrNumberOrUnderline:/^w+$/,
        /**
         * html
         * @type RegExp
         */
        Html:/<(.*)>.*<\/\1>|<(.*) \/>/,
        /**
         * 国内电话号码
         * @type RegExp
         */
        ChinaTel:/\d{3}-\d{8}|\d{4}-\d{7}/,
        /**
         * 国内邮编
         * @type RegExp
         */
        ChinaPostCode:/[1-9]\d{5}(?!\d)/,
        /**
         * 国内身份证号
         * @type RegExp
         */
        ChinaIDCard:/(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
    };
    /**
     * 正则验证
     */
    XCLJsTool.Regex.ValidRegex = {
        /**
         * 验证指定值是否与正则匹配
         * @param {RegExp} regex
         * @param {string} str
         * @returns {bool}
         */
        IsValid: function (regex, str) {
            return regex.test(str);
        }
    };

    XCLJsTool.String = {
        /**
         * 去左右空格
         * @param {string} str
         * @returns {string}
         */
        Trim: function (str) {
            return str.replace(/^\s+|\s+$/g, "");
        },
        /**
         * 去左空格
         * @param {string} str
         * @returns {string}
         */
        LTrim: function (str) {
            return str.replace(/^\s+/, "");
        },
        /**
         * 去右空格
         * @param {string} str
         * @returns {string}
         */
        RTrim: function (str) {
            return str.replace(/\s+$/, "");
        },
        /**
         * 格式输出
         * @param {string} str
         * @returns {string}
         */
        Format: function (str) {
            if (arguments.length <= 1) {
                return str;
            }
            var tokenCount = arguments.length - 2;
            for (var token = 0; token <= tokenCount; token++) {
                str = str.replace(new RegExp("\\{" + token + "\\}", "gi"), arguments[token + 1]);
            }
            return str;
        },
        /**
         * 指定源字符串sourceStr中是否包含str字符串
         * @param {string} sourceStr 源字符串
         * @param {string} str 要查找的字符串
         * @param {Boolean} isIgnoreCase 是否忽略大小写
         * @returns {Boolean}
         */
        Contains:function(sourceStr, str,isIgnoreCase){
            if(sourceStr){
                if(isIgnoreCase){
                    sourceStr=sourceStr.toUpperCase();
                    str=str.toUpperCase();
                }
                return sourceStr.indexOf(str)>=0;
            }else{
                return false;
            }
        }
    };

    XCLJsTool.Cookie = {
        /**
         * 根据cookie名,获取cookie
         * @param {string} name
         * @returns {string}
         */
        GetCookie: function (name) {
            var nameEQ = name + "=";
            var ca = doc.cookie.split(';');
            for (var i = 0; i < ca.length; i++) {
                var c = ca[i];
                while (c.charAt(0) == ' ')
                    c = c.substring(1, c.length);
                if (c.indexOf(nameEQ) == 0)
                    return c.substring(nameEQ.length, c.length);
            }
            return null;
        },
        /**
         * 设置cookie
         * @param {string} name cookie名
         * @param {string} value cookie值
         * @param {int} days 过期时间(天数)
         */
        SetCookie: function (name, value, days) {
            if (days) {
                var date = new Date();
                date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
                var expires = "; expires=" + date.toGMTString();
            }
            else var expires = "";
            doc.cookie = name + "=" + value + expires + "; path=/";
        },
        /**
         * 删除cookie
         * @param {string} name 名称
         */
        DelCookie: function (name) {
            this.SetCookie(name, "", -1);
        }
    };

    XCLJsTool.Http = {
        /**
         * 获取HttpRequest对象
         * @returns {XMLHttpRequest|ActiveXObject|Boolean}
         */
        GetHttpRequestObject: function () {
            var xmlhttp = false;

            try {
                xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
            } catch (e) {
                try {
                    xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
                } catch (E) {
                    xmlhttp = false;
                }
            }

            if (!xmlhttp && typeof XMLHttpRequest != 'undefined') {
                try {
                    xmlhttp = new XMLHttpRequest();
                } catch (e) {
                    xmlhttp = false;
                }
            }
            if (!xmlhttp && win.createRequest) {
                try {
                    xmlhttp = win.createRequest();
                } catch (e) {
                    xmlhttp = false;
                }
            }
            return xmlhttp;
        }
    };

    XCLJsTool.Ajax = {
        /**
         * 获取同步请求的数据
         * @param {string} url 请求地址
         * @param {json} paramData 参数
         * @returns {string}
         */
        GetSyncData: function (url, paramData) {
            var result = "";
            $.ajax({
                url: url,
                data: paramData,
                async: false,
                success: function (data) {
                    result = data;
                }
            });
            return result;
        },
        /**
         * 获取同步请求的json数据
         * @param {string} url 请求地址
         * @param {json} paramData 参数
         * @returns {json}
         */
        GetSyncJsonData: function (url, paramData) {
            var _this = this;
            var result = _this.GetData(url, paramData);
            if (result) {
                return $.parseJSON(result);
            } else {
                return null;
            }
        }
    };

    XCLJsTool.Data = {
        /**
         * 将值转为int型,若失败,则返回0
         * @param {string} val
         * @returns {int}
         */
        GetInt: function (val) {
            return this.GetIntDefault(val, 0);
        },
        /**
         * 将值转为int型,若失败,则返回null
         * @param {string} val
         * @returns {int?}
         */
        GetIntNull: function (val) {
            return this.GetIntDefault(val, null);
        },
        /**
         * 将值转为int型,若失败,则返回defaultValue
         * @param {string} val
         * @param {int} defaultValue
         * @returns {int}
         */
        GetIntDefault: function (val, defaultValue) {
            return parseInt(val, 10) || defaultValue;
        },
        /**
         * 将值转为float型,若失败,则返回0
         * @param {string} val
         * @returns {float}
         */
        GetFloat: function (val) {
            return this.GetFloatDefault(val, 0);
        },
        /**
         * 将值转为float型,若失败,则返回null
         * @param {string} val
         * @returns {float?}
         */
        GetFloatNull: function (val) {
            return this.GetFloatDefault(val, null);
        },
        /**
         * 将值转为float型,若失败,则返回defaultValue
         * @param {string} val
         * @param {float} defaultValue
         * @returns {float}
         */
        GetFloatDefault: function (val, defaultValue) {
            return parseFloat(val) || defaultValue;
        },
        /**
         * 将值转为object(eval)
         * @param {string} val
         * @returns {object}
         */
        GetObject: function (val) {
            return eval(val);
        },
        /**
         * 判断val是否为数字
         * @param {object} val
         * @returns {Boolean}
         */
        IsNumber: function (val) {
            return (typeof(val) === 'number' || typeof(val) === 'string') && val !== '' && !isNaN(val);
        },
        /**
         * 判断指定值是否为一个对象
         * @param {object} val
         * @returns {Boolean}
         */
        IsObject: function (val) {
            return val !== null && typeof val === 'object';
        },
        /**
         * 判断指定值是否为Date对象
         * @param {object} val
         * @returns {Boolean|Date}
         */
        IsDate: function (val) {
            return val instanceof Date && !isNaN(val.valueOf());
        },
        /**
         * 判断指定值是否为数组
         * @param {object} val
         * @returns {Boolean}
         */
        IsArray: function (val) {
            return Object.prototype.toString.call(val) === "[object Array]";
        },
        /**
         * 判断指定值为null或为空字符串
         * @param {string} val
         * @returns {Boolean}
         */
        IsNullOrEmpty: function (val) {
            return null===val || val==="";
        },
        /**
         * 判断指定值为null,或为空字符串,或为空白字符串
         * @param {string} val
         * @returns {Boolean}
         */
        IsNullOrWhiteSpace:function (val){
            return this.IsNullOrEmpty(XCLJsTool.String.Trim(val));
        },
        /**
         * 判断指定值是否为html元素
         * @param {object} val
         * @returns {obj|Boolean}
         */
        IsElement: function (val) {
             return typeof HTMLElement === "object" ? o instanceof HTMLElement :  o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName==="string";
        },
        /**
         * 判断指定值是否为function
         * @param {object} val
         * @returns {Boolean}
         */
        IsFunction: function (val) {
            return Object.prototype.toString.call(val) == '[object Function]';
        },
        /**
         * 判断指定值是否为String
         * @param {object} val
         * @returns {Boolean}
         */
        IsString: function (val) {
            return typeof val == 'string' || val instanceof String;
        },
        /**
         * 判断指定字符串是否为"true"
         * @param {string} val
         * @returns {bool}
         */
        IsBoolean: function (val) {
            return /^true$/i.test(val);
        },
        /**
         * 判断指定值是否为RegExp对象
         * @param {object} val
         * @returns {bool}
         */
        IsRegExp: function (val) {
            return val && val instanceof RegExp;
        },
        /**
         * 判断指定值是否为NaN
         * @param {object} val
         * @returns {Boolean}
         */
        IsNaN: function (val) {
            return isNaN(val);
        },
        /**
         * 判断指定值是否为null
         * @param {object} val
         * @returns {Boolean}
         */
        IsNull: function (val) {
            return val===null;
        },
        /**
         * 判断指定值是否为undefined
         * @param {object} val
         * @returns {Boolean}
         */
        IsUndefined: function (val) {
            return val===undefined || typeof(val)==="undefined";
        },
        /**
         * 指定值是否全部为大写
         * @param {string} val
         * @returns {Boolean}
         */
        IsUpper:function (val){
            return val.toUpperCase()===val;
        },
        /**
         * 指定值是否全部为小写
         * @param {string} val
         * @returns {Boolean}
         */
        IsLower:function(val){
            return val.toLowerCase()===val;
        }
    };

    XCLJsTool.Date = {
        /**
         * 是否为int(私有)
         * @param {string} val
         * @returns {Boolean}
         */
        _isInteger: function (val) {
            var digits = "1234567890";
            for (var i = 0; i < val.length; i++) {
                if (digits.indexOf(val.charAt(i)) == -1) { return false; }
            }
            return true;
        },
        /**
         * 获取int(私有)
         * @param {string} str
         * @param {int} i
         * @param {int} minlength
         * @param {int} maxlength
         */
        _getInt: function (str, i, minlength, maxlength) {
            var _this = this;
            for (var x = maxlength; x >= minlength; x--) {
                var token = str.substring(i, i + x);
                if (token.length < minlength) { return null; }
                if (_this._isInteger(token)) { return token; }
            }
            return null;
        },
        /**
         * 月份名数组
         * @type Array
         */
        MONTH_NAMES: new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'),
        /**
         * 星期名数组
         * @type Array
         */
        DAY_NAMES: new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'),
        LZ: function (x) { return (x < 0 || x > 9 ? "" : "0") + x },
        /**
         * 格式化date
         * @param {Date} date
         * @param {string} format
         * @returns {String}
         */
        FormatDate: function (date, format) {
            var _this = this;
            format = format + "";
            var result = "";
            var i_format = 0;
            var c = "";
            var token = "";
            var y = date.getYear() + "";
            var M = date.getMonth() + 1;
            var d = date.getDate();
            var E = date.getDay();
            var H = date.getHours();
            var m = date.getMinutes();
            var s = date.getSeconds();
            var yyyy, yy, MMM, MM, dd, hh, h, mm, ss, ampm, HH, H, KK, K, kk, k;
            // Convert real date parts into formatted versions
            var value = new Object();
            if (y.length < 4) { y = "" + (y - 0 + 1900); }
            value["y"] = "" + y;
            value["yyyy"] = y;
            value["yy"] = y.substring(2, 4);
            value["M"] = M;
            value["MM"] = _this.LZ(M);
            value["MMM"] = _this.MONTH_NAMES[M - 1];
            value["NNN"] = _this.MONTH_NAMES[M + 11];
            value["d"] = d;
            value["dd"] = _this.LZ(d);
            value["E"] = _this.DAY_NAMES[E + 7];
            value["EE"] = _this.DAY_NAMES[E];
            value["H"] = H;
            value["HH"] = _this.LZ(H);
            if (H == 0) { value["h"] = 12; }
            else if (H > 12) { value["h"] = H - 12; }
            else { value["h"] = H; }
            value["hh"] = _this.LZ(value["h"]);
            if (H > 11) { value["K"] = H - 12; } else { value["K"] = H; }
            value["k"] = H + 1;
            value["KK"] = _this.LZ(value["K"]);
            value["kk"] = _this.LZ(value["k"]);
            if (H > 11) { value["a"] = "PM"; }
            else { value["a"] = "AM"; }
            value["m"] = m;
            value["mm"] = _this.LZ(m);
            value["s"] = s;
            value["ss"] = _this.LZ(s);
            while (i_format < format.length) {
                c = format.charAt(i_format);
                token = "";
                while ((format.charAt(i_format) == c) && (i_format < format.length)) {
                    token += format.charAt(i_format++);
                }
                if (value[token] != null) { result = result + value[token]; }
                else { result = result + token; }
            }
            return result;
        },
        /**
         * 根据指定格式,返回 1970 年 1 月 1 日至val的毫秒数
         * @param {string} val
         * @param {string} format
         * @returns {Number}
         */
        GetDateFromFormat: function (val, format) {
            var _this=this;
            val = val + "";
            format = format + "";
            var iVal = 0;
            var iFormat = 0;
            var c = "";
            var token = "";
            var token2 = "";
            var x, y;
            var now = new Date();
            var year = now.getYear();
            var month = now.getMonth() + 1;
            var date = 1;
            var hh = 0;
            var mm = 0;
            var ss = 0;
            var ampm = "";

            while (iFormat < format.length) {
                // Get next token from format string
                c = format.charAt(iFormat);
                token = "";
                while ((format.charAt(iFormat) === c) && (iFormat < format.length)) {
                    token += format.charAt(iFormat++);
                }
                // Extract contents of value based on format token
                if (token === "yyyy" || token === "yy" || token === "y") {
                    if (token === "yyyy") {
                        x = 4;
                        y = 4;
                    }
                    if (token === "yy") {
                        x = 2;
                        y = 2;
                    }
                    if (token === "y") {
                        x = 2;
                        y = 4;
                    }
                    year = _this._getInt(val, iVal, x, y);
                    if (year === null) {
                        return NaN;
                    }
                    iVal += year.length;
                    if (year.length === 2) {
                        if (year > 70) {
                            year = 1900 + (year - 0);
                        } else {
                            year = 2000 + (year - 0);
                        }
                    }
                } else if (token === "MMM" || token === "NNN") {
                    month = 0;
                    for (var i = 0; i < monthsAll.length; i++) {
                        var monthName = monthsAll[i];
                        if (val.substring(iVal, iVal + monthName.length).toLowerCase() === monthName.toLowerCase()) {
                            if (token === "MMM" || (token === "NNN" && i > 11)) {
                                month = i + 1;
                                if (month > 12) {
                                    month -= 12;
                                }
                                iVal += monthName.length;
                                break;
                            }
                        }
                    }
                    if ((month < 1) || (month > 12)) {
                        return NaN;
                    }
                } else if (token === "EE" || token === "E") {
                    for (var n = 0; n < daysAll.length; n++) {
                        var dayName = daysAll[n];
                        if (val.substring(iVal, iVal + dayName.length).toLowerCase() === dayName.toLowerCase()) {
                            iVal += dayName.length;
                            break;
                        }
                    }
                } else if (token === "MM" || token === "M") {
                    month = _this._getInt(val, iVal, token.length, 2);
                    if (month === null || (month < 1) || (month > 12)) {
                        return NaN;
                    }
                    iVal += month.length;
                } else if (token === "dd" || token === "d") {
                    date = _this._getInt(val, iVal, token.length, 2);
                    if (date === null || (date < 1) || (date > 31)) {
                        return NaN;
                    }
                    iVal += date.length;
                } else if (token === "hh" || token === "h") {
                    hh = _this._getInt(val, iVal, token.length, 2);
                    if (hh === null || (hh < 1) || (hh > 12)) {
                        return NaN;
                    }
                    iVal += hh.length;
                } else if (token === "HH" || token === "H") {
                    hh = _this._getInt(val, iVal, token.length, 2);
                    if (hh === null || (hh < 0) || (hh > 23)) {
                        return NaN;
                    }
                    iVal += hh.length;
                } else if (token === "KK" || token === "K") {
                    hh = _this._getInt(val, iVal, token.length, 2);
                    if (hh === null || (hh < 0) || (hh > 11)) {
                        return NaN;
                    }
                    iVal += hh.length;
                } else if (token === "kk" || token === "k") {
                    hh = _this._getInt(val, iVal, token.length, 2);
                    if (hh === null || (hh < 1) || (hh > 24)) {
                        return NaN;
                    }
                    iVal += hh.length;
                    hh--;
                } else if (token === "mm" || token === "m") {
                    mm = _this._getInt(val, iVal, token.length, 2);
                    if (mm === null || (mm < 0) || (mm > 59)) {
                        return NaN;
                    }
                    iVal += mm.length;
                } else if (token === "ss" || token === "s") {
                    ss = _this._getInt(val, iVal, token.length, 2);
                    if (ss === null || (ss < 0) || (ss > 59)) {
                        return NaN;
                    }
                    iVal += ss.length;
                } else if (token === "a") {
                    if (val.substring(iVal, iVal + 2).toLowerCase() === "am") {
                        ampm = "AM";
                    } else if (val.substring(iVal, iVal + 2).toLowerCase() === "pm") {
                        ampm = "PM";
                    } else {
                        return NaN;
                    }
                    iVal += 2;
                } else {
                    if (val.substring(iVal, iVal + token.length) !== token) {
                        return NaN;
                    } else {
                        iVal += token.length;
                    }
                }
            }
            // If there are any trailing characters left in the value, it doesn't match
            if (iVal !== val.length) {
                return NaN;
            }
            // Is date valid for month?
            if (month === 2) {
                // Check for leap year
                if (((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0)) { // leap year
                    if (date > 29) {
                        return NaN;
                    }
                } else {
                    if (date > 28) {
                        return NaN;
                    }
                }
            }
            if ((month === 4) || (month === 6) || (month === 9) || (month === 11)) {
                if (date > 30) {
                    return NaN;
                }
            }
            // Correct hours value
            if (hh < 12 && ampm === "PM") {
                hh = hh - 0 + 12;
            } else if (hh > 11 && ampm === "AM") {
                hh -= 12;
            }
            var newdate = new Date(year, month - 1, date, hh, mm, ss);
            return newdate.getTime();
        },
        /**
         * 将date字符串转为Date对象
         * @param {string} date
         * @param {string} format
         * @returns {Date}
         */
        ParseDate: function (date, format) { 
            var result=null;
            if (format) {
                result= this.GetDateFromFormat(date, format);
            }
            else
            {
                var timestamp =Date.parse(date), minutesOffset = 0, match;
                if (isNaN(timestamp) && (match = /^(\d{4}|[+\-]\d{6})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?))?/.exec(date))) {
                    if (match[8] !== 'Z') {
                        minutesOffset = +match[10] * 60 + (+match[11]);

                        if (match[9] === '+') {
                            minutesOffset = 0 - minutesOffset;
                        }
                    }

                    match[7] = match[7] || '000';

                    timestamp = Date.UTC(+match[1], +match[2] - 1, +match[3], +match[4], +match[5] + minutesOffset, +match[6], +match[7].substr(0, 3));
                }

                result= timestamp;
            }
            return result ? new Date(result) : null;
        }
    };
    
    XCLJsTool.Events={
        /**
         * 阻止事件,默认类名(私有)
         */
        _stopEventClassName:"XCLJsToolStopEvent",
        /**
         * 阻止指定事件
         * @param {object} $obj 被操作的元素
         * @param {string} eventName 事件名,默认为click
         * @param {string} className 绑定阻止事件时给元素$obj添加的类名,默认为"XCLJsToolStopEvent"
         * @returns {Boolean}
         */
        StopEvent:function($obj,eventName,className){
            var _this=this;
            eventName=eventName || "click";
            className=className || _this._stopEventClassName;
            $obj.addClass(className);
            $(doc).on(eventName,"."+className,function(){
                return false;
            })
            return  false;
        },
        /**
         * 移除阻止的事件
         * @param {object} $obj 被操作的元素
         * @param {string} className 移除的类名
         */
        RemoveStopEvent:function($obj,className){
            var _this=this;
            className=className || _this._stopEventClassName;
            $obj.removeClass(className);
        }
    };


    XCLJsTool.Browser={
        /**
         * 判断是否为IE
         * @param {int} version(6,7,8,9) 当指定此参数时,返回判断指定的IE版本结果,否则,则返回是否为IE
         * @returns {bool}
         */
        IsIE:function(version){
            var ie=(!-[1,]);
            if(!version){
                return ie;
            }
            var result=false;
            switch(version){
                case 6:
                    result=/msie 6/i.test(navigator.userAgent);
                    break;
                case 7:
                    result=/msie 7/i.test(navigator.userAgent);
                    break;
                case 8:
                    result=/msie 8/i.test(navigator.userAgent);
                    break;
                case 9:
                    result=ie && navigator.appVersion.match(/9./i)=="9.";
                    break;
            }
            return result;
        },
        
        /**
         * 判断是否为Firefox
         */
        IsFirefox:function(){
            return navigator.userAgent.indexOf("Firefox")>=0;
        },
        
        /**
         * 判断是否为Chrome
         */
        IsChrome:function(){
            return navigator.userAgent.indexOf("Chrome") >=0 ;
        }
    };

    XCLJsTool.Mobile={
        /**
         * 判断是否为Android
         */
        IsAndroid:function(){
            return navigator.userAgent.match(/Android/i);
        },
        /**
         * 判断是否为BlackBerry
         */        
        IsBlackBerry: function() {
            return navigator.userAgent.match(/BlackBerry/i);
        },
        /**
         * 判断是否为IOS
         */        
        IsIOS: function() {
            return navigator.userAgent.match(/iPhone|iPad|iPod/i);
        },
        /**
         * 判断是否为Opera
         */        
        IsOpera: function() {
            return navigator.userAgent.match(/Opera Mini/i);
        },
        /**
         * 判断是否为IEMobile
         */        
        IsIEMobile: function() {
            return navigator.userAgent.match(/IEMobile/i);
        },
        /**
         * 判断是否为移动端
         */        
        IsMobile: function() {
            return (this.IsAndroid() || this.IsBlackBerry() || this.IsIOS() || this.IsOpera() || this.IsWindows());
        }
    };
    
    XCLJsTool.Math={
        /**
         * 返回指定值中的最小值
         * @param {type} val 可以为一个数组,也可以为多个参数
         * @returns {Number}
         */
        Min:function(val){
            if(XCLJsTool.Data.IsArray(val)){
                return Math.min.apply(null,val);
            }else{
                return Math.min(arguments);
            }
        },
        /**
         * 返回指定值中的最大值
         * @param {type} val 可以为一个数组,也可以为多个参数
         * @returns {Number}
         */        
        Max:function(val){
            if(XCLJsTool.Data.IsArray(val)){
                return Math.max.apply(null,val);
            }else{
                return Math.max(arguments);
            }
        }
    };
    
    XCLJsTool.Random={
        /**
         * 生成指定范围内的随机数
         * @param {type} min 最小值
         * @param {type} max 最大值
         * @returns {Number}
         */
        Range:function(min,max){
            return Math.random()*(max-min)+min;
        },
        /**
         * 生成guid(此guid可能会重复,如果是关键的地方,请勿使用)
         * @returns {String} 所生成的guid
         */
        Guid:function(){
            var S4=function() {
                return (((1+Math.random())*0x10000)|0).toString(16).substring(1); 
            };
            var guid = (S4() + S4() + "-" + S4() + S4() + "-" + S4() + "-" + S4() + S4() + S4()).toLowerCase();
            return guid;  
        }
    };
    
    XCLJsTool.Array={
        /**
         * 合并多个数组为一个数组
         * @param {type} args 要合并的数组参数,如:arr1,arr2,arr3...
         * @returns {Array} 合并后的结果数组
         */
        Concat:function(args){
            return [].concat.apply([],arguments);
        },
        /**
         * 将一个或多个数组合并为一个字符串
         * @param {type} separator 指定分隔符
         * @param {type} args 要合并的数组参数(arr1,arr2,arr3...)
         * @returns {string} 合并后的字符串
         */
        Join:function(separator,args){
            var source=[];
            if(arguments.length>2){
                for(var i=1;i<arguments.length;i++){
                    source=source.concat(arguments[i]);
                }
            }else{
                source=arguments[1];
            }
            return source.join(separator);
        }
    };
    
    win.XCLJsTool=win.XCLJsTool || XCLJsTool;

})(window);


文章评论

2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
程序员必看的十大电影
程序员必看的十大电影
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
一个程序员的时间管理
一个程序员的时间管理
程序员和编码员之间的区别
程序员和编码员之间的区别
我的丈夫是个程序员
我的丈夫是个程序员
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
鲜为人知的编程真相
鲜为人知的编程真相
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
如何成为一名黑客
如何成为一名黑客
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
旅行,写作,编程
旅行,写作,编程
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
Java程序员必看电影
Java程序员必看电影
我是如何打败拖延症的
我是如何打败拖延症的
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
编程语言是女人
编程语言是女人
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
中美印日四国程序员比较
中美印日四国程序员比较
程序员都该阅读的书
程序员都该阅读的书
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
10个调试和排错的小建议
10个调试和排错的小建议
Google伦敦新总部 犹如星级庄园
Google伦敦新总部 犹如星级庄园
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
为什么程序员都是夜猫子
为什么程序员都是夜猫子
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
 程序员的样子
程序员的样子
程序员应该关注的一些事儿
程序员应该关注的一些事儿
程序员的鄙视链
程序员的鄙视链
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
代码女神横空出世
代码女神横空出世
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有