[笔记]记录原开发工作在base命名空间下扩展的属性与方法

前言

该笔记只是为了记录以前开发使用的方式。

处理命名空间namespace

/**
 * 处理命名空间
 * @param {string} 空间名称，可多个 
 * @return {object} 对象
 */    
var namespace = function(){
    var argus = arguments,
            arguslen = argus.length;
    for(var i =0; i < arguslen; i++){
        var objs = argus[i].split('.'),
                objslen = objs.length,
                obj = window;
        for(var j = 0; j < objslen; j++){
                obj[objs[j]] = obj[objs[j]] || {};
                obj = obj[objs[j]];
        }
    }
    return obj;
    
}
namespace("base");

 extend及base命名下的常用方法

(function(){
    /**
     * 获取对象类型
     * @private 私有方法
     * @param {object} object 对象
     * @return {string} 类型
     * 可判断类型：boolean number string function array date regexp object
     */    
    function getparamtype(obj){
        return obj == null ? string(obj) : 
            object.prototype.tostring.call(obj).replace(/\[object\s+(\w+)\]/i,"$1") || "object";
    };
    
    /**
     * 为对象进行扩展属性和方法
     * @param {object} object 对象
     * @return {bool} 是/否
     */     
    base.extend = function(destination, source) {
        if (destination == null) {
            destination = source;
        }else {
            for (var property in source){        
                if ( getparamtype(source[property]).tolowercase() === "object" && 
                    getparamtype(destination[property]).tolowercase() === "object" ){
                        extend(destination[property], source[property]);
                    }else{
                        destination[property] = source[property];
                    }
            }
        }
        return destination;
    }
    
    base.extendless = function(destination, source) {
        var newopt = source;
        for (var i in destination) {
            if (isobject(source) && typeof(source[i]) != 'undefined') {
                destination[i] = newopt[i]
            }
        }
        return destination
    }
    
    /**
     * 类式继承类
     * @param {object} subclass 子类
     * @param {object} superclass 基础类
     * @return {undefined} 
     */    
    base.extendclass = function(subclass,superclass){
        var f = function(){};
        f.prototype = superclass.prototype;
        subclass.prototype = new f();
        subclass.prototype.constructor = subclass;
        subclass.superclass = superclass.prototype;
        if (superclass.prototype.constructor == object.prototype.constructor){
            superclass.prototype.constructor = superclass
        }
    }
    
    /**
     * 原型继承类
     * @param {object} object 基类
     * @return {object} 生成的子类
     */     
    base.cloneclass = function(object){        
        if(!isobject(object)) return object;
        if(object == null) return object;
        var f = new object();
        for(var i in object)
            f[i] = cloneclass(object[i]);
        return f;         
    }
    /**
     * 绑定上下文
     * @param {function,context} object
     * @return {object}
     */     
    base.bind = function(fn,context){        
         return function(){
             return fn.apply(context,arguments);
         };        
    }
    
    base.extend( base, {
        /**
         * 判断对象是否定义
         * 其实只对对象中的元素判断有效，如是纯变量，此方法会无法调用，需要外面加try
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isundefined : function(o){ 
                 return o === undefined && typeof o == "undefined";
        },
        /**
         * 判断对象是否数组
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isarray : function(obj) {
            return getparamtype(obj).tolowercase() === "array";
        },        
        /**
         * 判断对象是否函数
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isfunction : function(obj){
            return getparamtype(obj).tolowercase() === "function";
        },        
        /**
         * 判断对象是否对象
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isobject : function(obj) {
            return getparamtype(obj).tolowercase() === "object";
        },
        /**
         * 判断对象是否数值
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isnumber : function(obj) {
            return getparamtype(obj).tolowercase() === "number";
        },
        /**
         * 判断对象是否字符串
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isstring : function(obj) {
            return getparamtype(obj).tolowercase() === "string";
        },
        /**
         * 判断是否布尔值
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isboolean : function(obj) {
            return getparamtype(obj).tolowercase() === "boolean";
        },
        /**
         * 判断对象是否日期
         * @param {object} object 对象
         * @return {bool} 是/否
         */
        isdate : function(obj){
            return getparamtype(obj).tolowercase() === "date";
        },
        
        /**
         * 判断对象是否dom元素
         * @param {object} obj dom对象
         * @return {bool} 是/否
         */
        isdom : function(obj){
            try{
                return obj && typeof obj === "object" && !isundefined(obj.nodetype) && obj.nodetype==1 && !isundefined(obj.nodename) && typeof obj.nodename == "string";
            }
            catch(e){
                //console.log(e)
                return false;
            }
        },
        
        /**
         * 获取dom对象的值
         * @param {object} obj dom对象
         * @return {string} 取value或innerhtml
         */
        getdomval : function(obj){
            return obj.value || obj.innerhtml;
        },
        /**
         * 索引序列
         * @param {serial,function} 数组或对象集合
         * @return {undefined}
         */
        foreach : function(haystack, callback) {
            var i = 0,
                length = haystack.length,
                name;

            if (length !== undefined) {
                for (; i < length;) {
                    if (callback.call(haystack[i], i, haystack[i++]) === false) {
                        break;
                    }
                }
            } else {
                for (name in haystack) {
                    callback.call(haystack[name], name, haystack[name]);
                }
            }
        },
        /**
         * 获取dom对象
         * @param {string|dom} dom的id或对象k
         * @return {dom} 
         */
        g : function(obj){
            return (typeof obj=='object')?obj:document.getelementbyid(obj);
        }
    });
    
})();

base.extend(window, base); 

 base下的dom操作

namespace("base.dom");
(function(){
var dom = base.dom;

var useragent = navigator.useragent.tolowercase();

extend( dom, {
    /**
     * 判断浏览器类型
     */
    browser : {
        /**
         * 获取版本号
         */
        version: (useragent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
        /**
         * 是否webkit浏览器
         */
        webkit: /webkit/.test( useragent ),
        /**
         * 是否opera浏览器
         */
        opera: /opera/.test( useragent ),
        /**
         * 是否ie浏览器
         */
        msie: /msie/.test( useragent ) && !/opera/.test( useragent ),
        /**
         * 是否mozilla浏览器
         */
        mozilla: /mozilla/.test( useragent ) && !/(compatible|webkit)/.test( useragent ),
        /**
         * 是否tt浏览器
         */
        tt: /tencenttraveler/.test( useragent ),
        /**
         * 是否chrome浏览器
         */
        chrome: /chrome/.test( useragent ),
        /**
         * 是否firefox浏览器
         */
        firefox: /firefox/.test( useragent ),
        /**
         * 是否safari浏览器
         */
        safari: /safari/.test( useragent ),
        /**
         * 是否gecko浏览器
         */
        gecko: /gecko/.test( useragent ),
        /**
         * 是否ie6
         */
        ie6: this.msie && this.version.substr(0,1) == '6'
    
    },
    
    /**
     * 获取dom对象
     * @param {string|dom} dom的id或对象
     * @return {dom} 
     */
    g : function(obj){
        return (typeof obj=='object')?obj:document.getelementbyid(obj);
    },
    
    /**
     * 判断dom对象是否存在样式类名称
     * @param {dom} element dom对象
     * @param {string} classname 样式名称
     * @return {bool} 
     */     
    hasclassname : function(element, classname) {
        var elementclassname = element.classname;
        return (elementclassname.length > 0 && (elementclassname == classname ||
      new regexp("(^|\\s)" + classname + "(\\s|$)").test(elementclassname)));
    },
    
    /**
     * 为dom对象增加样式类名称
     * @param {dom} element dom对象
     * @param {string} classname 样式名称
     * @return {dom} 
     */
    addclassname : function(element, classname) {
        if (!base.hasclassname(element, classname))
            element.classname += (element.classname ? ' ' : '') + classname;
        return element;
    },
    
    /**
     * 为dom对象删除样式类名称
     * @param {dom} element dom对象
     * @param {string} classname 样式名称
     * @return {dom} 
     */
    removeclassname : function(element, classname) {
        element.classname = base.trim(element.classname.replace(
            new regexp("(^|\\s+)" + classname + "(\\s+|$)") , ' '));
        return element;    
    },
    
    /**
     * 为dom对象设置样式
     * @param {dom} ele dom对象
     * @param {object} styles 样式对象 like:{width:100,height:100}
     * @return undefined
     */
    setstyle: function(ele, styles){
        for (var i in styles) {
            ele.style[i] = styles[i];
        }
    },
    
    /**
     * 为dom对象获取选定属性的样式
     * @param {dom} ele dom对象
     * @param {string} prop 属性名称
     * @return 属性样式
     */
    getstyle: function(el, prop){
        var viewcss = isfunction(document.defaultview) //(typeof document.defaultview == 'function') 
            ? document.defaultview() 
            : document.defaultview;
        if (viewcss && viewcss.getcomputedstyle) {
            var s = viewcss.getcomputedstyle(el, null);
            return s && s.getpropertyvalue(prop);
        }
        return (el.currentstyle && (el.currentstyle[prop] || null) || null);
    },
    
    /**
     * 获取页面最大高度
     * @return 属性样式
     */
    getmaxh: function(){
        return (this.getpageheight() > this.getwinheight() ? this.getpageheight() : this.getwinheight())
    },
    
    /**
     * 获取页面最大宽度
     * @return 属性样式
     */
    getmaxw: function(){
        return (this.getpagewidth() > this.getwinwidth() ? this.getpagewidth() : this.getwinwidth())
    },
    
    /**
     * 网页内容高度
     * @return {int} 网页内容高度
     */
    getpageheight: function(){
        var h = (window.innerheight && window.scrollmaxy) ? (window.innerheight + window.scrollmaxy) : (document.body.scrollheight > document.body.offsetheight ? document.body.scrollheight : document.body.offsetheight);
        return h > document.documentelement.scrollheight ? h : document.documentelement.scrollheight
    },
    
    /**
     * 网页内容宽度
     * @return {int} 网页内容宽度
     */
    getpagewidth: function(){
        return (window.innerwidth && window.scrollmaxx) ? (window.innerwidth + window.scrollmaxx) : (document.body.scrollwidth > document.body.offsetwidth ? document.body.scrollwidth : document.body.offsetwidth);
    },
    
    /**
     * 浏览器可视区域高度
     * @return {int} 网可视区域高度
     */
    getwinheight: function(){
        return (window.innerheight) ? window.innerheight : 
        (document.documentelement && document.documentelement.clientheight) 
        ? document.documentelement.clientheight 
        : document.body.offsetheight
    },
    
    /**
     * 浏览器可视区域宽度
     * @return {int} 网可视区域宽度
     */
    getwinwidth: function(){
        return (window.innerwidth) ? window.innerwidth : (document.documentelement && document.documentelement.clientwidth) ? document.documentelement.clientwidth : document.body.offsetwidth
    },
    
    /**
     * 设置dom透明度
     * @param {dom} ele dom对象
     * @param {int} level 透明度值（0-100的整数）
     * @return {undefined} 
     */    
    setopacity: function(ele, level){
        //level = math.min(1,math.max(level,0));
        if(this.browser.msie && (!document.documentmode || document.documentmode < 9)){
            ele.style.filter = 'alpha(opacity=' + level + ')'
        }else{
            ele.style.opacity = level / 100
         }
    },
    /**
     * 获取页面中对象的绝对x位置
     * @param {dom} e dom对象
     * @return {int} 
     */    
    getx: function(e) {
        var t = e.offsetleft;
        while (e = e.offsetparent) t += e.offsetleft;
        return t
    },
    /**
     * 获取页面中对象的绝对y位置
     * @param {dom} e dom对象
     * @return {int} 
     */    
    gety: function(e) {
        var t = e.offsettop;
        while (e = e.offsetparent) t += e.offsettop;
        return t
    },
    
    /**
     * 获取url中的参数值
     * @param {string} pa 参数名称
     * @return {string} 参数值
     */    
    request: function(pa){ 
        var url = window.location.href.replace(/#+.*$/, ''),
            params = url.substring(url.indexof("?")+1,url.length).split("&"),
            param = {} ;
        for (var i=0; i<params.length; i++){  
            var pos = params[i].indexof('='),//查找name=value  
                key = params[i].substring(0,pos),
                val = params[i].substring(pos+1);//提取value 
            param[key] = val;
        } 
        return (typeof(param[pa])=="undefined") ? "" : param[pa];
    } 
})
})();
base.extend(base, base.dom);

base下的event事件

namespace("base.event");

(function(){
var event = base.event;
extend( event, {
    /**
     * 停止事件继续进行
     * @param {event} e 事件
     * @return {dom} 
     */
    preventdefault : function(e){
        if (e.preventdefault){
            e.preventdefault();
        }
        else{
            e.returnvalue = false;
        }
    },
    /**
     * 阻止事件冒泡传递
     * @param {event} e 事件
     * @return {dom} 
     */
    stoppropagation : function(e){
        if (e.stoppropagation){
            e.stoppropagation();            
        }
        else{
            e.cancelbubble = true;
        }
    },
    /**
     * 为dom对象增加事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     */
    addevent : function(el, type, fn){
        if (window.addeventlistener){
            el['e'+type+fn] = fn;
            el[type+fn] = function(e){
                var _e = e || window.event,
                    _r = el['e'+type+fn](_e);
                if (_r==false) {
                    base.preventdefault(_e);
                    base.stoppropagation(_e);
                }                
            }            
            el.addeventlistener(type, el[type+fn], false);    
        }
        else if (window.attachevent){
            el['e'+type+fn] = fn;
            el[type+fn] = function(e){
                var _r = el['e'+type+fn](window.event);
                if (_r==false) base.preventdefault(window.event);
            }
            el.attachevent( 'on'+type, el[type+fn] );
            return;
        }
        else{
            el['on' + type] = fn;
        }
    },    
    /**
     * 为dom对象移除事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     */
    removeevent : function (el, type, fn){
        if (window.removeeventlistener){
            el.removeeventlistener(type, el[type+fn], false);
            el[type+fn] = null;    
        }
        else if (window.detachevent){        
            el.detachevent( 'on'+type, el[type+fn] );            
            el[type+fn] = null;            
            return;
        }
        else{
            el['on' + type] = null;
        }
    },
    isready : false,
    readyfn : [],
    /**
     * dom ready事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     */
    ready : function (fn){    
        bindreadyevent();    
        if ( base.isready ){
            fn.call();
        }
        else {
            if (isfunction(fn)){
                base.readyfn.push(fn);
            }
        }
    }
});

function bindreadyevent(){
    if(document.readystate === 'complete'){
        return ready();
    }
    if(document.addeventlistener){
        document.addeventlistener("domcontentloaded", function(){
            document.removeeventlistener("domcontentloaded", arguments.callee, false);
            ready();
        },false);
        window.addeventlistener("load", ready, false);
    }
    else if(document.attachevent){
        document.attachevent("onreadystatechange", function(){
            if (document.readystate === "complete"){
                document.detachevent("onreadystatechange", arguments.callee);
                ready();
            }
        });
        window.attachevent("onload",ready);
        if(document.documentelement.doscroll && window == window.top){
            if(base.isready) return;
            try{
                document.documentelement.doscroll("left");
            }catch(e){
                settimeout(arguments.callee, 0);
                return;
            }
            ready();
        }
    }
}

function ready(){
    if(!base.isready){
        if(!document.body){
            return settimeout(ready,13);
        }
        base.isready = true;
        
        if(base.readyfn.length >0){
            var i=0,fn;
            while(fn = base.readyfn[i++])
                fn.call();
            base.readyfn.length = 0;
        }
            
    }
}

})();
base.extend(base, base.event);

base下的array数组

namespace("base.array");
(function(){
var array = base.array;
extend( array, {
    /**
     * 判断数组内容个数
     * @param {array} array 对象
     * @return {int} 长度
     */
    getlength : function(arr){
        var l = 0;
        for(var key in arr){
            l ++;
        }    
        return l;
    },
    /**
     * 复制数组
     * @param {array} array 对象
     * @return {array} 新数组对象
     */
    clone : function(arr){
        var a = [];
        for(var i=0; i<arr.length; ++i) {
            a.push(arr[i]);
        }
        return a;
    },
    /**
     * 判断数组中是否存在这个值
     * @param {array} arr 数组对象
     * @param {object} value 对象
     * @return {bool} 是/否
     */
    hasvalue : function(arr, value){
        var find = false;
        if (isarray(arr) || isobject(arr))
            for(var key in arr){
                if (arr[key] == value) find = true;
            }
        return find;
    },
    /**
     * 根据值获得数组中的key
     * @param {array} arr 数组对象
     * @param {object} value 对象
     * @return {string} key
     */
    getarraykey : function(arr, value){
        var findkey = -1;
        if (isarray(arr) || isobject(arr))
            for(var key in arr){
                if (arr[key] == value) findkey = key;
            }
        return findkey;
    },
    /**
     * 返回a1数组有a2没有的值
     * @param {array} a1 数组对象
     * @param {array} a2 数组对象
     * @return {array} key
     */
    filter : function (a1, a2) {
        var res = [];
        for(var i=0;i<a1.length;i++) {
            if(!base.hasvalue(a2, a1[i]))
                res.push(a1[i]);
        }
        return res;
    },
    /**
     * 两个数组的值的交集
     * @param {array} arr 数组
     * @param {array} arr 数组
     * @return {array} key
     */
    unique : function (a1, a2) {
        return base.filter(a1,a2).concat(base.filter(a2,a1))
    } 
});
})();
base.extend(base, base.array); 

base下的string字符串

namespace("base.string");
(function(){

var string = base.string;
extend( string, {
    /**
     * 查找字符串的字节长度<br/>
     * 中文算2 英文算1<br/>
     * @param {string} str 字符串
     * @return {int}
     */
    getbytelength : function(str){
        var bytes=0,i=0;
        for (; i<str.length; ++i,++bytes) {
            if ( str.charcodeat(i) > 255 ) {
                    ++bytes;
            }
        }
        return bytes;
    },
    /**
     * 查找有多少个双字节字符
     * @param {string} str 字符串
     * @return {int}
     */
    getdwordnum : function(str){
        return string.getbytelength(str) - str.length;
    },
    /**
     * 查找有多少个汉字字符
     * @param {string} str 字符串
     * @return {int}
     */
    getchinesenum : function(str){
        return str.length - str.replace(/[\u4e00-\u9fa5]/g,"").length;
    },
    /**
     * 截取中文字符串<br/>
     * 取imaxbytes 或最后一个中文字符出现的地方替换字符<br/>
     * @param {string} str 字符串
     * @param {int} imaxbytes 字符串
     * @param {string} ssuffix 替补字符串
     * @return {string}
     */
    cutchinese : function(str, imaxbytes, ssuffix){
        if(isnan(imaxbytes)) return str;
        if(string.getbytelength(str)<=imaxbytes) return str;
        var i=0, bytes=0;
        for (; i<str.length && bytes<imaxbytes; ++i,++bytes) {
            if ( str.charcodeat(i) > 255 ) {
                    ++bytes;
            }
        }
        ssuffix = ssuffix || "";
        return (bytes-imaxbytes == 1 ? str.substr(0,i-1) : str.substr(0,i) ) + ssuffix;
    },
    /**
     * 去掉字符串左边的非空字符
     * @param {string} str 字符串
     * @return {string}
     */
    trimleft : function(str){
        return str.replace(/^\s+/,"");
    },
    /**
     * 去掉字符串右边的非空字符
     * @param {string} str 字符串
     * @return {string}
     */
    trimright : function(str){
        return str.replace(/\s+$/,"");
    },
    /**
     * 去掉字符串左右两边的非空字符
     * @param {string} str 字符串
     * @return {string}
     */
    trim : function(str){
        return base.trimright(base.trimleft(str));
    },
    /**
     * 成对字符串替换
     * @param {string} str 字符串
     * @param {array} str 字符串<br/>
          array包含两个 [0] 查找内容，[1] 替换内容<br/>
          array可以出现多次<br/>
     * @return {string}
     */
    replacepairs : function(){
        var str = arguments[0];
        for (var i=1; i<arguments.length; ++i) {
            var re = new regexp(arguments[i][0], "g"); 
            str = str.replace(re, arguments[i][1]);
        }
        return str;
    },
    /**
     * 字符串替换为html编码形式
     * @param {string} str 字符串
     * @return {string}
     */
    tohtml : function(str){
        var convert_array =
        [
            ["&", "&#38;"],
            [" ", "&#32;"],
            ["'", "&#39;"], 
            ["\"", "&#34;"],
            ["/", "&#47;"],
            ["<", "&#60;"],
            [">", "&#62;"],
            ["\\\\", "&#92;"],
            ["\n", "<br />"],
            ["\r", ""]
        ];
        return base.replacepairs.apply(this, [str].concat(convert_array));
    },
    /**
     * 校验邮箱地址
     * @param {string} str 字符串
     * @return {bool}
     */
    ismail : function(str){
        return /^(?:[\w-]+\.?)*[\w-]+@(?:[\w-]+\.)+[\w]{2,3}$/.test(str);    
    },
    /**
     * 校验普通电话、传真号码：可以“+”开头，除数字外，可含有“-”
     * @param {string} str 字符串
     * @return {bool}
     */
    istel : function(str){
        return /^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/.test(str);
    },
    /**
     * 校验手机号码：必须以数字开头
     * @param {string} str 字符串
     * @return {bool}
     */
    ismobile : function(str){
        return /^1[34578]\d{9}$/.test(str);
    },
    /**
     * 校验邮政编码
     * @param {string} str 字符串
     * @return {bool}
     */
    iszipcode : function(str){
        return /^(\d){6}$/.test(str);
    },
    /**
     * 是否身份证号码
     * @param {string} str 字符串
     * @return {bool}
     */
    isidcard : function(str){
        var c15toc18 = function(c15) {
            var cid=c15.substring(0,6)+"19"+c15.substring(6,15);
            var strjiaoyan  =[  "1", "0", "x", "9", "8", "7", "6", "5", "4", "3", "2"];
            var intquan =[7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
            var inttemp=0;
            for(i = 0; i < cid.length ; i++)
            inttemp +=  cid.substring(i, i + 1)  * intquan[i];  
            inttemp %= 11;
            cid+=strjiaoyan[inttemp];
            return cid; 
        }
        var is18idcard = function(idnum) {
            var acity={11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"*",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"*",71:"*",81:"香港",82:"澳门",91:"国外"};
        
            var isum=0, info="", sid=idnum;
            if(!/^\d{17}(\d|x)$/i.test(sid)) {
                return false;
            }
            sid=sid.replace(/x$/i,"a");
        
            if(acity[parseint(sid.substr(0,2))]==null) {
                return false;
            }
            
            var sbirthday=sid.substr(6,4)+"-"+number(sid.substr(10,2))+"-"+number(sid.substr(12,2));
            var d=new date(sbirthday.replace(/-/g,"/"))
            
            if(sbirthday!=(d.getfullyear()+"-"+ (d.getmonth()+1) + "-" + d.getdate()))return false;
            
            for(var i = 17;i>=0;i --) isum += (math.pow(2,i) % 11) * parseint(sid.charat(17 - i),11)
            
            if(isum%11!=1)return false;
            return true;
        }
        
        return str.length==15 ? is18idcard(c15toc18(str)) : is18idcard(str);
    },    
    /**
     * 是否全部是中文
     * @param {string} str 字符串
     * @return {bool}
     */
    ischinese : function(str){
        return base.getchinesenum(str)==str.length ? true : false;
    },
    /**
     * 是否全部是英文
     * @param {string} str 字符串
     * @return {bool}
     */
    isenglish : function(str){
        return /^[a-za-z]+$/.test(str);
    },
    /**
     * 是否链接地址
     * @param {string} str 字符串
     * @return {bool}
     */
    isurl : function(str){
        return /^(https|http):\/\/[a-za-z0-9-_]+\.[a-za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/.test(str);
    },
    /**
     * 是否数字字符串
     * @param {string} str 字符串
     * @return {bool}
     */
    isnumberstring : function(str){
        return /^\d+$/.test(str);
    }
})
})();
base.extend(base, base.string); 

base下的cookie操作

namespace("base.cookie");

(function(){
var cookie = base.cookie;
extend( cookie, {
    /**
     * 设置cookie
     * @param {string} sname cookie名
     * @param {string} svalue cookie值
     * @param {int} iexpiresec 失效时间（秒）
     * @param {string} sdomain 作用域
     * @param {string} spath 作用路径
     * @param {bool} bsecure 是否加密
     * @return {void}
     */
    set : function(sname,svalue,iexpiresec,sdomain,spath,bsecure){
        if(sname==undefined) {
            return;
        }
        if(svalue==undefined) {
            svalue="";
        }
        var ocookiearray = [sname+"="+escape(svalue)];
        if(!isnan(iexpiresec)){
            var odate = new date();
            odate.settime(odate.gettime()+iexpiresec*1000);
            iexpiresec==0 ? '' : ocookiearray.push("expires=" + odate.togmtstring()) ;
        }
        if(sdomain!=undefined){
            ocookiearray.push("domain="+sdomain);
        }
        if(spath!=undefined){
            ocookiearray.push("path="+spath);
        }
        if(bsecure){
            ocookiearray.push("secure");
        }
        document.cookie=ocookiearray.join("; ");
    },
    /**
     * 获取cookie
     * @param {string} sname cookie名
     * @param {string} svalue 默认值
     * @return {string} cookie值
     */
    get : function(sname,sdefaultvalue){
        var sre = "(?:; |^)" + sname + "=([^;]*);?";
        var ore = new regexp(sre);
        
        if (ore.test(document.cookie)) {
            return unescape(regexp["$1"]);
        } else {
            return sdefaultvalue||null;
        }
    },
    /**
     * 获取cookie
     * @param {string} sname cookie名
     * @param {string} sdomain 作用域
     * @param {spath} spath 作用路径
     * @return {void} 
     */
    clear : function(sname, sdomain, spath){
        var odate = new date();
        cookie.set(sname,"", -odate.gettime()/1000, sdomain, spath);
    }    
});
})();
base.extend(base, base.cookie); 

base下的date日期操作

namespace("base.date");
(function(){
var date = base.date;
var _d = new date();
extend( date, {
    /**
     * 获取日期
     * @param {string} sep 分隔符 默认为-
     * @return {string} yyyy-mm-dd
     */
    todatestring : function(nd){    
        var a=[],
            dt = isdate(nd) ? nd : _d;
            m = dt.getmonth()+1,
            d = dt.getdate(),
            sep = arguments[1] ? arguments[1] : (isstring(arguments[0]) ? arguments[0] : "-"); 
        a.push(dt.getfullyear());
        a.push( m.tostring().length < 2 ? "0" + m : m);
        a.push( d.tostring().length < 2 ? "0" + d : d);
        return a.join(sep);
    },
    /**
     * 获取日期和时间
     * @param {string} sep 分隔符 默认为-
     * @return {string} yyyy-mm-dd hh:ii:ss
     */
    todatetimestring : function(nd){
        var dt = isdate(nd) ? nd : _d,
            h = dt.gethours(),
            i = dt.getminutes(),
            s = dt.getseconds(),
            a = [];
        a.push(h.tostring().length < 2 ? "0" + h : h);
        a.push(i.tostring().length < 2 ? "0" + i : i);
        a.push(s.tostring().length < 2 ? "0" + s : s);
        return date.todatestring.apply(this,arguments) + " " + a.join(":");
    },
    /**
     * 是否润年
     * @param {int} year 年份
     * @return {bool} 是/否
     */
    isleapyear : function(year) {
        return (0 == year % 4 && ((year % 100 != 0) || (year % 400 == 0)))
    },
    /**
     * 获取服务器时间
     * @return {date} date
     */
    getseverdatetime : function(){
        var xhr = window.activexobject ? new activexobject("microsoft.xmlhttp") : new xmlhttprequest();
        xhr.open("head", window.location.href, false);
        xhr.send();    
        var d= new date(xhr.getresponseheader("date"));
        
        
        return d;
    }    
});
})();
base.extend(base, base.date);

base下的number

namespace("base.number");
(function(){

var number = base.number;
extend( number, {
    /**
     * 是否某一范围的整数
     * @param {int} n 数值
     * @param {int} imin 范围低值
     * @param {int} imax 范围高值
     * @return {bool} 
     */
    isint : function(n, imin, imax){
        if(!isfinite(n)) {
            return false;
        }
        if(!/^[+-]?\d+$/.test(n)) {
            return false;   
        }
        if(imin!=undefined && parseint(n)<parseint(imin)) {
            return false;
        }
        if(imax!=undefined && parseint(n)>parseint(imax)) {
            return false;
        }    
        return true;
    },
    /**
     * 是否某一范围浮点数
     * @param {float} n 数值
     * @param {float} fmin 范围低值
     * @param {float} fmax 范围高值
     * @return {bool} 
     */
    isfloat : function(n, fmin, fmax){
        if(!isfinite(n)) {
            return false;
        }
        if(fmin!=undefined && parsefloat(n)<parsefloat(fmin)) {
            return false;
        }
        if(fmax!=undefined && parsefloat(n)>parsefloat(fmax)) {
            return false;
        }
        return true;
    },
    /**
     * 取随机整数
     * @param {int} n 整数
     * @return {int} 0~n间的随机整数
     */
    randomint : function(n){
        return math.floor(math.random() * n);
    }
});
})();
base.extend(base,base.number);

base下的object对象

namespace("base.object");

(function(){

extend( base.object, {
    /**
     * 序列化json对象
     * 对object转化为url参数字符串，各属性间以&分隔，如a=1&b=2&c=3
     * 对象属性为string 则进行encodeuricomponent编码
     * 对象属性为bool 则以0代表false 1代表true
     * 对象属性为对象，则会继续进行递归序列化
     * 对象属性为function 则返回function.tostring
     * @param {object} jsonobj json对象
     * @return {string}
     */
    serialize : function(jsonobj){
        var newjsonobj = null;
        if (typeof(jsonobj) == 'undefined' || typeof(jsonobj) == 'function') 
            newjsonobj = '';
        if (typeof(jsonobj) == 'number') 
            newjsonobj = jsonobj.tostring();            
        if (typeof(jsonobj) == 'boolean') 
            newjsonobj = (jsonobj) ? '1' : '0';
        if (typeof(jsonobj) == 'object') {
            if (!jsonobj) newjsonobj = '';
            if (jsonobj instanceof regexp) newjsonobj = jsonobj.tostring();
        }
        if (typeof(jsonobj) == 'string') 
            newjsonobj = jsonobj;        
        if (typeof(newjsonobj) == 'string') 
            return encodeuricomponent(newjsonobj);
            
        var ret = [];
        if (jsonobj instanceof array) {
            for (var i = 0; i < jsonobj.length; i++) {
                if (typeof(jsonobj[i]) == 'undefined')     continue;
                ret.push(typeof(jsonobj[i]) == 'object' ? '' : base.serialize(jsonobj[i]))
            }
            return ret.join('|')
        } 
        else {
            for (var i in jsonobj) {                
                if (typeof(jsonobj[i]) == 'undefined')     continue;
                newjsonobj = null;
                if (typeof(jsonobj[i]) == 'object') {
                    if (jsonobj[i] instanceof array) {
                        newjsonobj = jsonobj[i];
                        ret.push(i + '=' + base.serialize(newjsonobj));
                    } else {
                        ret.push(i + '=')
                    }
                } else {
                    newjsonobj = jsonobj[i];
                    ret.push(i + '=' + base.serialize(newjsonobj));
                }
            }
            return ret.join('&')
        }
    },
    /**
     * 反序列化为json对象
     * 对url参形形式的对象反序列化成为json对象
     * 与serialize相对应
     * @param {object} jsonobj json对象
     * @return {string}
     */
    unserialize : function(jsonstr, de){
        de = de || 0;
        jsonstr = jsonstr.tostring();
        if (!jsonstr) return {};
        var retobj = {}, 
            obj1ret = jsonstr.split('&');
        if (obj1ret.length == 0) return retobj
        for (var i = 0; i < obj1ret.length; i++) {
            if (!obj1ret[i]) continue;
            var ret2 = obj1ret[i].split('=');
            if (ret2.length >= 2) {
                var ret0 = obj1ret[i].substr(0, obj1ret[i].indexof('=')),
                    ret1 = obj1ret[i].substr(obj1ret[i].indexof('=') + 1);
                if (!ret1) ret1 = '';
                if (ret0) retobj[ret0] = de == 0? decodeuricomponent(ret1) : ret1;
            }
        }
        return retobj;
    },
    /**
     * 对整个object进行utf8格式的url解码
     * @param {object} newopt 解码对象
     * @return {object} 已解码对象
     */
    decode : function(newopt) {
        if (typeof(newopt) == 'string') {
            try {
                return decodeuricomponent(newopt)
            } catch(e) {}
            return newopt
        }
        if (typeof(newopt) == 'object') {
            if (newopt == null) {
                return null
            }
            if (newopt instanceof array) {
                for (var i = 0; i < newopt.length; i++) {
                    newopt[i] = base.decode(newopt[i])
                }
                return newopt
            } else if (newopt instanceof regexp) {
                return newopt
            } else {
                for (var i in newopt) {
                    newopt[i] = base.decode(newopt[i]);
                }
                return newopt
            }
        }
        return newopt
    }
    
});
})();
base.extend(base,base.object);

base下的xss漏洞过滤

/*处理前端的xss漏洞过滤
* 通用过滤xss
* base.xss.filter("javascript:alert(document.cookie)");
 *过滤微信昵称
* base.xss.filterwxnickname('小<script>alert(document.cookie);</script>丁<span class=\"emoji emoji1f42f\"></span>丁');
*/

namespace("base.xss");
(function(){
var xss = base.xss;
extend(xss,{
    /**
     * 通用过滤，对所有涉及到xss漏洞的敏感字符和符号进行过滤
     * @param {oristr} string 待过滤的原始字符串
     * @return {string} 过滤后的字符串
     */
    filter:function(oristr){
        if(!oristr){
            return oristr;
        }
        var charcodes=['3c','3e','27','22','28','29','60',{format:'script{}',chr:'3a'}];//要转义字符的16进制ascii码[1<  2>  3'  4"  5(  6)  7`]
        var xsschars=[],filterchars=[],tmpformat='{}',tmpchr;
        for(var i=0;i<charcodes.length;i++){
            if('string'==typeof charcodes[i]){
                tmpformat='{}';
                tmpchr=charcodes[i];
            }else{
                tmpformat=charcodes[i].format;
                tmpchr=charcodes[i].chr
            }
            xsschars.push(tmpformat.replace('{}','\\u00'+tmpchr));
            xsschars.push(tmpformat.replace('{}','%'+tmpchr));//1次encode
            xsschars.push(tmpformat.replace('{}','%25'+tmpchr));//2次encode
            filterchars.push(tmpformat.replace('{}','&#x'+tmpchr+';'));
            filterchars.push(tmpformat.replace('{}','%26%23x'+tmpchr+'%3b'));//1次encode
            filterchars.push(tmpformat.replace('{}','%2526%2523x' + tmpchr + '%253b'));//2次encode
        }
        for(var i=0;i<xsschars.length;i++){
            oristr=oristr.replace(new regexp(xsschars[i],'gi'),filterchars[i]);
        }
        //预防script:
        oristr=oristr.replace(/script[\u000d\u000a\u0020]+\:/i,'script&#x3a;');
        return oristr;
    },
    /**
     * [专门过滤]过滤微信昵称，过滤除emoji表情之外的所有字符
     * @param {oristr} string 待过滤的原始字符串
     * @return {string} 过滤后的字符串
     */
    filterwxnickname:function(oristr){
        console.log(this);
        var matcharr=oristr.match(/\<span\sclass\=\"emoji\semoji[0-9a-z]+\"\>\<\/span\>/g);
        var oritagstr="",filtertagstr="";
        var tag="{tag_"+(new date()).gettime()+"}";
        if(!matcharr || !matcharr.length){
            return this.filter(oristr);
        }else{
            oritagstr=oristr.replace(/\<span\sclass\=\"emoji\semoji[0-9a-z]+\"\>\<\/span\>/g,tag);
            filtertagstr=this.filter(oritagstr);
            for(var i=0;i<matcharr.length;i++){
                filtertagstr=filtertagstr.replace(tag,matcharr[i]);
            }
            return filtertagstr;
        }
    }
});
})();
base.extend(base,base.xss);