【笔记】在base命名空间下扩展的属性与方法

前端之家收集整理的这篇文章主要介绍了【笔记】在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;
        var j = 0; j < objsLen; j++){
                obj[objs[j]] = obj[objs[j]] || {};
                obj = obj[objs[j]];
        }
    }
    return obj;
    
}
namespace("base");

 extend及base命名下的常用方法

(*
     * 获取对象类型
     * @private 私有方法
     * @param {object} object 对象
     * @return {string} 类型
     * 可判断类型:Boolean Number String Function Array Date RegExp Object
     */    
     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 = (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]);
                    }{
                        destination[property] = source[property];
                    }
            }
        }
         destination;
    }
    
    base.extendLess = var newopt = source;
        var i  destination) {
            if (isObject(source) && typeof(source[i]) != 'undefined') {
                destination[i] = newopt[i]
            }
        }
         destination
    }
    
    *
     * 类式继承类
     * @param {object} subClass 子类
     * @param {object} superClass 基础类
     * @return {undefined} 
         
    base.extendClass = (subClass,superClass){
        var F = (){};
        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 = (object){        
        if(!isObject(object))  object;
        if(object == null)  Object();
         object)
            F[i] = cloneClass(object[i]);
         F;         
    }
    *
     * 绑定上下文
     * @param {function,context} object
     * @return {object}
          
    base.bind = (fn,context){        
         return (){
              fn.apply(context,arguments);
         };        
    }
    
    base.extend( base,{
        *
         * 判断对象是否定义
         * 其实只对对象中的元素判断有效,如是纯变量,此方法会无法调用,需要外面加try
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isUndefined : (o){ 
                 return o === undefined && typeof o == "undefined";
        },*
         * 判断对象是否数组
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isArray : (obj) {
            return getParamType(obj).toLowerCase() === "array"*
         * 判断对象是否函数
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isFunction : (obj){
            return getParamType(obj).toLowerCase() === "function"*
         * 判断对象是否对象
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isObject : return getParamType(obj).toLowerCase() === "object"*
         * 判断对象是否数值
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isNumber : return getParamType(obj).toLowerCase() === "number"*
         * 判断对象是否字符串
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isString : return getParamType(obj).toLowerCase() === "string"*
         * 判断是否布尔值
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isBoolean : return getParamType(obj).toLowerCase() === "boolean"*
         * 判断对象是否日期
         * @param {object} object 对象
         * @return {bool} 是/否
         
        isDate : return getParamType(obj).toLowerCase() === "date"*
         * 判断对象是否DOM元素
         * @param {object} obj DOM对象
         * @return {bool} 是/否
         
        isDom : try{
                return obj && typeof obj === "object" && !isUndefined(obj.nodeType) && obj.nodeType==1 && !isUndefined(obj.nodeName) && typeof obj.nodeName == "string";
            }
            catch(e){
                //console.log(e)
                false;
            }
        },1)">*
         * 获取DOM对象的值
         * @param {object} obj DOM对象
         * @return {string} 取value或innerHTML
         
        getDomVal : return obj.value || obj.innerHTML;
        },1)">*
         * 索引序列
         * @param {serial,function} 数组或对象集合
         * @return {undefined}
         
        forEach : (haystack,callback) {
            var i = 0,length = haystack.length,name;

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

base.extend(window,base); 

 base下的DOM操作

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

var userAgent = navigator.userAgent.toLowerCase();

extend( dom,{
    *
     * 判断浏览器类型
     
    browser : {
        *
         * 获取版本号
         
        version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],1)">*
         * 是否webkit浏览器
         
        webkit: /webkit/.test( userAgent ),1)">*
         * 是否opera浏览器
         
        opera: /opera/*
         * 是否IE浏览器
         
        msie: /msie/.test( userAgent ) && !/opera/*
         * 是否mozilla浏览器
         
        mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/*
         * 是否TT浏览器
         
        tt: /tencenttraveler/*
         * 是否chrome浏览器
         
        chrome: /chrome/*
         * 是否firefox浏览器
         
        firefox: /firefox/*
         * 是否safari浏览器
         
        safari: /safari/*
         * 是否gecko浏览器
         
        gecko: /gecko/*
         * 是否IE6
         
        ie6: this.msie && this.version.substr(0,1) == '6'
    
    },1)">*
     * 获取dom对象
     * @param {string|dom} dom的id或对象
     * @return {dom} 
     
    g : (obj){
        obj:document.getElementById(obj);
    },1)">*
     * 判断DOM对象是否存在样式类名称
     * @param {dom} element dom对象
     * @param {string} className 样式名称
     * @return {bool} 
          
    hasClassName : (element,className) {
        var elementClassName = element.className;
        return (elementClassName.length > 0 && (elementClassName == className ||
      new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
    },1)">*
     * 为DOM对象增加样式类名称
     * @param {dom} element dom对象
     * @param {string} className 样式名称
     * @return {dom} 
     
    addClassName : if (!base.hasClassName(element,className))
            element.className += (element.className ? ' ' : '') + className;
         element;
    },1)">*
     * 为DOM对象删除样式类名称
     * @param {dom} element dom对象
     * @param {string} className 样式名称
     * @return {dom} 
     
    removeClassName :  base.trim(element.className.replace(
            new RegExp("(^|\\s+)" + className + "(\\s+|$)"),' '));
         element;    
    },1)">*
     * 为dom对象设置样式
     * @param {dom} ele dom对象
     * @param {object} styles 样式对象 like:{width:100,height:100}
     * @return undefined
     
    setStyle: (ele,styles){
         styles) {
            ele.style[i] = styles[i];
        }
    },1)">*
     * 为dom对象获取选定属性的样式
     * @param {dom} ele dom对象
     * @param {string} prop 属性名称
     * @return 属性样式
     
    getStyle: (el,prop){
        var viewCSS = isFunction(document.defaultView) (typeof document.defaultView == 'function') 
            ? document.defaultView() 
            : document.defaultView;
        if (viewCSS && viewCSS.getComputedStyle) {
            var s = viewCSS.getComputedStyle(el,);
            return s && s.getPropertyValue(prop);
        }
        return (el.currentStyle && (el.currentStyle[prop] || null) || );
    },1)">*
     * 获取页面最大高度
     * @return 属性样式
     
    getMaxH: (){
        this.getPageHeight() > this.getWinHeight() ? this.getPageHeight() : this.getWinHeight())
    },1)">*
     * 获取页面最大宽度
     * @return 属性样式
     
    getMaxW: this.getPageWidth() > this.getWinWidth() ? this.getPageWidth() : .getWinWidth())
    },1)">*
     * 网页内容高度
     * @return {int} 网页内容高度
     
    getPageHeight: 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
    },1)">*
     * 网页内容宽度
     * @return {int} 网页内容宽度
     
    getPageWidth: return (window.innerWidth && window.scrollMaxX) ? (window.innerWidth + window.scrollMaxX) : (document.body.scrollWidth > document.body.offsetWidth ? document.body.scrollWidth : document.body.offsetWidth);
    },1)">*
     * 浏览器可视区域高度
     * @return {int} 网可视区域高度
     
    getWinHeight: return (window.innerHeight) ? window.innerHeight : 
        (document.documentElement && document.documentElement.clientHeight) 
        ? document.documentElement.clientHeight 
        : document.body.offsetHeight
    },1)">*
     * 浏览器可视区域宽度
     * @return {int} 网可视区域宽度
     
    getWinWidth: return (window.innerWidth) ? window.innerWidth : (document.documentElement && document.documentElement.clientWidth) ? document.documentElement.clientWidth : document.body.offsetWidth
    },1)">*
     * 设置dom透明度
     * @param {dom} ele dom对象
     * @param {int} level 透明度值(0-100的整数)
     * @return {undefined} 
         
    setOpacity: level = Math.min(1,Math.max(level,0));
        if(this.browser.msie && (!document.documentMode || document.documentMode < 9)){
            ele.style.filter = 'Alpha(opacity=' + level + ')'
        }{
            ele.style.opacity = level / 100
         }
    },1)">*
     * 获取页面中对象的绝对X位置
     * @param {dom} e dom对象
     * @return {int} 
         
    getX: (e) {
        var t = e.offsetLeft;
        while (e = e.offsetParent) t += t
    },1)">*
     * 获取页面中对象的绝对Y位置
     * @param {dom} e dom对象
     * @return {int} 
         
    getY:  e.offsetTop;
        *
     * 获取url中的参数值
     * @param {string} pa 参数名称
     * @return {string} 参数值
         
    request: (pa){ 
        var url = window.location.href.replace(/#+.*$/,'' {} ;
        var i=0; i<params.length; i++){  
            var pos = params[i].indexOf('='),1)">查找name=value  
                key = params[i].substring(0提取value 
            param[key] = val;
        } 
        typeof(param[pa])=="undefined") ? "" : param[pa];
    } 
})
})();
base.extend(base,base.dom);

base下的event事件

namespace("base.event");

(var event = base.event;
extend( event,1)">*
     * 停止事件继续进行
     * @param {event} e 事件
     * @return {dom} 
     
    preventDefault : (e){
        if (e.preventDefault){
            e.preventDefault();
        }
        {
            e.returnValue = ;
        }
    },1)">*
     * 阻止事件冒泡传递
     * @param {event} e 事件
     * @return {dom} 
     
    stopPropagation :  (e.stopPropagation){
            e.stopPropagation();            
        }
        {
            e.cancelBubble = true*
     * 为DOM对象增加事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     
    addEvent :  (window.addEventListener){
            el['e'+type+fn] = fn;
            el[type+fn] = var _e = e || window.event,_r = el['e'+type+fn](_e);
                if (_r==) {
                    base.preventDefault(_e);
                    base.stopPropagation(_e);
                }                
            }            
            el.addEventListener(type,el[type+fn],1)">);    
        }
        else  (window.attachEvent){
            el['e'+type+fn] =var _r = el['e'+type+fn](window.event);
                ) base.preventDefault(window.event);
            }
            el.attachEvent( 'on'+type,el[type+fn] );
            ;
        }
        {
            el['on' + type] = fn;
        }
    },1)">*
     * 为DOM对象移除事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     
    removeEvent :  (el,1)"> (window.removeEventListener){
            el.removeEventListener(type,1)">);
            el[type+fn] = ;    
        }
         (window.detachEvent){        
            el.detachEvent( 'on'+type,1)">fn] );            
            el[type+fn] = ;            
            {
            el['on' + type] = *
     * dom ready事件
     * @param {dom} element dom对象
     * @param {string} type 事件名称
     * @param {function} type 事件方法
     * @return {undefined} 
     
    ready :  (fn){    
        bindReadyEvent();    
         ( base.isReady ){
            fn.call();
        }
         (isFunction(fn)){
                base.readyFn.push(fn);
            }
        }
    }
});

 bindReadyEvent(){
    if(document.readyState === 'complete' ready();
    }
    (document.addEventListener){
        document.addEventListener("DOMContentLoaded",1)">(){
            document.removeEventListener("DOMContentLoaded",arguments.callee,1)">);
            ready();
        },1)">);
        window.addEventListener("load",ready,1)">);
    }
    (document.attachEvent){
        document.attachEvent("onreadystatechange",1)">(){
            if (document.readyState === "complete"){
                document.detachEvent("onreadystatechange"if(document.documentElement.doScroll && window == window.top){
            if(base.isReady) ;
            {
                document.documentElement.doScroll("left");
            }(e){
                setTimeout(arguments.callee,0);
                ;
            }
            ready();
        }
    }
}

 ready(){
    if(!base.isReady){
        document.body){
            return setTimeout(ready,13);
        }
        base.isReady = ;
        
        if(base.readyFn.length >0){
            var i=0while(fn = base.readyFn[i++])
                fn.call();
            base.readyFn.length = 0;
        }
            
    }
}

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

base下的array数组

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

base下的string字符串

namespace("base.string"(){

var string = base.string;
extend( string,1)">*
     * 查找字符串的字节长度<br/>
     * 中文算2 英文算1<br/>
     * @param {string} str 字符串
     * @return {int}
     
    getByteLength : (str){
        var bytes=0,i=0for (; i<str.length; ++i,++bytes) {
            if ( str.charCodeAt(i) > 255 ) {
                    ++bytes;
            }
        }
         bytes;
    },1)">*
     * 查找有多少个双字节字符
     * @param {string} str 字符串
     * @return {int}
     
    getDwordNum : return string.getByteLength(str) - str.length;
    },1)">*
     * 查找有多少个汉字字符
     * @param {string} str 字符串
     * @return {int}
     
    getChineseNum : return str.length - str.replace(/[\u4e00-\u9fa5]/g,"").length;
    },1)">*
     * 截取中文字符串<br/>
     * 取iMaxBytes 或最后一个中文字符出现的地方替换字符<br/>
     * @param {string} str 字符串
     * @param {int} iMaxBytes 字符串
     * @param {string} sSuffix 替补字符串
     * @return {string}
     
    cutChinese : (str,iMaxBytes,sSuffix){
        if(isNaN(iMaxBytes))  str;
        if(string.getByteLength(str)<=iMaxBytes) var i=0,bytes=0for (; i<str.length && bytes<iMaxBytes; ++i,1)">bytes;
            }
        }
        sSuffix = sSuffix || ""return (bytes-iMaxBytes == 1 ? str.substr(0,i-1) : str.substr(0,i) ) + sSuffix;
    },1)">*
     * 去掉字符串左边的非空字符
     * @param {string} str 字符串
     * @return {string}
     
    trimLeft : return str.replace(/^\s+/,1)">*
     * 去掉字符串右边的非空字符
     * @param {string} str 字符串
     * @return {string}
     
    trimRight : return str.replace(/\s+$/,1)">*
     * 去掉字符串左右两边的非空字符
     * @param {string} str 字符串
     * @return {string}
     
    trim :  base.trimRight(base.trimLeft(str));
    },1)">*
     * 成对字符串替换
     * @param {string} str 字符串
     * @param {array} str 字符串<br/>
          array包含两个 [0] 查找内容,[1] 替换内容<br/>
          array可以出现多次<br/>
     * @return {string}
     
    replacePairs : var str = arguments[0];
        var i=1; i<arguments.length; ++i) {
            var re = new RegExp(arguments[i][0],"g"); 
            str = str.replace(re,arguments[i][1]);
        }
         str;
    },1)">*
     * 字符串替换为HTML编码形式
     * @param {string} str 字符串
     * @return {string}
     
    toHtml : var CONVERT_ARRAY =
        [
            ["&","&#38;"]
        ];
        return base.replacePairs.apply(*
     * 校验邮箱地址
     * @param {string} str 字符串
     * @return {bool}
     
    isMail : return /^(?:[\w-]+\.?)*[\w-]+@(?:[\w-]+\.)+[\w]{2,3}$/.test(str);    
    },1)">*
     * 校验普通电话、传真号码:可以“+”开头,除数字外,可含有“-”
     * @param {string} str 字符串
     * @return {bool}
     
    isTel : return /^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/.test(str);
    },1)">*
     * 校验手机号码:必须以数字开头
     * @param {string} str 字符串
     * @return {bool}
     
    isMobile : return /^1[34578]\d{9}$/*
     * 校验邮政编码
     * @param {string} str 字符串
     * @return {bool}
     
    isZipCode : return /^(\d){6}$/*
     * 是否身份证号码
     * @param {string} str 字符串
     * @return {bool}
     
    isIDCard : var C15ToC18 = (c15) {
            var cId=c15.substring(0,6)+"19"+c15.substring(6,15var 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,2var intTemp=0for(i = 0; i < cId.length ; i++)
            intTemp +=  cId.substring(i,i + 1)  * intQuan[i];  
            intTemp %= 11;
            cId+=strJiaoYan[intTemp];
             cId; 
        }
        var Is18IDCard = (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)) {
                ;
            }
            sID=sID.replace(/x$/i,"a");
        
            if(aCity[parseInt(sID.substr(0,2))]==) {
                ;
            }
            
            var sBirthday=sID.substr(6,4)+"-"+Number(sID.substr(10,2))+"-"+Number(sID.substr(12,1)">));
            var d=new Date(sBirthday.replace(/-/g,"/"))
            
            if(sBirthday!=(d.getFullYear()+"-"+ (d.getMonth()+1) + "-" + d.getDate()));
            
            var i = 17;i>=0;i --) iSum += (Math.pow(2,i) % 11) * parseInt(sID.charAt(17 - i),11)
            
            if(iSum%11!=1);
        }
        
        return str.length==15 ? Is18IDCard(C15ToC18(str)) : Is18IDCard(str);
    },1)">*
     * 是否全部是中文
     * @param {string} str 字符串
     * @return {bool}
     
    isChinese : return base.getChineseNum(str)==str.length ? true : ;
    },1)">*
     * 是否全部是英文
     * @param {string} str 字符串
     * @return {bool}
     
    isEnglish : return /^[A-Za-z]+$/*
     * 是否链接地址
     * @param {string} str 字符串
     * @return {bool}
     
    isURL : return /^(https|http):\/\/[A-Za-z0-9-_]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/*
     * 是否数字字符串
     * @param {string} str 字符串
     * @return {bool}
     
    isNumberString : return /^\d+$/.test(str);
    }
})
})();
base.extend(base,base.string); 

base下的cookie操作

namespace("base.cookie"var cookie = base.cookie;
extend( cookie,1)">*
     * 设置cookie
     * @param {string} sName cookie名
     * @param {string} sValue cookie值
     * @param {int} iExpireSec 失效时间(秒)
     * @param {string} sDomain 作用域
     * @param {string} sPath 作用路径
     * @param {bool} bSecure 是否加密
     * @return {void}
     
    set : (sName,sValue,iExpireSec,sDomain,sPath,bSecure){
        if(sName==undefined) {
            if(sValue==undefined) {
            sValue=""var oCookieArray = [sName+"="+escape(sValue)];
        isNaN(iExpireSec)){
            var oDate =  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);
        }
        (bSecure){
            oCookieArray.push("secure");
        }
        document.cookie=oCookieArray.join("; "*
     * 获取cookie
     * @param {string} sName cookie名
     * @param {string} sValue 默认值
     * @return {string} cookie值
     
    get : var sRE = "(?:; |^)" + sName + "=([^;]*);?"var oRE =  RegExp(sRE);
        
         (oRE.test(document.cookie)) {
            return unescape(RegExp["$1"]);
        } return sDefaultValue||*
     * 获取cookie
     * @param {string} sName cookie名
     * @param {string} sDomain 作用域
     * @param {sPath} sPath 作用路径
     * @return {void} 
     
    clear :  Date();
        cookie.set(sName,"",-oDate.getTime()/1000,sPath);
    }    
});
})();
base.extend(base,base.cookie); 

base下的date日期操作

namespace("base.date"var date = base.date;
var _d =  Date();
extend( date,1)">*
     * 获取日期
     * @param {string} sep 分隔符 默认为-
     * @return {string} yyyy-mm-dd
     
    toDateString : (nd){    
        var a=[],dt = isDate(nd) ? nd : _d;
            m = dt.getMonth()+1 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);
         a.join(sep);
    },1)">*
     * 获取日期和时间
     * @param {string} sep 分隔符 默认为-
     * @return {string} yyyy-mm-dd hh:ii:ss
     
    toDateTimeString : (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 : (year) {
        return (0 == year % 4 && ((year % 100 != 0) || (year % 400 == 0)))
    },1)">*
     * 获取服务器时间
     * @return {date} Date
     
    getSeverDateTime : var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") :  XMLHttpRequest();
        xhr.open("HEAD",window.location.href,1)">);
        xhr.send();    
        var d= new Date(xhr.getResponseHeader("Date"));
        
        
         d;
    }    
});
})();
base.extend(base,base.date);

base下的number

namespace("base.number"var number = base.number;
extend( number,1)">*
     * 是否某一范围的整数
     * @param {int} n 数值
     * @param {int} iMin 范围低值
     * @param {int} iMax 范围高值
     * @return {bool} 
     
    isInt : (n,iMin,iMax){
        isFinite(n)) {
            if(!/^[+-]?\d+$/.test(n)) {
            ;   
        }
        if(iMin!=undefined && parseInt(n)<parseInt(iMin)) {
            if(iMax!=undefined && parseInt(n)>parseInt(iMax)) {
            *
     * 是否某一范围浮点数
     * @param {float} n 数值
     * @param {float} fMin 范围低值
     * @param {float} fMax 范围高值
     * @return {bool} 
     
    isFloat : if(fMin!=undefined && parseFloat(n)<parseFloat(fMin)) {
            if(fMax!=undefined && parseFloat(n)>parseFloat(fMax)) {
            *
     * 取随机整数
     * @param {int} n 整数
     * @return {int} 0~n间的随机整数
     
    randomInt : (n){
        return Math.floor(Math.random() * n);
    }
});
})();
base.extend(base,base.number);

base下的object对象

namespace("base.object"(){

extend( base.object,1)">*
     * 序列化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 : (jsonObj){
        var newJsonObj = if (typeof(jsonObj) == 'undefined' || typeof(jsonObj) == 'function') 
            newJsonObj = ''typeof(jsonObj) == 'number') 
            newJsonObj = jsonObj.toString();            
        typeof(jsonObj) == 'boolean') 
            newJsonObj = (jsonObj) ? '1' : '0'typeof(jsonObj) == 'object'if (!jsonObj) newJsonObj = ''if (jsonObj instanceof RegExp) newJsonObj = jsonObj.toString();
        }
        typeof(jsonObj) == 'string' jsonObj;        
        typeof(newJsonObj) == 'string') 
             encodeURIComponent(newJsonObj);
            
        var ret =instanceof Array) {
            var i = 0; i < jsonObj.length; i++typeof(jsonObj[i]) == 'undefined')     continue;
                ret.push(typeof(jsonObj[i]) == 'object' ? '' : base.serialize(jsonObj[i]))
            }
            return ret.join('|')
        } 
         jsonObj) {                
                ;
                newJsonObj = ;
                typeof(jsonObj[i]) == 'object') {
                    if (jsonObj[i]  Array) {
                        newJsonObj = jsonObj[i];
                        ret.push(i + '=' + base.serialize(newJsonObj));
                    }  {
                        ret.push(i + '=')
                    }
                }  {
                    newJsonObj = jsonObj[i];
                    ret.push(i + '=' + base.serialize(newJsonObj));
                }
            }
            return ret.join('&')
        }
    },1)">*
     * 反序列化为JSON对象
     * 对url参形形式的对象反序列化成为JSON对象
     * 与serialize相对应
     * @param {object} jsonObj json对象
     * @return {string}
     
    unSerialize : (jsonStr,de){
        de = de || 0;
        jsonStr = jsonStr.toString();
        if (!jsonStr)  {};
        var retObj = {},obj1Ret = jsonStr.split('&');
        if (obj1Ret.length == 0)  retObj
        var i = 0; i < obj1Ret.length; i++if (!obj1Ret[i]) var ret2 = obj1Ret[i].split('='if (ret2.length >= 2var ret0 = obj1Ret[i].substr(0,obj1Ret[i].indexOf('=')),ret1 = obj1Ret[i].substr(obj1Ret[i].indexOf('=') + 1if (!ret1) ret1 = ''if (ret0) retObj[ret0] = de == 0? decodeURIComponent(ret1) : ret1;
            }
        }
         retObj;
    },1)">*
     * 对整个object进行utf8格式的url解码
     * @param {object} newopt 解码对象
     * @return {object} 已解码对象
     
    decode : (newopt) {
        typeof(newopt) == 'string' decodeURIComponent(newopt)
            } (e) {}
             newopt
        }
        typeof(newopt) == 'object'if (newopt == 
            }
            if (newopt  Array) {
                var i = 0; i < newopt.length; i++) {
                    newopt[i] = base.decode(newopt[i])
                }
                 newopt
            }  RegExp) {
                 newopt) {
                    newopt[i] = base.decode(newopt[i]);
                }
                 newopt
            }
        }
         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"var xss = base.xss;
extend(xss,1)">*
     * 通用过滤,对所有涉及到XSS漏洞的敏感字符和符号进行过滤
     * @param {oriStr} string 待过滤的原始字符串
     * @return {string} 过滤后的字符串
     
    filter:(oriStr){
        oriStr){
             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='{}'var i=0;i<charCodes.length;i++if('string'==typeof charCodes[i]){
                tmpFormat='{}';
                tmpChr=charCodes[i];
            }{
                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
        }
        var i=0;i<xssChars.length;i++){
            oriStr=oriStr.replace(new RegExp(xssChars[i],'gi'预防script:
        oriStr=oriStr.replace(/script[\u000d\u000a\u0020]+\:/i,'script&#x3a;' oriStr;
    },1)">*
     * [专门过滤]过滤微信昵称,过滤除emoji表情之外的所有字符
     * @param {oriStr} string 待过滤的原始字符串
     * @return {string} 过滤后的字符串
     
    filterWxNickName:(oriStr){
        console.log(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){
            .filter(oriStr);
        }{
            oriTagStr=oriStr.replace(/\<span\sclass\=\"emoji\semoji[0-9a-z]+\"\>\<\/span\>/g,tag);
            filterTagStr=.filter(oriTagStr);
            var i=0;i<matchArr.length;i++){
                filterTagStr=filterTagStr.replace(tag,matchArr[i]);
            }
             filterTagStr;
        }
    }
});
})();
base.extend(base,base.xss);

 

猜你在找的程序笔记相关文章