JavaScript函数遇实参与形参——智能而有原则

1.实参与形参个数可以有偏差，不会因为参数不统一而错误。

例1：

functionbox(a,b){
    return a + b;
 }

 alert(box(1,3,5));        //运行结果：“4”。
                           //进行的运算为“1+3”，没有用到“5”。

例2：

functionbox(a,b,c){
    return a + b+c;
 }
 alert(box(1,'5'));         //运行结果：15undefined。
                            //结果为sring类型。进行的运算1与‘5’的字符连接，再与一个不存在(undefined)的字符连接，结果即为15undefined。

2.JS函数不能重载。

因为“函数重载”靠的就是相同函数名根据参数的不同，匹配特定函数，从而执行函数的过程；而JS函数不再排斥“异形”函数，缺失了辨别相同函数名的不同函数的过程，相同函数名的情况下，JS调用时，只会执行最后一个所调函数。

例3：

function box(a,b,c){
    alert('执行了第一个函数，' + a +'+' + c + '='+(a+c));
 } 

function box(a,b,c){
    alert('执行了第二个函数，'+ a + '+' + b + '='+(a+b));
 }                

alert(box(1,'5',3));    //执行结果为：执行了第二个函数，1+5=15
                        //类型为string.               

例4：

function box(a,b,c){
    alert('执行了第二个函数，'+ a + '+' + b + '='+(a+b));
 } 

function box(a,b,c){
    alert('执行了第一个函数，' + a +'+' + c + '='+ (a+c));
 }               

alert(box(1,'5',3));    //执行结果为：执行了第一个函数，1+3=4
                        //类型为number.

3.函数运用arguments对象，很有特点

arguments对象的使用，很好地解释了支持形参、实参不一致而不出错的原理性问题。

3.1 arguments[index]指定参数值，index为参数的索引

例5：

function box(){
    return arguments[0]+arguments[5];
}

alert(box(1,2,3,4,5,6));                       //执行结果为：7
alert(box('Test','UseCase',3,4,5,6));          //执行结果为：Test6
                                               //arguments[0]表示第一个参数，arguments[5]表示第六个参数；上面两个执行结果，都反映了，box()函数只用了所需的指定参数，其他参数都被忽略了。</span>

3.2 arguments.length得到参数的个数

例6：

function box(){
    return arguments.length;
}

alert(box(1,2,3,4,5,6));                      //执行结果为：6
alert(box('Test','UseCase',3,4,5,6));         //执行结果为：6
                                              //当需要知道某序列有多少元素时，将其传入该函数，即可知道</span>

3.3 arguments.length的扩展运用

例7：

function box(){
    var sum = 0;
    for (var i=0;i<arguments.length;i++){
       sum += arguments[i];
    }
    return sum;
}

alert(box(1,3,7,14));                         //运行结果：25
                                              //这样，box()函数就不用管参数到底有几个</span>

4.一个显而易见的错误(只为下面说明问题)

看了例7，可能会有点迷糊，因而添加例8、例9，都说明了一个问题，参数为函数体提供必要信息，用于可控地实现功能。函数(function:功能)

例8：

function box(a,b){
    return a+b+c;
}

alert(box(1,2,3));                                       //ReferenceError:c is not defined
alert(box(1,2));                                         //ReferenceError:c is not defined
                                                         //字面量c未定义</span>

例9：

function box(){
    return a+b+c;
}                           

alert(box(1,2,3));                                       //ReferenceError:a is not defined
                                                         //字面量a未定义</span>

简单比较例2、例4、例8，可以得出这样的结论，JS中的函数体与形参、实参以及形参与实参的关系是：

遵循一个原则：函数实现功能

函数体与形参关系：形参必须满足函数体的必要需求，否则没法进行，即使用了形参未定义的‘字面量’，出错：c is not defined 。

形参与实参关系：实参在形参的标尺下，多出的被拦截而被忽略，缺少的被判断为undefined(不存在)，但都不报错。

智能：是说JS函数对多出的实参去粗取精，对少的实参做了适当的处理，没有雷厉加之，使得函数运行更大限度地平稳协调。