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

函数声明： function functionName(){}
函数表达式：var fn = function(){}

• 区别
  他们的区别在变量提前上，函数声明可以直接变量提升，函数表达式和普通的变量提升一样先提升的是变量名。

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

变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明。和变量声明前置一样，执行代码之前会先读取函数声明，只要函数在代码中进行了声明，无论它在哪个位置上进行声明，js引擎都会将它的声明放在范围作用域的顶部。

3、arguments 是什么

arguments是一个类数组对象。代表传给一个function的参数列表。
  arguments对象是函数内部的本地变量；arguments 已经不再是函数的属性了。可以在函数内部通过使用 arguments 对象来获取函数的所有参数。这个对象为传递给函数的每个参数建立一个条目，条目的索引号从0开始。它包括了函所要调用的参数。object对象。类数组。

var f = function(one) {
  console.log(arguments[0]);
  console.log(arguments[1]);
  console.log(arguments[2]);
}
f(1, 2, 3)
// 1
// 2
// 3

4、函数的"重载"怎样实现

• 重载是很多面向对象语言实现多态的手段之一，在静态语言中确定一个函数的手段是靠方法签名——函数名+参数列表，也就是说相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，称为函数重载。

 //其他语言重载范例
 int sum(int num1, int num2){
   return num1 + num2;
 }

 float sum(float num1, float num2){
   return num1 + num2;
 }

 sum(1, 2);
 sum(1.5, 2.4);

• 在JavaScript中没有函数重载的概念，函数通过名字确定唯一性，参数不同也被认为是相同的函数，后面的覆盖前面的，但可以在函数体针对不同的参数调用执行相应的逻辑。

  function printPeopleInfo (name, age, sex){
    if(name){
      console.log(name);
    }
    if(age){
      console.log(age);
    }
    if(sex){
      console.log(sex);
    }
  }
  printPeopleInfo('Byron', 26);
  printPeopleInfo('Byron', 26, 'male');

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

• 立即执行函数表达式（Immediately-Invoked Function Expression），简称IIFE。表示定义函数之后，立即调用该函数。

(function(){
  var a  = 1;
})()

• 其他写法：

(function fn1() {
    alert(11);
}());
[function fn2() {
    alert(22)
}()];
1, function fn3() {
       alert(33)
}();

• 作用：隔离作用域。

6、求n!，用递归来实现

function fn(n){
    if(n === 1|| n===0){
        return 1
    }
    return n*fn(n-1);
}

7、以下代码输出什么

     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('饥人谷', 2, '男');
        /* 输出：name:饥人谷 age:2 sex:男 ["饥人谷",2,"男"] name valley */
        getInfo('小谷', 3);
        /* 输出：name:小谷 age:3 sex:undefined ["小谷",3] name valley */
        getInfo('男');
        /* 输出：name:男 age:undefiend sex:undefined ["男"] name valley */

8、 写一个函数，返回参数的平方和？

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

9、 如下代码的输出？为什么

console.log(a);
var a = 1;
console.log(b);
/* 输出：undefined 报错：b is not defined 原因：变量提升，没有b变量的声明*/

10、如下代码的输出？为什么

        sayName('world');//输出：hello world 函数声明前置
    sayAge(10);//报错：sayAge is not a function 函数表达式不前置
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };

11、如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10
    bar() 
    function foo() {
      console.log(x)//输出10
    }
    function bar(){
      var x = 30
      foo()
    }

    /*
        globalContext = {
            AO:{
                x : 10 ,
                foo: function(){},
                bar: function(){}
            },
            Scope: null
        }
        foo.[[scope]] = globalContext.AO;
        bar.[[scope]] = globalContext.AO;

        barContext = {
            AO: {
                x:30
            }
            Scope: globalContext.AO;
        }

        fooContext = {
            AO: {
                
            }
            Scope: globalContext.AO;
        }

     */

12、 如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10;
    bar() 
    function bar(){
      var x = 30;
      function foo(){
        console.log(x) //输出30
      }
      foo();
    }

    /*
        gobalContext = {
            AO: {
                x:10,
                foo: function(){}
            },
          Scope: null
        }
        bar.[[scope]] = gobalContext.AO

        barContext = {
            AO:{
                x:30,
                foo: function(){}
            },
            Scope: gobalContext.AO
        }
     */

13、以下代码输出什么? 写出作用域链的查找过程伪代码

var x = 10;
    bar() 
    function bar(){
      var x = 30;
      (function (){
        console.log(x)//输出30
      })();
    }
    /*
        gobalContext = {
            AO: {
                x: 10,
                bar: function(){}
            },
            Scope: null
        }
        bar.[[scope]] = gobalContext.AO;
        
        barContext = {
            AO: {
                x: 30,
                IIFE: function(){}
            },
            Scope: gobalContext.AO;
        };

        IIFEContext = {
            AO: {
                
            },
            Scope: barContext.AO
        }
     */

14、

    var a = 1;

    function fn(){
      console.log(a)//undefined 
      var a = 5;
      console.log(a)//输出5
      a++
      var a
      fn3();
      fn2();
      console.log(a)//输出20

      function fn2(){
        console.log(a);//输出6
        a = 20;
      }
    }

    function fn3(){
      console.log(a)//输出1
      a = 200;
    }

    fn();
    console.log(a)//输出200

    //输出结果依次为  undefined,5,1,6,20,200

     /*
        gobalContext = {
            AO: {
                a:1,
                fn: function(){},
                fn3: function(){}
            },
            Scope: null
        };

        fn[Scope] = gobalContext.AO;
        fn3[Scope] = gobalContext.AO;
        
        fnContext = {
            AO: {
                a: 20,
                fn2: function(){}
            }
            Scope: gobalContext.AO;
        };

        fn3Context = {
            AO: {
                  
            },
            Scope: gobalContext.AO;
        };
        
        fn2Context = {
            AO: {
                
            },
            Scope: fnContext.AO
        }

      */