JavaScript函数命名空间、参数类型重载实现

有时候使用doFunc({arg1: xxx, arg2:xxx});不方便,还是得在参数表重载,而重载情况又多种多样弄得晕头转向,结果就试着写了这么个东西,也不知道有没有地方能用上:

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
    <title>命名空间、参数类型重载</title>
    <script type="text/javascript" src="arg-func.js"></script>
    <script type="text/javascript">
        (function () {
            var MyFuncs = {
                ‘myNamespace.exampleFunc(string str, number num)‘: function (str, num) {
                    alert(‘str: ‘ + str + ‘ num: ‘ + num);
                },
                ‘myNamespace.exampleFunc(number num)‘: function (num) {
                    alert(‘num: ‘ + num);
                },
                ‘myNamespace.exampleFunc(array)‘: function (arr) {
                    alert(‘arr: ‘ + arr);
                },
                ‘myNamespace.exampleFunc()‘: function () {
                    alert(‘无参数重载‘);
                }
            };

            ArgFunc.parse(MyFuncs);
        })();
    </script>
</head>
<body>
    <label>有效调用:</label><br />
    <input type="button" value="myNamespace.exampleFunc(‘abc‘,123)" onclick="myNamespace.exampleFunc(‘abc‘, 123)" /><br />
    <input type="button" value="myNamespace.exampleFunc(123)" onclick="myNamespace.exampleFunc(123)" /><br />
    <input type="button" value="myNamespace.exampleFunc([1,2,3])" onclick="myNamespace.exampleFunc([1, 2, 3])" /><br />
    <input type="button" value="myNamespace.exampleFunc()" onclick="myNamespace.exampleFunc()" /><br />
    <label>无效调用:</label><br />
    <input type="button" value="myNamespace.exampleFunc(false)" onclick="myNamespace.exampleFunc(false)" /><br />
    <input type="button" value="myNamespace.exampleFunc(‘abc‘,123,[1,2,3])" onclick="myNamespace.exampleFunc(‘abc‘, 123, [1, 2, 3])" /><br />
</body>
</html>

用到的arg-func.js:

(function () {
    if (!String.prototype.trim) {
        String.prototype.trim = function () {
            return this.replace(/(^\s+)|(\s+$)/g, ‘‘);
        };
    }

    var TYPE = { UNKOWN: null, UNDEFINED: ‘undefined‘, NULL: ‘null‘, BOOLEAN: ‘boolean‘, NUMBER: ‘number‘, STRING: ‘string‘, FUNCTION: ‘function‘, OBJECT: ‘object‘, ARRAY: ‘array‘ };
    function getType(o) {
        if (o === undefined) { return TYPE.UNDEFINED; }
        if (o === null) { return TYPE.NULL; }
        switch (typeof (o)) {
            case TYPE.BOOLEAN: return TYPE.BOOLEAN;
            case TYPE.NUMBER: return TYPE.NUMBER;
            case TYPE.STRING: return TYPE.STRING;
            case TYPE.FUNCTION: return TYPE.FUNCTION;
        }
        switch (Object.prototype.toString.call(o)) {
            case ‘[object Array]‘: return TYPE.ARRAY;
            case ‘[object Object]‘: return TYPE.OBJECT;
            default: return o ? TYPE.OBJECT : TYPE.UNKOWN;
        }
    }

    var _ArgFunc = {
        _parse: function (format, func, namespace) {
            var lp = format.indexOf(‘(‘), rp = format.indexOf(‘)‘);
            var name = format.substring(0, lp);
            var argTypes = format.substring(lp + 1, rp).split(‘,‘);
            for (var i = 0, len = argTypes.length; i < len; i++) {
                argTypes[i] = argTypes[i].trim().split(/ +/)[0];
            }
            argTypes = argTypes.join(‘,‘);

            var nsnn = _ArgFunc._analyseNamespace(name, namespace);
            namespace = nsnn.namespace;
            name = nsnn.name;

            var wrapperFunc = namespace[name];
            if (!wrapperFunc) {
                wrapperFunc = namespace[name] = function () {
                    ArgFunc.apply(wrapperFunc, arguments);
                };
            }

            if (wrapperFunc[argTypes]) {
                throw ‘方法已存在参数类型一样的重载。‘;
            } else {
                wrapperFunc[argTypes] = func;
            }
        },
        _analyseNamespace: function (name, upperNamespace) {
            var namespace = upperNamespace || window;
            var parts = name.split(‘.‘);
            var name = parts.pop();
            for (var i = 0, part; part = parts[i]; i++) {
                if (!namespace[part]) {
                    namespace[part] = {};
                }
                namespace = namespace[part];
            }
            return { namespace: namespace, name: name };
        }
    };

    var ArgFunc = {
        bind: function (funcs, prototype) {
            ArgFunc.parse(funcs, prototype);
        },
        parse: function (funcs, namespace) {
            if (arguments.length == 3) {
                _ArgFunc._parse(arguments[0], arguments[1], arguments[2]);
            } else if (getType(funcs) == TYPE.OBJECT) {
                for (var format in funcs) {
                    _ArgFunc._parse(format, funcs[format], namespace);
                }
            } else if (getType(funcs) = TYPE.ARRAY) {
                for (var i = 0, func; func = funcs[i]; i++) {
                    _ArgFunc._parse(func[0], func[1], namespace);
                }
            }
        },
        apply: function (func, args) {
            var argTypes = [];
            for (var i = 0, len = args.length; i < len; i++) {
                var arg = args[i];
                argTypes.push(getType(arg));
            }
            argTypes = argTypes.join(‘,‘);

            func = func[argTypes];
            if (!func) {
                throw ‘没有找到参数类型匹配的重载方法‘;
            } else {
                func.apply(this, args);
            }
        }
    };
    if (!window[‘ArgFunc‘]) {
        window[‘ArgFunc‘] = ArgFunc;
    }
})();
时间: 2024-12-11 02:00:43

JavaScript函数命名空间、参数类型重载实现的相关文章

JavaScript命名空间、函数参数类型重载的实现

突然心血来潮写的东西,可以考虑在func({arg1: xxx, arg2: xxx})不适用的情况下使用. <!DOCTYPE html> <html lang="zh"> <head> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <title>命名空间.参数类型重载</title>

Python函数学习-参数类型

函数的参数 在定义Python函数时可定义形参,这些参数在调用时候才能确定具体的值,由函数的调用者负责为行参传入参数值 函数的参数类型 一. 位置参数 也叫必传参数,顺序参数,是最重要的,也是必须在调用函数时明确提供的参数!位置参数必须按先后顺序,一一对应,个数不多不少的传递! 说明:a,b,c是函数add的行参,没有具体的值,只有在add(x,y,z)是才被传入值,a=x=1,b=y=2,c=z=3, 其中x,y,z叫做实参,add(4,5,6,7),add(5,7)均为错误调用 二.关键字参

指定函数的参数类型

题目:海滩上有一堆桃子,五只猴子来分.第一只猴子把这堆桃子凭据分为五份,多了一个,这只 猴子把多的一个扔入海中,拿走了一份.第二只猴子把剩下的桃子又平均分成五份,又多了 一个,它同样把多的一个扔入海中,拿走了一份,第三.第四.第五只猴子都是这样做的, 问海滩上原来最少有多少个桃子? 方法1: for i in range(10000): if (i*5+4)%4 == 0 : a=(i*5+4)/4 if (a*5+4)%4 == 0 : b=(a*5+4)/4 if (b*5+4)%4 ==

深入了解JavaScript函数的参数

ECAMScript函数不介意传递进来多少个参数,也不介意传递的参数的类型,即使定义的函数只接受两个参数,当调用该函数时没有传递参数,甚至传递了三个参数等等都无所谓,这是因为在ECAMScript中参数在内部是用一个数组表示的,函数接受到的始终是一个数组.在函数体内可以通过arguments对象来访问这个参数数组,获取到传递的每一个参数值.arguments[0]可以用来访问调用该函数时传递的第一个参数,以此类推...以下两个函数function1和function2其实是等价的可以实现同样的效

关于JavaScript函数及其参数

问题由来: 1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <title>Document</title> 6 </head> 7 <body> 8 9 </body> 10 <script type="text/javascript"&

函数输入参数类型为枚举时,则限定函数参数的接收范围,非枚举值输入则错误

1 typedef enum 2 { 3 Mon = 1, 4 Tues, 5 Wed, 6 Thurs, 7 Fri, 8 Sat, 9 Sun 10 }week; 11 12 void week_func(week day) 函数参数 day 为枚举类型week,在使用函数 week_func() 时,参数只接收枚举值 Mon ~ Sun,输入数值1···或枚举值之外的值都是错误的 原文地址:https://www.cnblogs.com/skullboyer/p/9060056.html

函数的参数类型带协议约束

在头文件中,我们在这个类里面定义一个方法,然后参数的类型是一个对象,或者直接id,但是我们要求这个对象,必须是实现了myprotocol里面的协议的对象,才能传进来.这样也起到一个约束和提醒作用,提醒其他开发人员这个对象必须实现了xxx协议的才能传进来. #import "myprotocol.h" @interface  test : NSObject -(void)setFooObject:(id <myprotocol>)object withKey:(NSStrin

C#控制台基础 函数的参数类型是EventArgs如何传递数值

1 code 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace ConsoleApplication3 8 { 9 /// <summary> 10 /// 这个类继承于eventargs,是它的子类 11 /// </summary> 12 class

理解JavaScript函数参数

前面的话 javascript函数的参数与大多数其他语言的函数的参数有所不同.函数不介意传递进来多少个参数,也不在乎传进来的参数是什么数据类型,甚至可以不传参数. arguments javascript中的函数定义并未指定函数形参的类型,函数调用也未对传入的实参值做任何类型检查.实际上,javascript函数调用甚至不检查传入形参的个数 ? 1 2 3 4 5 6 7 function add(x){ return x+1; } console.log(add(1));//2 console