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类型的参数才能调用!");
    }
}

 

 

转载于:https://www.cnblogs.com/wuxiang/p/3922794.html