函数

1. 函数声明和函数表达式有什么区别？

• 在变量提升或声明提前过程中，函数声明是将整个被定义的函数提前，即该函数可以在任意位置被调用；
  而函数表达式的变量提升则是将函数名作为一个普通参数提前，此时并没有被赋予函数属性，所以只有在被函数表达式赋值后才能调用该函数。、

2. 什么是变量的声明前置？什么是函数的声明前置？

• 变量的声明前置是指将所声明的变量提升，即表示存在该变量，但此时并没有给这个变量赋值；
  函数的声明前置是指将整个被定义的函数提升，此时这个函数是有意义的，可以被调用的。

3. arguments是什么？

• arguments的作用是获取函数中的参数并形成一个类数组对象。

4. 函数的重载怎样实现？

• 通过arguments来实现函数对象数目的变化。

举例：

•   function getInfo(name, age, sex){
        console.log('name:',name);      //  输出'name:'+name的赋值
        console.log('age:', age);       //  输出'age:'+ age的赋值
        console.log('sex:', sex);       //  输出'sex:'+ sex的赋值
        console.log(arguments);         //  获取参数，形成一个类数组对象
        arguments[0] = 'valley';        //  为数组中第一个参数即'name'重新赋值
        console.log('name', name);      //  输出'name:'+name的新值
    }
  
    getInfo('hunger', 28, '男');
    // name: hunger
    // age: 28
    // sex: 男
    // ["hunger", 28, "男"]
    // name valley
    getInfo('hunger', 28);
    // name: hunger
    // age: 28
    // sex: undefined
    // ["hunger", 28]
    // name valley
    getInfo('男');
    // name: 男
    // age: undefined
    // sex: undefined
    // ["男"]
    // name valley
  

###2. 写一个函数，返回参数的平方和？如：
- ```
    function sumOfSquares() {
    }
    sumOfSquares(2,3,4);   // 29
    sumOfSquares(1,3);   // 10

代码如下：

•   function sumOfSquares(){
        var sum = 0;
        for (var i = 0; i < arguments.length; i++) {
            sum += arguments[i]*arguments[i];
        };
        console.log (sum);
    }
    sumOfSquares(2,3,4);   // 29
    sumOfSquares(1,3);   // 10
  

[代码地址](http://book.jirengu.com/jirengu-inc/jrg-vip9/members/%E7%8E%8B%E5%BA%B7/%E4%BB%BB%E5%8A%A1%E5%8D%81%E4%B8%83%EF%BC%9A%E5%87%BD%E6%95%B0/task17-2.html)

###3. 如下代码的输出？为什么？
- ```
    console.log(a);     // undefined
    var a = 1;
    console.log(b);     // Uncaught ReferenceError: b is not defined

• 由于变量提升，且变量a的赋值在语句console.log(a)之后，故console.log(a)输出为undefined；
  因为b为被定义，故浏览器报错。

4. 如下代码的输出？为什么？

•   sayName('world');   // hello world
    sayAge(10);         // Uncaught TypeError: sayAge is not a function
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };
  

- 函数声明提升是把整个被定义的函数提升，故第一行```sayName('world'); ```执行时函数```sayName()```可被调用；
但函数表达式的声明提前只是把函数名作为一个普通变量提升，故```sayAge(10);```执行时```sayAge```只是一个普通变量，故将其作为函数调用会使浏览器报错。

###5. 如下代码的输出？为什么？
- ```
    function fn(){}
    var fn = 3;
    console.log(fn);    // 3

• 变量提升或声明提前后按照执行顺序代码如下：

•   function fn(){}
    var fn;
    fn = 3;
    console.log(fn);
  

故输出结果为```3```。

###6. 如下代码的输出？为什么？
- ```
    function fn(fn2){
       console.log(fn2);
       var fn2 = 3;
       console.log(fn2);
       console.log(fn);
       function fn2(){
            console.log('fnnn2');
        }
     }
    fn(10);
    // fn2(){
    //         console.log('fnnn2');
    //     }
    // 3
    // fn(fn2){
    //    console.log(fn2);
    //    var fn2 = 3;
    //    console.log(fn2);
    //    console.log(fn);
    //    function fn2(){
    //         console.log('fnnn2');
    //     }
    //  }

函数fn()根据声明提前等规则可以变换为：

•   function fn(fn2){
        var fn2;
        function fn2(){
            console.log('fnnn2');
        }
       console.log(fn2);        // 语句1
       fn2 = 3;
       console.log(fn2);        // 语句2
       console.log(fn);         // 语句3
     }
    fn(10);
  

所以语句1输出为函数```fn2()```，语句2执行时```fn2=3```，故输出3，语句3输出函数```fn(fn2)```。

###7. 如下代码的输出？为什么？
- ```
    var fn = 1;
    function fn(fn){
        console.log(fn);
    }
    console.log(fn(fn));    // Uncaught TypeError: fn is not a function

按照变量提升或声明提前可变换为：

•   var fn ；
    function fn(fn){
        console.log(fn);
    }
    fn = 1;
    console.log(fn(fn));
  

所以在执行```console.log(fn(fn));```语句时，```fn```的数据类型为数值，故浏览器报错。

###8. 如下代码的输出？为什么？
- ```
    console.log(j);         // undefined
    console.log(i);         // undefined
    for(var i=0; i<10; i++){
        var j = 100;
    }
    console.log(i);         // 10
    console.log(j);         // 100

变量提升或声明提前后，代码变为：

•   var i;
    var j;
    console.log(j);
    console.log(i);
    for(i=0; i<10; i++){
        j = 100;
    }
    console.log(i);
    console.log(j);
  

当```for```循环之后，```i```的值为10，```j=100```，所以最后的```console.log(i);```输出为10，```console.log(j);```输出为100.

###9. 如下代码的输出？为什么？
- ```
    fn();
    var i = 10;
    var fn = 20;
    console.log(i);
    function fn(){
        console.log(i);
        var i = 99;
        fn2();
        console.log(i);
        function fn2(){
            i = 100;
        }
    }  

变量提升或声明提前后，代码变为：

•   var i;
    var fn;
    function fn(){
        var i
        function fn2(){
            i = 100;
        }
        console.log(i);         
        i = 99;
        fn2();
        console.log(i);         
    }   
    fn();
    i = 10;
    fn = 20;
    console.log(i);
    // undefined
    // 100
    // 10
  

###10. 如下代码的输出？为什么？
- ```
    var say = 0;
    (function say(n){
        console.log(n);     // 10 9 8 7 6 5 4 3 2
        if(n<3) return;
        say(n-1);
    }( 10 ));
    console.log(say);       // 0

变量提升或声明提前后，代码变为：

•   var say;
    function say(n){
        console.log(n);     
        if(n<3) return;
        say(n-1);
    };
    say = 0;
    (function say(n){
        console.log(n);     
        if(n<3) return;
        say(n-1);
    }( 10 ));
    console.log(say);
  

立即调用函数使得```say()```在被调用时不会被```say = 0```覆盖，同时也不会影响全局变量```say = 0```。

***
此教程版权归本人和饥人谷所有，转载需注明来源。