1.方法重载

js中并不直接支持类似c#的方法重载，所以只能变相的来解决，示意代码：(利用了内置属性arguments)

var f1 = function(p1,p2,p3){
    switch(arguments.length){
        case 0:
            alert("无参版本的f1")
            break;
        case 1:
            alert("1个参数版本的f1：" + p1)
            break;
        case 2:
            alert("2个参数版本的f1：" + p1 + "，" + p2)
            break;
        case 3:
            alert("3个参数版本的f1：" + p1 + "，" + p2 +  "，" + p3)
            break;
        default:
            alert("不支持多于3个参数的调用!");
            break;
    }
}
 
f1();
f1("1");
f1("a",100);
f1("1","2","3");
f1("1","2","3","4")

2.参数个数检测

js引擎同样也不会在function调用时，强制检查参数个数，所以只能自己处理，示例代码:

var fnMustOneParam = function(p){
                 
    //检测有没有参数传入
    if (typeof p=="undefined"){
        alert("fnMustOneParam必须要有参数传入，才能调用(1)!");
        return ;
    }
 
    //也可以写成这样
    if (arguments.length==0){
        alert("fnMustOneParam必须要有参数传入，才能调用(2)!");
        return;
    }
 
    //检测参数个数
    if (arguments.length!=0){
        alert("fnMustOneParam只能传入一个参数调用!");
        return;
    }
 
    //to do...
 
}
 
//fnMustOneParam(1,3,4);

 3.参数基本类型检测
js引擎同样更不会检测参数的类型，如果您希望对参数的基本类型做些限制，可以利用typeof 来判断基本类型

var fnString = function(s){
    if (arguments.length!=1){
        alert("参数个数不匹配!");
        return ;
    }
 
 
    if (typeof s != "string"){
        alert("只能传入string类型的参数!");
        return ;
    }
     
}
 
//fnString(123);

 4.自定义类的参数类型检测
第3条所提到的方法，只能检测参数的基本类型，如果是自定义类的参数，如果用typeof运算符号，只能得到object的类型检测结果，这时可利用instanceof运算符号来解决

function Person(name,age){
    this.name = name;
    this.age = age;
}
 
function fnPerson(p){
    if (arguments.length==1 && p instanceof Person){
    //if (arguments.length==1 && p.constructor == Person) //也可以写成这样
        alert("fnPerson调用成功，p.name=" + p.name + ",p.age=" + p.age);
    }
    else{                   
        alert("必须传入一个Person类型的参数才能调用!");
    }
}
 
fnPerson("asdf");
fnPerson(new Person('菩提树下的杨过',30))