ECMA5Script的函数function

Function类型，即函数的类型。
一个典型的JavaScript函数定义如下：
function 函数名称(参数列表){
函数体;
}
注意：参数列表直接写形参名即可，不用写var
return 语句：return返回函数的返回值并结束函数运行
函数可作为参数进行传递
示例：

//参数列表相当于函数的入口，return语句相当于函数的出口
function test(a,b){
    return a+b;
}
var re = test(5,12);
alert(re);
alert(typeof test); // function 函数也是一种数据类型(function类型)

函数当作参数传递

function test(aa){
    aa();
}
function test1(){
    alert("执行啦没！！！");
}
test(test1);//函数当做参数传递
test(function(){
    alert("执行了吖····");
})

在js中函数是可以嵌套定义的，尽量避免

function test3(){
    function test4(){
        alert("这里是test4");
    }
    test4();
}
test3();

***********************function重点**************************
函数的三种定义方式

//1、function语句式  常用  性质：静态  解析顺序：优先解析   作用域：具有函数的作用域
function test(){
    alert("这是function语句式");
}
test();

//2、函数的直接量     常用  性质：静态  解析顺序：顺序解析  作用域：具有函数的作用域
var test2 = function(){
    alert("这是函数的直接量");
}
test2();

//3、function构造函数式   性质：动态  解析顺序：顺序解析  作用域：顶级作用域
var test3 = new Function("a","b","return a+b;");
alert(test3(10,20));

效率对比

var d1 = new Date();
var t1 = d1.getTime();
for(var i = 0 ; i<=100000;i++){
    //function test(){;}         //function语句式
    //var test = function (){;} ;  //function直接量     只实例化一次，占用内存 ，效率高
    //var test = new Function();  //function构造函数式  每次动态new定义 ，不占内存，效率低
}
var d2 = new Date();
var t2 = d2.getTime();
alert(t2-t1);

解析顺序：对于function语句式的函数，会被优先解析;function直接量和function构造函数式是顺序解析

示例一：
test1();
function test1(){
    alert("这是function语句式");
}

alert(test2);  //变量声明了，未赋值
test2();
var test2 = function(){
    alert("这是字面量的方式");
}

示例二：
function f(){return 1;}                 // 函数1  
alert(f());     //返回值为4 说明第1个函数被第4个函数覆盖 
var f = new Function("return 2;");      // 函数2 
alert(f());     //返回值为2 说明第4个函数被第2个函数覆盖
var f = function(){return 3;}           // 函数3 
alert(f());     //返回值为3 说明第2个函数被第3个函数覆盖 
function f(){return 4;}                 // 函数4 
alert(f());     //返回值为3 说明第4个函数被第3个函数覆盖
var f = new Function("return 5");       // 函数5 
alert(f());     //返回值为5 说明第3个函数被第5个函数覆盖 
var f = function(){return 6 ;}          // 函数6 
alert(f());     //返回值为6 说明第5个函数被第6个函数覆盖

函数作用域：

var k = 5 ; 
function t1(){
    var k = 6 ;    //局部变量
    //function test(){return k ;}          //6    函数语句式作用域是 函数作用域
    //var test = function(){ return k};    //6    函数直接量作用域是 函数作用域
    var test = new Function('return k;');  //5    构造函数式作用域是顶级作用域
    alert(test());
}
t1();

函数形参和实参：通过arguments 对象获取

示例一：
function test(a,b,c,d){
    //alert(test.length); //函数的形参个数
    //函数的实际参数  内部是用数组接收的函数的实际参数
    //arguments 对象，访问函数的实际参数，只能在函数的内部访问使用
    //alert(arguments.length);  //函数的实参个数
    //if(test.length == arguments.length){
    if(arguments.callee .length == arguments.length){
        return a+b;
    }else{
        return "实际参数不正确";
    }
    //arguments 对象多用于递归对象
    //arguments.callee  函数本身
}
//实参
alert(test(5,6));

示例二： arguments.callee 必要性
function fact(num){
     if(num <=1) return 1 ;
     //else  return num*fact(num-1);            //会存在隐患
     else  return num*arguments.callee(num-1);     //函数体中不要出现函数名称
}
alert(fact(5));
//这是一个典型的递归实现阶乘函数，如果程序中采用了下面代码就会导致程序错误
var anotherFact = fact; 
fact = null;    
alert(anotherFact(4));      //出错！！    fact is not a function