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

函数声明格式：

functionName();
function functionName(参数){
         console.log('hello')
}
声明不必放到调用的前面

函数表达式格式：

var functionName = function (参数){
          console.log('hello')
}
functionName();

等价于

var functionName
functionName();
var functionName = function(){
          console.log('hello')
}

声明必须放到调用的前面

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

变量的声明前置就是把变量的声明提升到当前作用域的最前面。

函数的声明前置就是把整个函数提升到当前作用域的最前面(位于前置的变量声明后面)，代码执行前会先生成该函数，然后再执行语句。

console.log(a);    //undefined，在一个作用域下，var声明的变量和function声明的函数会前置
var a = 1;
console.log(b);    // b is not defined    

3、arguments 是什么？

arguments 是一个类似数组的对象, 对应于传递给函数的参数。对象仅在函数内部有效，在函数外部调用 arguments 对象会出现一个错误。

4、函数的“重载”怎样实现？

在 JS 中，没有重载! 同名函数会覆盖。但可以在函数体针对不同的参数调用执行相应的逻辑

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、立即执行函数表达式是什么？有什么作用？（题13）参考

(function(){
  var a  = 1;
})()
console.log(a);     //undefined

其他写法

(function fn1() {});
// 在数组初始化器内只能是表达式
[function fn2() {}];
// 逗号也只能操作表达式
1, function fn3() {};

作用： 隔离作用域。
一是不必为函数命名，避免了污染全局变量；
二是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。

6.1、求n!（n的阶乘），用递归来实现

function factor(n){
  if(n === 1 || n==0) {
    return 1
  }else if(n < 1){
    return false
  }
  return n * factor(n-1)
}

factor()

6.2 求 1+2+...+n 的值

function sum(n){
  if(n === 1) {
    return 1
  }
  return n + sum(n-1)
}
sum()

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:undefined  age:undefined  sex:男;["男"];name valley

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

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

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()
}

作用域链

1\全局
globalContext = {
    AO:{
        x:10
        foo:function(){}
        bar:function(){}
    }
    scope:null
}
foo.[[scope]]=globalContext.AO
bar.[[scope]]=globalContext.AO

2\
barContext = {
    AO : {
        x:30
    }
    scope:bar.[[scope]]=globalContext.AO
}

3\
fooContext = {
    AO:{}
    scope:globalContext.AO
}

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

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

作用域链

1\
globalContext = {
  AO:{
    x:10
    bar:function(){}
  }
}
bar.[[scope]]=globalContext.AO

2\
barContext = {
  AO:{
    x:30
    foo:function(){}
  }
  scope:globalContext.AO
}
foo.[[scope]]:barContext.AO

3\
fooContext = {
    AO:{}
    scope:barContext.AO
}

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

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

作用域链

1\
globalContext = {
    AO:{
        x:10
        bar:function(){}
    }
}
bar.[[scope]]:globalContext.AO

2\
barContext = {
  AO:{
      x:30
      foo:function(){}
  }
  scope:globalContext.AO
}
foo.[[scope]]:barContext.AO

3\
fooContext = {
  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

作用域链

1\
globalContext = {
  AO:{
      a:1>200
      fn:function(){}
      fn3:function(){}
  }
}
fn.[[scope]]:globalContext.AO
fn3.[[scope]]:globalContext.AO

2\
fnContext = {
  AO:{
    a:5 >6>20
    fn2:function(){}
  }
  scope:globalContext.AO
}
fn2.[[scope]]:fnContext.AO

3\
fn3Context = {
  AO:{}
  scope:globalContext.AO
}

4\
fn2Context = {
  AO:{}
  scope:fnContext.AO
}