函数与作用域

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

function命令声明的代码区块，就是一个函数。function命令后面是函数名，函数名后面是一对圆括号，里面是传入函数的参数。函数体放在大括号里面。

function print(s) {
  console.log(s);
}```
除了用function命令声明函数，还可以采用变量赋值的写法。

var print = function(s) {
console.log(s);
};```
这种写法将一个匿名函数赋值给变量。这时，这个匿名函数又称函数表达式（Function Expression），因为赋值语句的等号右侧只能放表达式。
函数的表达式需要在语句的结尾加上分号，表示语句结束。而函数的声明在结尾的大括号后面不用加分号。

区别：

函数声明：声明不必放到调用的前面
函数表达式：声明必须放到调用的前面

JavaScript 解释器中存在一种变量声明被提升（hoisting）的机制，也就是说变量（函数）的声明会被提升到作用域的最前面，即使写代码的时候是写在最后面，也还是会被提升至最前面。
例如以下代码段：

alert(foo); // function foo() {}
alert(bar); // undefined
function foo() {}
var bar = function bar_fn() {};
alert(foo); // function foo() {}
alert(bar); // function bar_fn() {}```
输出结果分别是function foo() {}、undefined、function foo() {}和function bar_fn() {}。
可以看到 foo 的声明是写在 alert 之后，仍然可以被正确调用，因为 JavaScript 解释器会将其提升到 alert 前面，而以函数表达式创建的函数 bar 则不享受此待遇。

# 2.什么是变量的声明前置？什么是函数的声明前置
在一个作用域下，var 声明的变量和function 声明的函数会前置
与全局作用域一样，函数作用域内部也会产生“变量提升”现象。var命令声明的变量，不管在什么位置，变量声明都会被提升到函数体的头部。
# 3.arguments 是什么
由于JavaScript允许函数有不定数目的参数，所以我们需要一种机制，可以在函数体内部读取所有参数。这就是arguments对象的由来。

arguments对象包含了函数运行时的所有参数，arguments[0]就是第一个参数，arguments[1]就是第二个参数，以此类推。这个对象只有在函数体内部，才可以使用。
# 4.函数的"重载"怎样实现
>函数重载(英語:Function overloading)，是Ada、C++、C#、D和Java等编程语言中具有的一项特性，这项特性允许创建数项名称相同但功能的输入输出类型不同的子程序，它可以简单地称为一个单独功能可以执行多项任务的能力。

其他语言重载范例

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中，先定义的函数，会被后定义的函数覆盖。因此Javascript不支持函数的重载，不能够定义同样的函数然后通过编译器去根据不同的参数执行不同的函数。

但是javascript却可以通过自身属性去模拟函数重载。
变相实现函数重载的方法：
- 利用arguments对象

```

• 利用闭包（有点难，学学回来再看。）
  参考文章：http://www.cnblogs.com/yugege/p/5539020.html
  参考文章：https://johnresig.com/blog/javascript-method-overloading/
  参考文章：http://www.cnblogs.com/bluedream2009/archive/2011/01/05/1925963.html

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

立即执行函数就是
1.声明一个匿名函数
2.马上调用这个匿名函数

JavaScript引擎规定，如果function关键字出现在行首，一律解释成语句，为了兼容 JS 的语法。避免浏览器报语法错误，可以这样写：
(function(){alert('我是匿名函数')} ()) // 用括号把整个表达式包起来
(function(){alert('我是匿名函数')}) () //用括号把函数包起来
!function(){alert('我是匿名函数')}() // 求反，我们不在意值是多少，只想通过语法检查。
+function(){alert('我是匿名函数')}()
-function(){alert('我是匿名函数')}()
~function(){alert('我是匿名函数')}()
void function(){alert('我是匿名函数')}()
new function(){alert('我是匿名函数')}()

只有一个作用：创建一个独立的作用域。
这个作用域里面的变量，外面访问不到（即避免「变量污染」）。
参考文章：https://zhuanlan.zhihu.com/p/22465092

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

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

factor(5);

注意：求递归的时候要考虑负数和0；

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: 男
 ["饥人谷", 2, "男", callee: function, Symbol(Symbol.iterator): function]
 name valley

 name: 小谷
 age: 3
 sex: undefined
 ["小谷", 3, callee: function, Symbol(Symbol.iterator): function]
 name valley

 name: 男
 age: undefined
 sex: undefined
 ["男", callee: function, Symbol(Symbol.iterator): function]
 name valley

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

 function sumOfSquares(){
var sum = 0;
   for (var i = 0; i

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

    console.log(a);//undefined;变量a被提升
    var a = 1;
    console.log(b);//Uncaught ReferenceError: b is not defined;b未声明

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

sayName('world');
sayAge(10);
function sayName(name){
    console.log('hello ', name);//hello world;函数声明被提升到代码最前面。
}
var sayAge = function(age){
    console.log(age);//Uncaught TypeError: sayAge is not a function;这是函数表达式，只有var sayAge被提升到代码前面；
};

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
}

barContext= {
AO: {
     x:30
   }
scope:globalContext.AO
}

fooContex= {
AO: {}
scope:globalContext.AO
}

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

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

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

barContext= {
AO: {
x:30
foo: function
}
scope:globalContext.AO
}

fooContex= {
AO: {}
scope:barContext.AO
}

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

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

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

barContext= {
AO: {
     x:30
   }
scope:globalContext.AO
}

fooContex= {
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

globalContext = {
  AO: {
    a: 1
    fn: function
    fn3: function
  },
  Scope: null
}

fnContext= {
AO: {
     a:5
     fn2: function
   }
scope:globalContext.AO
}

fn2Contex= {
AO: {}
scope:fnContext.AO
}

fn3Contex= {
AO: {}
scope:globalContext.AO
}