`
JavaSam
  • 浏览: 952708 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

自定义 javascript 通用函数 学习用

阅读更多
 
var reg = {
	"html" : /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/ //匹配html代码
};
var allFinded = [];
/**
 * @author wsf
 * 检测浏览器版本
 */
var browser = {
    "explorer": {
        "ie": /msie ([\d.]+).*\.net clr (\d\.){1,2}\d+\)$/,
        "firefox": /firefox\/([\d.]+)/,
        "chrome": /chrome\/([\d.]+)/,
        "opera": /opera.([\d.]+)/,
        "safari": /version\/([\d.]+).*safari/,
		"se" : /msie ([\d.]+).*\.net clr (\d\.){1,2}\d+; 360se\)$/,//360浏览器
		"sougou" : /msie ([\d.]+).*\.net clr (\d\.){1,2}\d+; .*metasr.*\d\)$/,//搜狗浏览器
		"maxthon" : /maxthon\/([\d.]+)///遨游浏览器webkit
    }
};

/**
 * 常用js代码
 */
var oCommon = {
    /**
     * 改变本地对象的方法
     */
    base: function(){
        Array.prototype.indexOf = function(vValue){
            for (var i = this.length - 1; i >= 0; i--) {
                if (this[i] == vValue) {
                    return i;
                }
            }
            return -1;
        };
        Array.prototype.deleteIndex = function(index){
            var t = this.slice(index, index + 1);
            this.splice(index, 1);
        };
        Array.prototype.deleteVal = function(val){
            var index = this.indexOf(val);
            this.deleteIndex(index);
        };
        
        
        /**
         * 判断浏览器代码
         */
        var userAgent = navigator.userAgent.toLowerCase();
        var expName = null;
        (expName = userAgent.match(browser.explorer.ie)) ? browser.ie = expName[1] :
		(expName = userAgent.match(browser.explorer.firefox)) ? browser.firefox = expName[1] :
		(expName = userAgent.match(browser.explorer.chrome)) ? browser.chrome = expName[1] : 
		(expName = userAgent.match(browser.explorer.opera)) ? browser.opera = expName[1] : 
		(expName = userAgent.match(browser.explorer.safari)) ? browser.safari = expName[1] : 
		(expName = userAgent.match(browser.explorer.se)) ? browser.se = expName[1] :
		(expName = userAgent.match(browser.explorer.sougou)) ? browser.sougou = expName[1] : 
		(expName = userAgent.match(browser.explorer.maxthon)) ? browser.maxthon = expName[1] :
		false;
		  
    },
    /**
     * 类选择器解决ie不支持document.getElementByClassName;
     * @param {Object} elem
     * @param {Object} selector
     */
    classSelect: function(elem, selector){
        var childNodes = elem.childNodes;
        var oClassEle = arguments[2] ? arguments[2] : [];
        for (var i = childNodes.length - 1; i >= 0; i--) {
			if(!childNodes[i].className)continue;
            if (childNodes[i].childNodes.length > 0) {
                oCommon.classSelect(childNodes[i], selector, oClassEle);
            }
            if (childNodes[i].className.indexOf(selector) != -1) {
                var thisClass = childNodes[i].className;
                var tmp = thisClass.split(/\s/);
                if (oCommon.inArray(selector, tmp)) {
                    oClassEle.push(childNodes[i]);
                }
            }
        }
        return oClassEle;
    },
    /**
     * 选择器
     */
    select: function(selector){
        var flag = selector.charAt(0);
        var reg = /[a-zA-Z]/;
        var selector = reg.test(flag) ? selector : selector.substring(1);
        switch (flag) {
            case null:
                return null;
                break;
            case "":
                return null;
                break;
            case ".":
                if (document.all) {
                    return oCommon.classSelect(document.body, selector);
                }
                else  if (document.getElementsByClassName) {
                        return document.getElementsByClassName(selector);
                }
                break;
            case "#":
                var eles = [];
                eles[0] = document.getElementById(selector);
                return eles;
                break;
            default:
			    if(arguments[1]) 
					return arguments[1].getElementsByTagName(selector);
                return document.getElementsByTagName(selector);
                break;
        }
    },
	/**
	 * 判断对象是否为空
	 * @param {Object} obj
	 */
	isEmptyObj : function(obj){
		for(var i in obj){
			return false;
		}
		return true;
	},
    inArray: function(val, oArray){
        for (var i = oArray.length - 1; i >= 0; i--) {
            if (oArray[i] === val) 
                return true;
        }
        return false;
    },
    /**
     * 兄弟节点
     */
    sibling: function(firstSibling, elem){
        var siblings = [];
        for (; firstSibling; firstSibling = firstSibling.nextSibling) 
            firstSibling.nodeType === 1 && firstSibling !== elem && siblings.push(firstSibling);
        return siblings
    },
    /**
     * 所有兄弟节点
     */
    siblings: function(elem){
        return oCommon.sibling(elem.parentNode.firstChild, elem);
    },
	next : function(ele){
		return ele.nextSibling;
	},
	prev : function(ele){
		return ele.previousSibling;
	},
	parent : function(ele){
		return ele.parentNode;
	},
	first : function(ele){
		return ele.firstChild;
	},
	last : function(ele){
		return ele.lastChild;
	},
	hasChild : function(ele){
		if(ele.childNodes){
			return (ele.childNodes).length > 0;
		}
	},
	find : function(ele,selector){
		var kids = ele.childNodes;
		for(var i in kids){
			var resultFinded = oCommon.children(kids[i],selector);
			var kid = kids[i];
			if(kid.nodeType !== 1) continue;
			if(resultFinded.length > 0) {
				for(var k in resultFinded){
					allFinded.push(resultFinded[i]);
				}
			}
			if(oCommon.hasChild(kid)){
				oCommon.find(kid,selector);
			}
		}
		return allFinded;
	},
    /**
     * 所有子节点或者指定子节点SSS
     */
    children: function(parent, selector){
        if (selector) {
            var kids = oCommon.sibling(parent.firstChild);
            var filterKids = oCommon.select(selector);
            var temp = [];
            for (var i = kids.length - 1; i >= 0; i--) {
                for (var j = filterKids.length; j >= 0; j--) {
                    if (kids[i] === filterKids[j]) 
                        temp.push(filterKids[j]);
                }
            }
            return temp;
        }
        else {
            return oCommon.sibling(parent.firstChild);
        }
    },
	child : function(parent,index){
		var kids = oCommon.children(parent);
		if (!(typeof index === "number")) {
			return null;
		}
		for(var i = kids.length - 1 ; i >= 0 ; i --){
			if(i === index - 1){
				return kids[i];
			}
		}
		return null;
	},
    /**
     * 所有父节点
     */
    parents: function(elem, selector){
        var parents = [];
        var parent = elem.parentNode;
        var filterParents = [];
        for (; parent; parent = parent.parentNode) {
            parent.nodeType === 1 && parents.push(parent);
        }
        if (selector) {
            filterParents = oCommon.select(selector);
            var temp = [];
            for (var i = parents.length - 1; i >= 0; i--) {
                for (var j = filterParents.length - 1; j >= 0; j--) {
                    if (parents[i] === filterParents[j]) {
                        temp.push(filterParents[j]);
                    }
                }
            }
            return temp;
        }
        return parents;
    },
	/**
	 * 动态改变样式信息
	 * @param {Object} oEle dom对象
	 * @param {Object} style 样式信息
	 */
    css: function(oEle){
        var args = arguments;
        var len = args.length;
        switch (len) {
            case 1:
                throw new Error("请填写样式信息!");
                break;
            case 2:
                var options = args[1];
                if (typeof options === "object") {
                    for (var key in options) {
                        eval("oEle.style." + key + " = \"" + options[key] + "\"");
                    }
                }else if(typeof options === "string"){
					return eval("oEle.style." + args[1]);
				}else{
					throw new Error("参数有误!");
				}
                break;
            case 3:
                eval("oEle.style." + args[1] + " = \"" + args[2] + "\"");
                break;
        }
    },
	html : function(ele,str){
		if(!ele){
			throw new Error("对象为空!");
		}
		if(!arguments[1] && "innerHTML" in ele ){
			return ele.innerHTML;
		}else{
			if("innerHTML" in ele){
				ele.innerHTML = str;
			}else{
				throw new Error("此元素不支持innerHTML属性!");
			}
		}
	},
	attribute : function(ele,attrName,attrVal){
		if(!attrVal){
			return ele.attrName;
		}else{
			ele.attrName = attrVal;
		}
	},
	/**
	 * 判断是否有样式
	 * @param {Object} oEle
	 * @param {Object} className
	 */
	hasClass : function(oEle , className){
		return oEle.className.match(new RegExp('(\\s|^)' +  className + '(\\s|$)'));
	},
	/**
	 * 添加样式信息
	 * @param {Object} oEle
	 * @param {Object} className
	 */
    addClass : function(oEle,className){
		if(! oCommon.hasClass(oEle,className)){
			oEle.className += " " + className;
		}
	},
    /**
     * 移除样式信息
     * @param {Object} oEle
     * @param {Object} className
     */
	removeClass : function(oEle , className){
		if(oCommon.hasClass(oEle,className)){
			var _thizClassName = oEle.className;
			_thizClassName = oCommon.trim( _thizClassName.replace(className,""));
			oEle.className = _thizClassName;
		}
	},
		/**
	 * 
	 * @param {Object} oEle
	 * @param {Object} className
	 */
	toggleClass : function(oEle , className){
		if(oCommon.hasClass(oEle,className)){
			oCommon.removeClass(oEle,className);
		}else {
			oCommon.addClass(oEle,className);
		}
	},
	/**
	 * 动画目前只支持 width height 
	 * @param {Object} id
	 */
	animate : function(ele){
        var elem = ele, f = j = 0, callback, _this = {}, tween = function(t, b, c, d){
            return -c * (t /= d) * (t - 2) + b
        }
        _this.execution = function(key, val, t){
            var s = (new Date()).getTime(), d = t || 500, b = parseInt(elem.style[key]) || 0, c = val - b, a = function(){
                var t = (new Date()).getTime() - s;
                if (t > d) {
                    t = d;
                    elem.style[key] = tween(t, b, c, d) + 'px';
                    j && callback && callback.apply(elem);
                    return true;
                }
                elem.style[key] = tween(t, b, c, d) + 'px';
                setTimeout(a, 10);
            }
            a();
        }
        _this.animate = function(sty, t, fn){
            callback = fn;
            for (var i in sty) {
                j++;
                _this.execution(i, parseInt(sty[i]), t);
            }
        }
        return _this;
	},
	visible : function(ele){
		return oCommon.css(ele,"display") !== "none";
	},
	/**
	 * @param {Object} ele
	 * @param {Object} speed
	 */
	slideDown : function(ele,speed){
        var h = oCommon.css(ele, "height");
		if(!oCommon.visible(ele)){
			oCommon.css(ele,"height","0.000001px");
			oCommon.css(ele,"display","block");
		}
        oCommon.animate(ele).animate({
            height: h
        }, speed, function(){
        });
	},
	/**
	 * @param {Object} ele
	 * @param {Object} speed
	 */
	slideUp : function(ele,speed){
        oCommon.animate(ele).animate({
            height: '0px'
        }, speed, function(){
			oCommon.css(ele,"display","none");
        });
	},
	/**
	 * @param {Object} ele
	 * @param {Object} speed
	 */
	slideToggle : function(ele,speed){
		if(oCommon.visible(ele)){
			oCommon.slideUp(ele,speed);
		}else{
			oCommon.slideDown(ele,speed);
		}
	},
	/**
	 * 去除前端空格
	 * @param {Object} str
	 */
	prevTrim : function(str){
		str = str.replace(/^\s+/,"");
		return str;
	},
	/**
	 * 去除后端空格
	 * @param {Object} str
	 */
	
	lastTrim : function(str){
		str = str.replace(/\s+$/,"");
		return str;
	},
	/**
	 * 去除两端、中间的所有空格
	 * @param {Object} str
	 */
	middleTrim : function(str){
		str = str.replace(/\s+/g,"");
        return str;		
	},
	/**
	 *去除两端空格
	 * @param {Object} str
	 */
	trim : function(str){
		str = oCommon.prevTrim(str);
		str = oCommon.lastTrim(str);
		return str;
	},
	/**
	 * 对象循环
	 */
	each : function(object,callback){
		if(object && typeof object === "object"){
			if(object instanceof Array && object.length === 0){
				return;
			}
			for(i in object){
				callback(i,object[i]);
			}
		}else{
			throw new Error("对象不知此此方法!");
		}
	},
	/**
	 * 生成tab
	 * @param {Object} target
	 * @param {Object} length
	 */
	createTab : function(tabOptions,target){
		return oCommon.private.createTab(tabOptions);
	},
    /**
     * ajax请求
     */
    ajax: function(options){
        var httpRequest = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
        httpRequest.onreadystatechange = function(){
            var dataType = options.dataType.toLowerCase();
            httpRequest.readyState === 4 && httpRequest.status === 200 && options.callback(dataType === "json" ? eval("(" + httpRequest.responseText + ")") : dataType === "xml" ? httpRequest.responseXML : httpRequest.responseText,options.context);
        };
        httpRequest.open(options.mode, options.url, options.sync);
        options.mode.toLowerCase() === "get" ? httpRequest.send(null) : httpRequest.send(options.params);
    },
	
    /**
     * 调用某方法的target
     */
    currentTarget: function(){
    	return false;
    },
	/**
	 * cookie的读写
	 */
	cookie : function(){
		this.flag = false;
		if(!this.flag){
			/**
			 * 利用正则表达式根据cookie名取得cookie值
			 * @param {Object} key
			 */
            oCommon.cookie.prototype.getCookie = function(key){
                var arr = document.cookie.match(new RegExp("(^|\s*)" + key + "=([^;]*)(;|$)"));
                return arr ? decodeURIComponent(arr[2]) : null;
            }
			/**
			 * 添加cookie
			 * @param {Object} name
			 * @param {Object} value
			 * @param {Object} expires 单位为分钟
			 * @param {Object} path
			 * @param {Object} domain
			 * @param {Object} secure
			 */
            oCommon.cookie.prototype.setCookie = function(name, value, expires, path, domain, secure){
				var date ;
				if(expires === 0){
					date = new Date(0);
					expires =  date.toUTCString() ;
				}else{
					if(expires && (typeof expires === "number")){
						date = new Date();
						date.setTime(date.getTime() + expires * 60 * 1000);
					}else{
						date = expires;
					}
					expires = expires ? date.toUTCString(): false;
				}
                document.cookie = name + "=" + encodeURIComponent(value) +
                ((expires) ? "; expires=" + expires : "") +
                ((path) ? "; path=" + path : "") +
                ((domain) ? "; domain=" + domain : "") +
                ((secure) ? "; secure" : "");
            }
			/**
			 * 删除cookie
			 * @param {Object} key
			 */
			oCommon.cookie.prototype.delCookie = function(key){
			   this.getCookie(key) ? document.cookie = key + "=;expires=Thu, 1 Jan 1970 00:00:00 UTC" : false;
			}
			/**
			 * 清空所有cookie信息
			 */
			oCommon.cookie.prototype.clearCookie = function(){
				var arr = document.cookie.split(";");
				for(i in arr){
					this.delCookie(arr[i].split("=")[0]);
				};
			}
			this.flag = true;
		}
	},
	/**
	 * 模拟Map
	 */
	Map : function(){
		this.flag = false;
		this.store = new Array();
		if(!this.flag){
			 oCommon.Map.prototype.structure = function(key,val){
					this.key = key;
					this.val = val;
			 }
			 oCommon.Map.prototype.put = function (key,val){
			 	for(var i = this.store.length - 1 ; i >= 0 ; i --){
					this.store[i].key === key && this.store[i].val === val ; 
				}
				this.store[this.store.length] = new this.structure(key,val);
			 }
			 oCommon.Map.prototype.get = function(key){
			 	for(var i = this.store.length - 1 ; i >= 0 ; i --){
					if(this.store[i].key === key) return this.store[i].val; 
				}
				return null;
			 }
			 oCommon.Map.prototype.remove = function(key){
			 	for(var i = this.store.length - 1 ; i >= 0 ; i --){
					this.store[i].key === key && this.store.splice(i,1);
				}
			 }
			 oCommon.Map.prototype.keySet = function(){
			 	var keys = new Array();
			 	for(var i = 0 ; i <= this.store.length - 1 ; i ++){
					keys.push(this.store[i].key);
				}
				return keys;
			 }
			 oCommon.Map.prototype.valSet = function(){
			 	var vals = new Array();
			 	for(var i = 0 ; i <= this.store.length - 1 ; i ++){
					vals.push(this.store[i].val);
				}
				return vals;
			 }
			 oCommon.Map.prototype.clear = function(){
			 	this.store.length = 0;
			 }
			 oCommon.Map.prototype.size = function(){
			 	return this.store.length;
			 }
		}
	},
	/**
	 * 模拟StringBuilder
	 */
	StringBuilder : function(){
		this.vStrings = new Array();
		this.flag = false;
		if(!this.flag){
			oCommon.StringBuilder.prototype.append = function(str){
				this.vStrings.push(str);
			}
			oCommon.StringBuilder.prototype.toString = function(){
				return this.vStrings.join("");
			}
			oCommon.StringBuilder.prototype.charAt = function(index){
				return this.toString().charAt(index);
			}
			oCommon.StringBuilder.prototype.clear = function(){
				this.vStrings.length = 0;
			}
			oCommon.StringBuilder.prototype.Delete = function (start,end){
				var tempString = this.toString();
				var prevString = tempString.substring(0,start);
				var nextString = end ?  tempString.substring(end) : tempString.substring(start+1);
				this.clear();
				this.append(prevString);
				this.append(nextString);
			}
			oCommon.StringBuilder.prototype.length = function(){
				return this.toString().length;
			}
		    oCommon.StringBuilder.prototype.substring = function(start,end){
				return this.toString().substring(start,end);
			}
			oCommon.StringBuilder.prototype.replace = function(oldStr,newStr){
				var newStr = newStr ? newStr : "";
				var tempString =  this.toString().replace(new RegExp(oldStr,"g"),newStr);
				this.clear();
				this.append(tempString);
			}
			oCommon.StringBuilder.prototype.indexOf = function (val){
				return this.toString().indexOf(val);
			}
			oCommon.StringBuilder.prototype.lastIndexOf = function(val){
				return this.toString().lastIndexOf(val);
			}
			oCommon.StringBuilder.prototype.insert = function (offset,str){
				var prevString = this.substring(0,offset);
				var middleString = str;
				var nextString = this.substring(offset);
				this.clear();
				this.append(prevString);
				this.append(middleString);
				this.append(nextString);
			}
			this.flag = true;
		}
	}
}
 
0
0
分享到:
评论

相关推荐

    最常用的10个javascript自定义函数(english)

    - **功能概述**:`addEvent()` 是一个用于绑定事件监听器的通用函数,它可以跨浏览器地添加事件监听器。 - **应用场景**: - 在不同浏览器之间提供一致的行为。 - 简化事件绑定的过程,提高代码的可维护性。 - **...

    [hook.js]通用Javascript函数钩子

    //自定义对象匿名函数 function Person() { this.getName = function(name) { alert('Call' + name); } } var p = new Person(); var _p_getName = null; function mygetName(name){alert("Hooked");} p.getName....

    JavaScript 通用库

    JavaScript通用库是编程实践中常用的工具,它集合了一系列实用的函数,可以帮助开发者简化代码,提高开发效率。在Web开发中,JavaScript作为客户端脚本语言,它的通用库尤其重要,因为它们可以处理各种常见的任务,...

    js validator通用函数及实例

    总的来说,“js validator通用函数及实例”这个压缩包是学习和提升JavaScript数据验证能力的好资源,通过研究其中的函数和示例,开发者不仅可以学会基本的验证方法,还能了解到如何将这些方法灵活地应用到实际项目中...

    Eclipse下javascript开发spket插件实现自定义js的自动提示.pdf

    在本文档中,我们将探讨如何在Eclipse环境中利用Spket插件进行JavaScript开发,并实现自定义JavaScript函数的自动提示功能。Spket是一个强大的JavaScript、HTML和CSS开发工具,它为开发者提供了诸如代码提示、语法...

    一个窗体改变通用函数

    在JavaScript环境下,例如使用jQuery库,我们同样可以编写一个窗体改变通用函数来监听窗口的resize事件。这可能涉及到DOM操作、CSS样式修改以及动态布局计算。`$Win.js`、`$Dom.js`、`$Css.js`这些文件名暗示了它们...

    JS通用表单验证函数1

    另一个文件"javaScript通用数据类型校验 - JavaScript - web - JavaEye论坛.files"可能是与帖子相关的附件或资源,可能包含实际的JavaScript代码片段或者验证库。 在实际应用中,使用这些通用验证函数可以极大地...

    asp.net中javascript通用类

    "asp.net中javascript通用类"是指为ASP.NET应用程序设计的一组JavaScript函数或对象,这些函数或对象可以被多次重用,提高了代码的复用性和效率。通过在服务器端(ASP.NET)直接传递参数调用这些通用JS类,开发者...

    javaScript中自定义sort中的比较函数,用于比较字符串长度,数值大小.docx

    ### JavaScript中自定义sort中的比较函数 在JavaScript中,`Array.prototype.sort()` 方法是一个非常实用的功能,它允许我们对数组中的元素进行排序。默认情况下,`sort()` 方法按照字符串的Unicode码点顺序来排序...

    Web客户端统一验证JavaScript函数库组件概述Web客户端统一验证JavaScript函数库组件概述Web客户端统一验证JavaScript函数库组件概述Web客户端统一验证JavaScript函数库组件概述

    JavaScript函数库的设计通常遵循模块化和可复用性原则,使得开发者可以方便地在不同项目中引入和使用。例如,ChkInputs这个文件可能是该函数库的核心实现,包含了各种验证函数和相关的配置选项。它可能包含以下功能...

    JavaScript 通用库(一)

    JavaScript 通用库是一种为了简化开发工作,提高代码复用率而创建的集合,它包含了一系列常用的函数或方法,便于在不同的项目中应用。本篇主要介绍一个名为 `Common.js` 的 JavaScript 类库,该库提供了多种实用的...

    ASP.NET c# 封装常用到的js通用函数

    在IT领域,尤其是在Web开发中,ASP.NET与C#结合使用是构建动态、高效网站的常见方式。在这一过程中,JavaScript作为前端脚本语言,扮演着处理用户交互、数据验证等角色,其重要性不言而喻。因此,将常用的JavaScript...

    一个用于对象深度克隆的同构和可配置javascript函数

    标题提到的"一个用于对象深度克隆的同构和可配置javascript函数"是指一个能够在浏览器环境和Node.js环境中通用(同构)的JavaScript函数,它提供了一种灵活的方式来深度复制复杂的数据结构,同时允许用户根据需求...

    自定义JS类框架

    5. 封装与模块化:为避免全局变量污染和提升代码复用性,自定义框架可能会使用立即执行函数表达式(IIFE)或ES6的模块系统(如`import`和`export`)来封装代码。 6. 观察者模式/发布订阅模式:在自定义框架中,可能会...

    javascript自定义函数参数传递为字符串格式

    自定义函数参数传递为 字符串格式 ,传递方式 1:用this传递 2:引号缺省 3:转义字符(html中 代表”双引号,'代表单引号,javascript中直接\” 和Java通用转义字符集) &lt;html&gt; &lt;head&gt; [removed] ...

    JavaScript的一些工具函数的封装包括url的参数处理数字字符串日期等相关操作函数

    这些函数通常是一些通用的、非特定领域的功能,可以处理各种常见的编程任务。在这个名为"js_utils-master"的压缩包中,我们可以期待找到一系列封装好的JavaScript工具函数,它们涵盖了URL参数处理、数字与字符串操作...

    javascript 添加和移除函数的通用方法

    在JavaScript编程中,为DOM元素添加和移除事件处理函数是一种常见的操作。为了确保兼容不同浏览器并优化性能,我们需要掌握通用的添加和移除函数的方法。本文档将详细介绍实现这一目标的技术细节和步骤。 首先,...

    JavaScript写的一个自定义弹出式对话框代码

    在这篇文章中,作者介绍了一个用JavaScript编写的自定义弹出式对话框的代码实现。此对话框的实现,涉及到了JavaScript中的DOM操作、事件处理、以及CSS样式的控制等多方面知识点。下面,我们将详细探讨这些知识点。 ...

    svg通用操作javascript

    压缩包中的`tbusi.js`、`tmap.js`、`tevent.js`、`tdom.js`、`trule.js`、`tutil.js`、`tconstant.js`、`tsvg.js`可能包含了一些自定义的SVG操作函数,比如辅助计算、事件处理封装、常量定义等,这些可以帮助简化和...

Global site tag (gtag.js) - Google Analytics