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

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

两者的区别在于函数声明会前置，定义的Name函数名会受到javascript的变量名提升机制的影响，函数表达式其实就是创建一个匿名的函数声明并赋值给一个变量，可以省略函数名。

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

在一个作用域下，var声明的变量和function声明的函数会前置
不在函数作用域内,var声明的变量和function声明的函数都会前置到全局最顶部
在函数作用域内，var声明的变量和function声明的函数则会前置到函数体的最顶部
就是看变量和函数的作用于在什么地方，那么就前置到什么地方的最顶部。

3.arguments 是什么

arguments是函数所有参数的集合（数组），可以在函数内使用，既然是类数组，可以用arguments[0]来表示第一个参数。

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

js不支持重载，同名函数会覆盖，需要对参数进行非空或者类型的判断来模拟函数重载（可以用if条件判断语句来实现）

  function printPeopleInfo(name, age, sex){
    if(name){
      console.log(name);
    }

    if(age){
      console.log(age);
    }

    if(sex){
      console.log(sex);
    }
  }
  printPeopleInfo('Li', 26);//Li 26
  printPeopleInfo('Byron', 26, 'male');//Byron 26 male

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

类似于下面的写法是立即执行函数表达式：

(function(){
//todo
}())

作用：隔离作用域，让函数里面的变量被保护起来，外部无法访问。

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

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

fn(3)就返回6

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, '男');
getInfo('小谷', 3);
getInfo('男');

"name:饥人谷"
"age:2"
"sex:男"
[object Arguments] {
  0: "饥人谷",
  1: 2,
  2: "男"
}
"name:valley"
"name:小谷"
"age:3"
"sex:undefined"
[object Arguments] {
  0: "小谷",
  1: 3
}
"name:valley"
"name:男"
"age:undefined"
"sex:undefined"
[object Arguments] {
  0: "男"
}
"name:valley"

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

   function sumOfSquares(){
          var be=0;
          for(var i=0;i<arguments.length;i++){
            be+=arguments[i]*arguments[i];
          }
          return be;
   };
   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); ////ReferenceError: b is not defined，没有b变量的声明

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

 sayName('world');  //变量声明到最前面
 sayAge(10); //表达式形式不会被前置，所以执行到这里没有sayAge这个函数，报错。
 function sayName(name){
     console.log('hello ', name);
 }
 var sayAge = function(age){
     console.log(age);
 };

"hello "
"world"
"error"
"TypeError: sayAge is not a function

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

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

    globalContext = {
        AO:{
            x:10
            foo:function
            bar:function
        },
    Scope:null
    }

    foo.[[scope]] = globalContext.AO
    bar.[[scope]] = globalContext.AO

    2.调用bar()
    barContext = {
        AO:{
            x:30
        },
        Scope:bar.[[scope]] = globalContext.AO
    }
    x变成30

    3.调用foo()
    fooContext = {
        AO:{},
        Scope:foo.[[scope]] = globalContext.AO
    }
    输出10

总之就是在当前作用域下找，没有再往上找。

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

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

globalContext = {
  AO:{
    x:10,
    bar:function,
  },
  scope:none,
}
bar['scope'] = globalContext.AO;
barContext = {
  AO:{
    x:30,
    foo:function,
  },
  scope: globalContext.AO,
}
fooContext = {
  AO:{},
  scope:barContext.AO,
}

输出30

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}

输出30

    globalContext = {
        AO:{
            x:10
            bar:function
        },
        Scope:null
    }
    bar.[[scope]] = globalContext.AO
   
    barContext = {
        AO:{
            x:30
            function
        },
        Scope:bar.[[scope]] =globalContext.AO
    }
    function.[[scope]] = barContext.AO

    functionContext = {
        AO:{},
        Scope:function.[[scope]]=barContext.AO
    }
    

14. 以下代码输出什么？ 写出作用域链查找过程伪代码

var a = 1;

function fn(){
  console.log(a)
  var a = 5
  console.log(a)
  a++
  var a
  fn3()
  fn2()
  console.log(a)

  function fn2(){
    console.log(a)
    a = 20
  }
}

function fn3(){
  console.log(a)
  a = 200
}

fn()
console.log(a)








globalContext = {
  AO:{
    a:200,
    fn:function,
    fn3:function,
  },
  scope:none;
}
fn['scope'] = globalContext.AO;
fn3['scope'] = globalContext.AO;
fn3Context = {
  AO:{},
  scope:globalContext.AO,
}
fnContext = {
  AO:{
    a:20,
    fn2:function,
  },
  scope:globalContext.AO
}
fn2['scope'] = fnContext.AO;
fn2Context = {
  AO:{},
  scope:fnContext.AO
}