javascript 递归、预编译

递归：
// 自己调用自己，称为递归（先执行的最后被返回，缺点运行慢）；
两点：找规律，找出口（已知条件当出口）；
本博客主要讲述关于JS的函数递归，主要从“变量+函数”和“函数+变量”两个方面说明解释。 
相对简单，直接上代码。

function fun()
{
    // 自己调用自己
    fun();
    console.log("digui");
}
fun();
二、函数+变量

// 用递归 来求 5 的阶乘
// n! = n * (n-1)!

// 定义一个函数，用于求 n 的阶乘
function func(n)
{
    if (n == 1)  //出口
    {
        return 1;
    }
    return n * func(n-1);//规律
}
console.log(func(5));
return 5*func(5-1)
return (5-1)*func(5-2)
return (5-2)*func(5-3)
return (5-3)*func(5-4)
return 1
所以先执行的最后返回；他要等下面的执行完；

三、函数+函数
//斐波拉契题(兔子生兔子题目)--从出生后第3个月起每个月都生一对兔子，
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少
// 产量分析：1， 1， 2， 3， 5， 8， 13， 21 。。。
// 第n个月的兔子总数  =  第n-1个月的兔子总数 + 第n-2个月的兔子总数
// 问题： 求任意月兔子的总数

function func( n )
{
    if (n == 0 || n == 1)
    {
        return 1;
    }
    return func(n-1) + func(n-2);
}

var a = func(5);
console.log(a);

预编译：（解决函数执行顺序）
js执行1、语法分析 2、预编译 3、解释执行
预编译的前奏：

test();
function test(){console.log('gg')};//函数声明整理提升最前；
console.log(a);
var a = 123;//变量 （声明提升 var a提升）；

imply global 暗示全局变量：未经声明直接赋值的变量是全局变量；
全局对象 window；a=111；window.a;
一切声明的全局变量都是window的属性；
window是全局的域；
function fn(a){    //预编译发生在函数执行的前一个
    console.log(a);
    var a=123;
    console.log(a);
    function a(){};
    console.log(a);
    var b=function(){};
    function d(){};
}
fn(1);
预编译四部曲：
函数内（局部）预编译：
1、创建AO对象（Activation Object活跃对象（执行期上下文））；
2、找形参和变量声明，将变量和形参名作为AO的属性名，值为undefined
AO{a:undefined,b:undefined}
3、将实参值和形参统一（把实参值传到形参里）
4、在函数体里面找函数声明，值赋予函数体

上面的例子形参是a，变量声明也是a；
四部曲：
1、创建OA{};
2、OA{a:undefined,b:undefined}
3、OA{a=1,b=undefined}
4、function a(){},function d(){}都是函数声明，var b = function(){}是函数表达式；
所以OA{a:function a(){},b:undefined,function d(){}}
按顺序执行下来打印结果：function，123,123，function；

全局预编译三部曲：
1、全局生成一个Go{}对象（Global Object 他就是window对象）；
2、找形参和变量声明，将变量和形参名作为GO属性名，值为undefined
3、在函数体里面找函数声明，值赋予函数体
任何全局变量都是window上的属性。

console.log(test)//第一步 输出函数；test:function(){...函数体},
function test(test){  //提升了先不看
    console.log(test)  //test(){}
    var test=123;
    console.log(test); //123
    function test(){}
}
test(1);//执行函数
var test =123;
执行全局先生成GO｛｝；在执行test（）的前一刻生成OA｛｝
几层嵌套关系，AO有就用AO自己的（近的优先），没有在往上找GO；

GO{   //全局
   //test:undefined
    test:function(){...函数体},   
  
}
执行函数前生成：
AO{
   // test:function(){}
test:123,
}

var glb=123;
function fn(){console.log(glb)}
fn();

GO{
    glb:undefinde,
    fn:function(){....}
}
按顺序执行
GO{
    glb:123,
    fn:function(){....}//提升了先不看
}
按顺序执行，fn（）前先生成
AO{
    //什么都没有
}
执行函数fn
console.log(glb);//先找AO，没有glb的值，在往上找GO，所以glb=123；

typeof(null);  返回object；占位