js--递归，预编译

递归：

两点作用：1.做到规律  2.找出口

递归有个特点，代码会非常少，并且简洁，但是递归也是运行最慢的

最典型的递归，是阶乘与菲波纳妾数列

//写一个函数，实现n的阶乘
        function mul(n) {

            if (n == 1 || n == 0) {
                return 1;
            }

            return n * mul(n-1);
        }

        //写一个函数，实现菲波纳妾数列
        function fb(n) {
            if (n == 1 || n == 2) {
                return 1;
            }

            return fb(n - 1) + fb(n - 2);
        }

 

 

作用域：

两个独立的函数是不能互相访问的

如果是嵌套的函数，外层的函数不能访问里层的函数，但是里层的函数能访问外层的函数

 

 

js语法执行分为三部：

1.通篇预览，检查有没有基础的语法错误，例如少写一个括号，有中文等等，也叫做（语法分析）

2.预编译

3.解释执行（解释一行，执行一行）

 

1.任何变量未经声明，直接赋值，则归window所有

a = 10;

 ---->  wondow.a = 10;

2.一切声明的全局变量，全是window的属性

换句话说，window就是全局的域

通俗的讲，var a = 123; 现在申明了一个变量a,并赋值了，那它是存在哪里的呢？就是存在window里，这里window就相当于一个仓库

var a = 123;

//window{

       a ： 123

}

var a = 123;  ----> window.a = 123;

 

//预编译发生在函数执行的前一刻

预编译的四个步骤：

局部变量的过程

1.创建AO对象

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

3.将实参值和形参统一

4.在函数体里面找函数声明，值赋予函数体（函数声明才能提升，表达式不能提升）

这才是函数声明：function a( ) { }

这是函数表达式：var b = function ( ) { }

 

全局的预编译过程，大同小异

1.生成一个GO对象 Global Object

GO === window   (相当于就是一个人的两个名字)

var a = 123;
        function a () {

        }

        //go{
            a : 123
        }

 

注意一点：如果AO里与GO里有同一个test,函数里面，则先用AO的，没有了再调用GO里的

 

function bar () {
            return foo;//相当于console.log()
            foo = 10;
            function foo () {

            }
            var foo = 11;
            
        }
        console.log(bar());

像上述这个题，return在最上面，由于它下面有函数，那就啥也不用看了，直接打印函数

 

 

console.log(bar());//undefined
        function bar() {
            foo = 10;
            function foo () {

            }
            var foo = 11;
            return foo;
        }

像上述这个题，return foo在最下面，只要上面被赋值过，那就用那个值