函数与作用域

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

//函数声明
function fn() {
    console.log('hello');
}
//函数表达式
var fn = function() {
    console.log('hello');
}

对于函数声明来说， 声明不必放在调用之前。但是对于函数表达式来说，声明必须放在调用之前。
因为Javascript解释器中存在一种变量声明被提升的机制，也就是说函数声明会被提升到作用域的最前面，即使写代码的时候是写在最后的。用函数表达式创建的函数是在运行时赋值，并且要在等到表达式赋值完成之后才能调用。

总结：

函数声明在JS解析时进行函数提升，因此在同一个作用域内，不管函数声明在哪里定义，该函数都可以被调用；而
函数表达式的值是在运行时确定，并且在表达式赋值完成之后，该函数才能被调用。

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

变量的声明前置指的是在一个作用域中，所有的变量声明都会被放在作用域的开头。如：

// var a  变量提升到开头 声明
console.log(a) //undefined
var a = 7;
console.log(a);  // 7

函数的声明前置指的就是声明函数表达式，将函数作为一个变量来声明，调用必须在声明之后，否则会报错。

3. arguments 是什么

在函数的内部可以使用arguments对象获取到该函数的所有传入参数。arguments对象是所有函数都可以使用的局部变量。此对象包含传递给函数的每个参数的条目，第一个条目从索引0开始。arguments对象不是一个Array。但类似于Array,但除了长度以为没有任何Array属性。但可以转化成一个真正的Array

var args = Array.prototype.slice.call(arguments);
var args = [].slice.call(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. 立即执行函数表达式是什么？有什么作用

立即执行表达式（IIFE）

//立即执行函数表达式， 
(function(){
    var a = 1;
})();
console.log(a);   //undefined.使用立即执行函数表达式，可以隔离作用域

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

使用立即执行函数表达式的目的：

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

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

function factorial(n) {
  if (n === 1) {
    return 1
  } else {
    return n * factorial(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: undefied;age:undefned;sex:男;['男']；name: valley

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

   function sumOfSquares(){
    var arr = Array.prototype.slice.call(arguments);
    var total = 0;
    arr.map(function(value) {
        total = total + value * value;
    });
    return total;
   }
   var result = sumOfSquares(2,3,4)
   var result2 = sumOfSquares(1,3)
   console.log(result)  //29
   console.log(result2)  //10

9. 如下代码输出什么？为什么？

    console.log(a);  //undefined
    var a = 1;
    console.log(b); //error
    //变量a声明提升,打印前没有赋值，所以undefined。变量b完全没有声明，所以报错。

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

    sayName('world');
    sayAge(10);
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };
    
    //hello   world
    //error
    //函数声明 ，调用的时候 可以不看位置。函数表达式声明，由于声明前置的问题，必须先声明，后调用。

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

var x = 10
bar() 
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
  foo()
}
// 10
/*
globalContext = {
    A0 = {
        x: 10
        foo: function
        bar: function
    },
    Scope: null
}
foo.[[scope]] = globalContext.A0
bar.[[scope]] = globalContext.A0

barContext = {
    A0 = {
        x: 30
    }
    Scope: bar.[[scope]]
}
fooContext = {
    A0 = {}
    Scope: foo.[[scope]] //globalContext.A0
}
*/

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}   
// 30
/*
globalContext = {
    A0 = {
        x: 10
        bar: function
    },
    Scope: null
}
bar.[[scope]] = globalContext.A0

barContext = {
    A0 = {
        x: 30
        foo: function
    }
    Scope: bar.[[scope]]
}
foo.[[scope]] = barContext.A0

fooContext = {
    A0 = {
        x: 30
    }
    Scope: foo.[[scope]] //barContext.A0
}
*/

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}
// 30
/*
globalContext = {
    A0 = {
        x: 10
        bar: function
    },
    Scope: null
}
bar.[[scope]] = globalContext.A0

barContext = {
    A0 = {
        x: 30
        IIFE: function
    }
    Scope: bar.[[scope]]
}
IIFE.[[scope]] = barContext.A0
*/

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)
//undefined
//5
//1
//6
//20
//200

/*
globalContext = {
    A0 = {
        a: 1 -> 200
        fn: function
        fn3: function
    },
    Scope: null
}
fn.[[scope]] = globalContext.A0
fn3.[[scope]] = globalContext.A0

fnContext = {
    A0 = {
        a: 5 -> 6
        f2: function
    }
    Scope: fnContext.A0
}
f2.[[scope]] = fnContext.A0

fn2context = {
    A0 = {
        a: 6 -> 20
    }
}
*/