js之预编译——note

    
    <script>
        // 预编译 js执行三部曲-》语法解析（通篇扫描）、预编译、解释执行
         // 解释一行，执行一行

         // function test(){
         //    console.log('a');
         // }
         // test();//ok

         // test();
         // function test(){
         //    console.log('a')
         // }//也是Ok
         //按理解释一行，执行一行，那么不能被执行，但是由于预编译...，

         // var a = 123;
         // console.log(a);//ok
 
         // console.log(a);//undifined
         // var a = 10;不报错


         //两句话，函数声明整体提升（提升到逻辑最前面，就会优先执行），变量 声明提升

         // console.log(a);报错
         
         // console.log(a);
         // function a(){
         //    var a = 123;
         //    var a = function{

         //    }
         // }
         // var a = 123

         // 任何变量未经声明就赋值，此变量归全局变量所有（imply global）

         // var a = 123;->window.a = 123
         // a = 123;//不报错，就好像它被声明了。-->window.a = 10
         // window就是全局的域
         // window{
         //    a:123
         // }

         // var a = 123;
         // console.log(a)-->访问的就是window.a

         // a = 10;

         // var a = b = 123;
         // console.log(a);
         // console.log(b);

//          function test(){
//             var a = b = 123;
// //赋值顺序：从右往左,但是先把123赋值给b的时候，b是未经声明的b,然后再去声明a,然后再把b的值赋给a,那么此时b归全局所有,那么window.a是undifined,window.b有值
//          }
//          test();

          /*var a =123;
          123也是归全局所有*/

          // function test(){
          //   var b = 10;//局部
          // }
          // test();
          // console.log(window.b);unifined,全局里面没有

          // window就是全局
          // var a = 1;
          // var b = 2;
          // var c = 3;
          // window{
          //   a:1,
          //   b:2,
          //   c,3
          // }


          // function fn(a){
          //   console.log(a);//function a(){}

          //   var a = 123;

          //   console.log(a);//123

          //   function a(){}

          //   console.log(a);//123

          //   var b = function (){}

          //   console.log(b);//function (){}

          //   function d(){}
          // }
          // fn(1);

        //又有函数，又有变量，谁提升呢？有一个覆盖的问题，关键参数也是a,这道题形参名，变量名，函数名相同
        // 注意预编译发生在函数执行的前一刻，
        //   AO对象创立后，console.log(a);拿a从AO中去拿，第二个console.log(a);
        //     var a  = 123;不完全执行，因为预编译第二步（变量声明提升过程）,你之前那个a
        // 已经提升上去了，你再声明(即 var a;),因为预编译之前已经把你的变量提升过程看过了
        // 但是a = 123;这条语句还没有读，所以操作的是AO中的a,var a = 123;是a的一个
        // 显示的方式，但是a:function a(){}才是a的真正的存储值，所以a变成了123
        // 就是你真实传的是放到AO里面


       //例二：
       // function test(a,b){
       //  console.log(a);//undefined->1
       //  c = 0;
       //  var c;
       //  a = 3;
       //  b = 2;
       //  console.log(b);//undefined->function (){}->2
       //  function b(){}//访问过了
       //  function d(){}//访问过了
       //  console.log(b);//2
       //  }
       //  test(1);


        // 2步：AO{a(形参)/c/b/d}  //4步3 2 0 function d(){}


        // function test(){
        //     console.log(a);//fn
        //     console.log(b);//undefined
        //     var b = 234;
        //     console.log(b)//234
        //     a = 123;
        //     console.log(a);//123
        //     function a(){}
        //         var a;
        //         b = 234;
        //         var b = function (){} 
        //         console.log(a);//123
        //         console.log(b);//fn
        // }
        // test(1);

        // AO:{a->undefined->1->function a(){} b->undefined }
       // a变量，a函数。在预编译中，第一条还访问得是a，->fn返回，因为第四步当中，函数权限最高，他会覆盖前面的声明或者形参

       // GO对象：
       // GO{
       //      a:1
       // }
       // GO === window
       // var a = 1;
       // function a(){}
       // console.log(a);
       // console.log(window.a);//console.log(GO.a)

       // function test(){
       //     var a = b =123;
       //     console.log(window.b);
       // }

       // AO{
       //  a:undefined
       // }
       
       // GO{
       //  b:123
       // }

       // 先生成GO？还是先生成AO(执行的前一)？，先GO！！！
       // console.log(test);//fn(大的)
       // function test(test){
       //  console.log(test);//fn
       //  var test = 234;
       //  console.log(test);//234
       //  function test(){
       //  }
       // }
       // test(1);
       // var test = 123;

       // GO{
       //  // test(因为：var test = 123;提升上来)：
       //  从undifined->function test(){...}
       // }
       // 执行：
       //  输出函数体（大的），大的function test(){...}不看了，
       //  AO{
       //      // test:从undifined->function (){},就近关系找test方法（重要），就是先找AO的方法
       //  }


       // var global = 100;//声明最高级
       // function fn(){
       //  console.log(global);
       // }

       // fn();

       // GO{
       //  (变量)global:undefined->变成100
       //  (函数声明)：fn:function(){...}
       // }
       // 执行：global->变成100
       // AO{
       //  // 啥都没有，global自己AO上没有，找GO，打印100
       // }


       // console.log(a);
       // var a = 123;
       //var a = 123;
       // var a;
       // a = 123;
       // var a;过程中，变量声明提升，他就会提升到逻辑最前面
       // 就是如下：
       // var a;
       // console.log(a);
       // a = 123;
       // console.log(a);
       // GO：{
       //  a:undefined->123
       // }

       // 又或者：
       // console.log(b);
       // var b = function (){

       // }
       // console.log(b);

       // GO{
       //  b:undefined->function (){}
       // }

       // global = 100;
       // function fn(){
       //  console.log(global);//undefined
       //  global = 200;
       //  console.log(global);//200
       //  var global = 300;
       // }
       // fn();
       // var  global;//优先级最高

       // GO{
       //  global:undefined->,fn先不看->100(此时GO是有值的吧)
       // }
       // 然后执行fn前一刻看里面的fn,产生AO
       // AO{
       //  global:undefined->自己给自己（自己先找自己的AO），赋值200此时不会找外面GO的值 
       // }

       // 例题：
       function bar(){
        return foo;//等价与console.log(foo)
        foo = 10;
        function foo(){

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



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

        }
        var foo = 11;
        return foo;
       }

       //隐式类型转换
       var str = false + 1;
       document.write(str);
       var demo = false == 1;
       document.write(demo);
       if(typeof(a)&&-true + (undefined) + ""){
        document.write('基础扎实');
       }
       if(11 + "11" * 2 == 33){
        document.write('基础扎实');
       }

       !!" " + !!"" - !!false||document.write('你觉得能打印，你就是猪');

       //+两边只要没有str,那么对应的数据类发生隐式类型转换
       // false就会转换为0
       //==判断相等 =赋值  ，所以为false

    </script>