JS function的参数问题

1.当传入的参数个数小于声明的参数个数时,缺少的参数值就是:undefined

   类似方法重载

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.函数中可以通过arguments对象来获取函数的全部参数，也就是说可以用arguments进行参数个数检测

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...
 
}
 
function show()
{
    var largest=Max(10,20,30,1,10000,88,56,123);
     alert(largest);//display:10000
}
function Max(m)
{
   var re=0;
   for(var i=0;i<arguments.length;i++)
   {
      if(arguments[i]>re)
      {
         re=arguments[i];
       }
   }
return re;
}

Arguments对象是一个类似于数组的对象,可以按照参数的数目而不是名称来获取全部参数,并且arguments也具有length属性,可以用来获取获取实际参数的个数.

arguments虽然具有一些数组的特性,但是他不是数组.实际上arguments[]是和实际参数是引用同一变量的两种方法:

function ChangeParamValue()
{
   ChangParamValueDo("第一个参数","第二个参数");
}
function ChangParamValueDo(a,b)
{
    alert("改变前:a:"+a+",b:"+b);// display:改变前:a:第一个参数,b:第二个参数
   arguments[0]="arguments0";
    arguments[1]="arguments1";
   alert("用arguments改变后:a:"+a+",b:"+b); // display:用arguments改变后:a:arguments0,b:arguments0
}
arguments有一个callee属性,用没过来引用当前正在执行的函数
function f(x)
{
      if(x<=1) return x;
      return x*arguments.callee(x-1);
}

3。把对象属性用作参数:这样可以不必去记参数的顺序,用对象的属性名来传参

function ArrayCopy(name,age,grade,sex,height,weiht)
{
   alert("name:"+name+"　age:"+age+"　grade:"+grade+"　sex:"+sex+"　height:"+height+"　weiht:"+weiht);
}
function EasyCopy(args)
{
    ArrayCopy(args.name||"",
    args.age||0,
    args.grade||"one",
    args.sex||"可选",
    args.height||100,
   args.weight||100 )
}
function show()
{
    EasyCopy({name:'lily',age:'13',grade:'three'});
   EasyCopy({name:'mark',height:'180',weight:180}); 
}

4、js引擎同样不会检测参数的类型，如果您希望对参数的基本类型做些限制，可以利用typeof 来进行参数基本类型检测

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

 5、自定义类的参数类型检测，如果是自定义类的参数，如果用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类型的参数才能调用!");
    }
}