js函数、预编译和递归

1.函数声明和函数表达式

• 函数声明

function a() {
    
}

• 函数表达式

var a = function () {
    
}

2.预编译
在全局变量中 ： 生成GO对象相当于window（创建过程类似下面的AO对象）
函数声明整体提升
变量 声明提升（赋值不提升）

console,log(a);
 var a = 100;

结果：undefined,声明但是没有赋值
不是not defined

预编译发生在函数执行之前：
四部曲：
1.创建AO对象
2.找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
3.将实参值和形参统一
4.在函数体里面找函数声明，值赋予函数体

function test(a,b) {
    console.log(a);
    c = 0;
    var c;
    a = 3;
    b = 2;
    console.log(b);
    function b() {

    }
    function d() {

    }
    console.log(b);

}
test(1);

1.创建AO对象 Activity Objection 活动对象，执行上下文

AO {
    
 }

2.找形参和变量声明，将变量和形参名作为AO属性名，值为undefined

AO {
    a: undefined,
    b: undefined,
    c: undefined
 }

3.将实参值和形参统一

AO {
    a: 1,
    b: undefined,
    c: undefined
 }

4.在函数体里面找函数声明，值赋予函数体

AO {
    a: 1,
    b: function b() {

     },
    c: undefined,
    d: unction d() {

     }
 }

预编译过程完成，在AO基础上执行函数。所以结果是：

 1
  2
  2

函数执行完之后，

AO {
    a: 3,
    b: 2,
    c: 0,
    d: unction d() {

     }
 }

函数中的两个function已经预编译，所以不再编译。

例子：

var x = 1;
  function add(n) {
      n += 2;
      return n;
  }
  var y = add(x);
  function add(n) {
      n += 4;
      return n;
  }
  var z = add(x);
  console.log(x,y,z);

  // 1 5 5 

3.递归

 function jc(n) {
      if (n == 1) {
          return 1;
      }
      return n * jc(n - 1);
      //递归
      //两点：1，找规律，2，找出口
      //规律：n！= n * （n - 1)!
      //死循环！出口==》
  }

/规律 feiji（n）= feiji（n - 1）+ feiji（n - 2）
 function feiji(n) {
     if (n == 1 || n == 2) {
         return 1;
     }
     return feiji(n -1) + feiji(n - 2);
}