JavaScript函数闭包以及作用域

递归函数

递归函数：在函数内部调用自身，一般解决数学问题。
菲波那切数列：1,1,2,3,,5,8,13,21,34……

function feibo(n) {
  // 用户输入第n项，返回对应的值
  // 从第3项开始值等于n-1对应的值+n-2对应的值
  if(n === 1 || n == 2) {
    return 1;
  }else {
    return feibo(n-1) + feibo(n-2);
  }
}

console.log(feibo(1));
console.log(feibo(2));
console.log(feibo(3));
console.log(feibo(4));
console.log(feibo(5));
console.log(feibo(50));

变量的作用域

函数的内部声明的变量，只能在函数内部使用，在函数外部任何地方都不能访问。

// 在函数内部声明的变量只能在函数内部使用
function fun() {
  // a在函数内部声明的，只能在fun函数内部使用
  var a = 10;
  console.log(a);
}

// a在函数外部不能使用
console.log(a);

对于js。只有函数能够关住变量的作用域。

局部变量和全局变量

局部变量：在一个作用域（定义域）内定义的变量就是这个作用域内的局部变量。只能在作用域内被访问到。
全局变量：从广义上来看，全局变量也是一种局部变量。全局变量定义在全局，所以也叫全局变量。可以在任何地方都被访问到。
变量申明的原理：全局变量，在全局定义之后，会永久存在，任何时候，任何位置访问，都能够找到它。局部变量定义在函数内部的，函数定义的过程，并没有真正的去定义这个局部变量，只有在执行函数的时候，才会立即定义这个局部变量，执行完之后，变量就被立即销毁了，在其他的地方访问变量的时候，找不到这个变量，所以会有一个引用错误，变量未定义。

// 在全局范围内定义的变量
var a = 10;
// 函数
function fun() {
  // 函数内部可以使用全局a
  console.log(a);
  // b在函数内部声明，只能在函数内部使用，b局部变量
  var b = 20;
  console.log(++ b);
}

// 在函数内部声明b，在函数外部不能使用
// console.log(b);
fun();

形式参数是局部变量

形参也是局部变量，只能在函数内部使用，在外部任何地方都不能访问。

// 形参是局部变量
function fun(a,b,c) {
  console.log(a);
  console.log(b);
  console.log(c);
}

// 调用
fun(10,20,30,40,50);

全局变量作用

1传递作用。在不同函数间使用全局变量可以作用信号量，这些函数都可以改变信号量，使用新值参与计算。

// a 是全局变量，任何地方都可以使用
// a称为信号量，不管任何函数改变a的值，都可以记住并且再次使用都是使用a改变之后的新值参与计算
var a = 10;
// 函数使用a
function fun() {
  a ++;
  console.log(a);
}

// 函数也可以使用a
function fun2() {
  a --;
  console.log(a);
}

2 通信作用，在同一个函数使用全局变量，不会每次都清空，也是使用当前的新值参与计算。

// 使用全局变量
var a = 1;
// 声明函数
function fun() {
  console.log(++ a);
}

fun();
fun();
fun();
fun();
fun();
fun();
fun();
fun();
// 输出新值
console.log(a);

作用域链

指的是我们变量查找的一个规律：我们可以在不同的作用域内使用相同的标识符去命名变量。我们在使用一个变量的时候，需要找到匹配的标识符，我们有重复的，用哪一个？如果在当前作用域有这个变量，就直接使用，如果当前作用域没有这个变量定义，会一层一层的从本层往外依次查找，遇到第一个就直接使用。类似于就近原则。
当遇见一个变量时，JS引擎会从其所在的作用域依次向外层查找，查找会在找到第一个匹配的标识符的时候停止。在多层嵌套的作用域中可以定义同名的标识符，发生“遮蔽效应”。

// 全局a
var a = 10;
function fun1() {
  var a = 20;
  // 本层作用域有变量直接使用20
  console.log(a);
  function fun2() {
    // 本层作用域没有a的定义，从本层出发，向外进行查找20
    console.log(a);
    function fun3() {
      // 本层有a定义直接使用
      var a = 30;
      console.log(a);
    }
    fun3();
  }
  fun2();
}

// 调用
fun1();
console.log(a);

如果变量声明时，不写var关键字，计算机会自动在全局作用域内给它进行一个声明，局部变量就强制性的变成了全局变量。这种情况是不合理，会造成一个全局变量的污染。所以，定义变量必须写var关键字。

// 全局a
var a = 10;
// 等价于在全局声明var a = 20;
function fun1() {
  // 函数内部的var 省略，强制转为全局变量
  a = 20;
  console.log(a);
  function fun2() {
    console.log(a);
  }
  fun2();
}
fun1();
console.log(a);

函数的作用域

在函数内部声明的函数，只能在函数内部声明，在函数外部任何地方都不能访问。

// 声明函数
function outer() {
  // 函数内部声明一个变量
  var a = 10;
  // 函数内部声明一个函数
  function inner() {
    console.log(a);
  }
  // 调用函数
  inner();
}

// 调用函数
outer();
// inner在函数外部不能使用
inner();

闭包

函数本身就是闭包，函数可以记住自己定义时所处的外部环境，和内部语句，这就是闭包。

function outer() {
  var a = 10;
  function inner() {
    console.log(a);
  }
  // console.log(inner);
  // inner没有小括号。表示定义语句
  return inner;
}

// 调用outer返回的是Inner函数的定义
// console.log(outer());

// 用i变量接收outer()，相当于把inner函数赋值i
var i = outer();
i();

对于inner函数，外部环境var a = 10;内部语句console.log(a)，不管我们把inner函数拿到哪里它都可以记住自己的所处的外部环境（变量的作用域）和自己的内部语句。
闭包是函数天生存在的性质，不需要任何结构，只不过我们需要借助这种形式体会到闭包。

// 形参是局部变量
function outer(x) {
  function inner(y) {
    // 当前作用域没有x的定义，使用outer中x
    console.log(x + y);
  }
  // 返回inner定义
  return inner;
}

// 将outer调用赋值给i,相当于将inner定义赋值的i
//类似于把inner拿到外部使用，能够记住自己定义时所处的外部环境x=10
//类似于把inner拿到外部使用，能够记住自己定义时内部语句console.log(10+ y)
//i = function inner(y) {console.log(10 + y)}
var i = outer(10);
// 调用i函数
i(20,30,40);
// 声明一次函数i可以多次调用
i(100);

// 闭包：函数能够记住定义时的外部环境和内部语句
function outer(x,y) {
  function inner(y) {
    // 作用域链根据就近原则
    // console.log(y);
    console.log(x + y);
  }
  // 调用outer(x,y)返回的是inner函数
  return inner;
}

// i赋值的是inner函数
// outer(1,2) x = 1, y =2
var i = outer(1,2);
// i是inner函数名字，调用i函数，i的实际参数是赋值给inner函数y
// i（10）调用，能够记住x = 1,还可以内部语句console.log(1 + y)
i(10);
i(20);

闭包并不是一成不变的，函数的每一次调用都会产生一个全新的闭包。
举例：

function fun1() {
  var a = 10;
  function fun2() {
    a ++;
    console.log(a);
  }
  // 调用fun1返回的是fun2的定义
  return fun2;
}

// 每一次fun1调用都产生一个全新的闭包，之间互不影响
var inn1 = fun1();
var inn2 = fun1();

// 闭包的外部环境不是一成不变的，能够记住当前的新值，并且参与计算
inn1();
inn1();
inn1();
inn1();

// 每一次fun1调用都产生一个全新的闭包,inn1和inn2闭包互不影响
// 每一个闭包，外部环境是全新的内部语句也是全新的
inn2();
inn2();

inn1();