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

• 函数声明：function foo(arguments){////};
• 函数表达式：var foo = function(arguments){///};

两者除了在写法上的不同以外，最大的区别在于：函数声明提前的是整个函数，而函数表达式所提前的是函数名所代表的变量。下面看一个例子：

func1();
func2();
function func1(){
    console.log("I'm func1");
}
var func2=function(){
    console.log("I'm func2");
} 

其结果为：

若此时将func2();替换为func2;则此时结果为：

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

JavaScript会线检索一遍全部代码，如果遇到变量声明，会默认的将其置入最前端。如：var a=3;，会被拆分为var a;和a=3;两句，并把var a;提升至代码首行，所以：

console.log(a);// undefined
var a=3;
console.log(a);// 3

函数声明前置，意为将函数的位置前提，具体第一题中已经做出了回答。值得注意的是，函数声眀提前至变量声明之后。

3、arguments 是什么？

arguments是函数的固有属性，它代表了传入函数的形参所组成的数组。
例如：

function foo(x,y,z){
        console.log(arguments);
        console.log(arguments.length);
        console.log(arguments[2])
}
foo(1,2,3);  // [1,2,3]  3  3
foo(1,2);     //[1,2]    2   undefind
foo(1,2,3,4,5) //[1,2,3,4,5]   5   3 

可见arguments与函数所声明的变量没有什么关系，最终还是取决于实际的传入参数。我们亦可以通过给arguments.length赋值，来改变arguments的数据结构。

function foo(x,y,z){
        arguments.length=5;
        console.log(arguments);
}
foo(1,2,3);  //  [1,2,3,undefined,undefined]

4、函数的重载怎样实现

在静态语言中，同种函数拥有唯一的函数名与形参，相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，称为函数重载。
JavaScript并没有函数重载这个特性，因为只要函数名相同JS就认为是同一个函数。
但是我们可以通过判断传入参数的个数来简单的模拟函数重载,例如：

function specialSum(){
        if(arguments.length ==1 ){
                return arguments[0];
}
        if(arguments.length =2){
                return arguments[0]*10+arguments[1];
}
}

5、立即执行函数表达式是什么？有什么作用？

立即执行函数表达式：
(function() {statement} ());或者(function() {statement}) ();
为什么function(){statement}();这种写法不行呢？？
因为JavaScript解释器，遇见funtion时会将该语句当做函数声明来处理，而正常的函数声明写法后面显然是没有最后那一对括号的。function() {statement} 的本质是一个函数，所以只需要用新的括弧将它包装起来，就可以“骗过”解释器，从而将函数立即生效。

作用
最大、最常见的用处是形成自己的封闭空间，防止内部参数与外部参数的相互污染，实现自我的私有封装。

JavaScript中的立即执行函数表达式

6、什么是函数的作用域链？

先说函数的作用域，JavaScript最大的作用域为全局作用域（window），任何子作用域都能引用全局作用域中的变量。任何一个变量，只在它所在范围的作用域内生效，且子作用域可以继承父作用域中的变量。举这么一个例子：

var a = 1;                                    
function func1(){                       
          var b = 2;
          function func2(){ 
                  var a = 3;
                  var c = 4; 
                  console.log(a); 
                  console.log(b); 
           }
           function func3(){
                  console.log(c);           
            }           
           func2();                            // 3   2
           func3();                            //error:c is not defined;
}
func1();
connsole.log(a);                          //1 

我们可以理解上例中有三层作用域：

• 第一层为全局作用域，其中有一个全局变量a = 1；
• 第二层作用域为函数func2，也有一个局部变量b = 2；
• 第三层分别为func2,和func3，其中func2有两个变量 a = 3，c = 4，而func3没有变量。

实际上这就已经形成了一个作用链，

• 对于 func2来说，它首先会寻找自己所拥有的局部变量以及其对应值（a=3,c=4）,但其本身没有b这个变量，那么它便会在它的父级函数中寻找，所以它能在func2中找到b=2。
• 而对于 func3想要寻找c这个变量，func3中寻找——>未果——>func1中寻找——>未果——>window中寻找——>未果。因此抛出错误，c is not defined。

虽然func2中对变量c进行了声明，但是func2与func3没有任何关系，换句话来说他们不在一条作用链上，自然func3无法识别变量。

代码：

1. 以下代码输出什么？ （难度**）

    function getInfo(name, age, sex){
        console.log('name:',name);
        console.log('age:', age);
        console.log('sex:', sex);
        console.log(arguments);
        arguments[0] = 'valley';
        console.log('name', name);
    }

    getInfo('hunger', 28, '男');   //name: hunger age: 28 sex: 男    ["hunger",28,"男"]   name valley
    getInfo('hunger', 28);         //name: hunger age: 28    ["hunger",28]   name valley
    getInfo('男');                       //name:男    ["男"]   name valley

2.写一个函数，返回参数的平方和？如 （难度**）

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

3.如下代码的输出？为什么 （难度*）

   console.log(a);     //undefined  
    var a = 1;
    console.log(b);   //error:b is not definede

实际上该代码为：

    var a;
    console.log(a);     
    a = 1;
    console.log(b);   

4.如下代码的输出？为什么 （难度*）

    sayName('world');
    sayAge(10);
    function sayName(name){      
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };
//   hello world    erro:sayAge is not a function
//   函数声明使函数定义被提前；而函数表达式只有函数名所代表的变量提前，本质是变量，而非函数。

5.如下代码的输出？为什么 （难度**）

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

照妖镜还原：

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

6.如下代码的输出？为什么 （难度3）

    function fn(fn2){
       console.log(fn2);
       var fn2 = 3;
       console.log(fn2);
       console.log(fn);
       function fn2(){
            console.log('fnnn2');
        }
     }
    fn(10);
// function  3  function

照妖镜还原：

    function fn(fn2){
        var fn2;
        function fn2(){
            console.log('fnnn2');
        }
       console.log(fn2);
       fn2 = 3;
       console.log(fn2);
       console.log(fn);
     }
    fn(10);

7.如下代码的输出？为什么 （难度3）

    var fn = 1;
    function fn(fn){
         console.log(fn);
    }
    console.log(fn(fn));   //error: fn is not a function; 

照妖镜还原：

    var fn；
    function fn(fn){
         console.log(fn);
    }
    fn=1;
    console.log(fn(fn));   //error: fn is not a function; 

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

没什么好解释的吧，变量声明提前，故前两个为undefined,后面进行赋值了，自然输出数值。

9.如下代码的输出？为什么 （难度4）

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

照妖镜还原：

    var i,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);
    

10.如下代码的输出？为什么 （难度4）

    var say = 0;
    (function say(n){
        console.log(n);
        if(n<3) return;
        say(n-1);
    }( 10 ));
    console.log(say);
// 10 9 8 7 6 5 4 3 2 0

虽然立即执行函数并不会提前，但是会立刻执行，所以say函数一直在迭代，并且同时输出10 9....一直到2（小于3），此时return null,函数结束。最终console.log(say);会输出0，因为立即执行函数所在的封闭空间发生的一切事情与外界无关。