浅析JavaScript中预编译的原理与流程

function test() {
    console.log('test');
}
test();
// 上面能执行 
// 
test1();

function test1() {
    console.log('test1');
}
// 也能执行，因为有预编译的存在 发生了函数声明提升
var a = 123;
console.log(a); // 123 
// 
console.log(b); //undefiend
var b = 123;

// 要明白 声明 和 赋值 
var a = 123 //这句话其实两步 声明变量 和 变量赋值
// 可以拆解成下面这样
var a;
a = 123
// 未经声明的变量就赋值 归全局对象
b = 10
// b=10 => window.b=10

// 
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 b() {}
    function d() {}
}
fn(1);

console.log(test); // function test(test){...}
function test(test) {
    console.log(test); // fuction test () {}
    var test = 234;
    console.log(test);
    234

    function test() {}
}
test(1);
var test = 123;
// 下面是模拟的流程
// 经过 go 三部曲 变成下面这样
// 创建 GO ={
//   test : function test(test){...}
// }
// test(1) 执行
// 经过函数预编译四步
// 创建 AO ={
//  test:function test() {}
// }

// 根据 ES5 的规定都是非法的。 在现在es6的执行环境中 {}是块级作用域 
// 这就矛盾了es5明确规定 函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。

// 情况一
if (true) {
    function f() {}
}
// 情况二
try {
    function f() {}
} catch (e) {
    // ...
}

//  ES5 环境中运行
function f() {
    console.log('I am outside!');
}
(function() {
    if (false) { //不管这里是true还是false 结果一样的 发生预编译的时候不管执行条件
        // 重复声明一次函数f
        function f() {
            console.log('I am inside!');
        }
    }

    f(); //会得到“I am inside!”，
}());

// 浏览器的 ES6 环境
console.log(foo);
if (false) {
    function foo() {
        return 1;
    }
}
// 在 Chrome 里：
// 'foo' 变量名被提升，但是 typeof foo 为 undefined
//
// 在 Firefox 里：
// 'foo' 变量名被提升。但是 typeof foo 为 undefined
//
// 在 Edge 里：
// 'foo' 变量名未被提升。而且 typeof foo 为 undefined
//
// 在 Safari 里：
// 'foo' 变量名被提升。而且 typeof foo 为 function

// 浏览器的 ES6 环境
// 根据下面 规则只对 ES6 的浏览器实现有效 分析
function f() {
    console.log('I am outside!');
}
(function() {
    // 函数作用域 AO { f = undefiend} 这里是if里面的函数提升上来的
    if (false) { //false true都不影响提升
        //es6 {} 这是一个块级作用域了 因为块级作用域内声明的函数类似于let
        // 重复声明一次函数f
        // 块作用域  预编译 AO{ f:function f() {...}}
        function f() {
            console.log('I am inside!');
        }
    }
    // 这里为什么会报错 如果改变了块级作用域内声明的函数的处理规则，显然会对老代码产生很大影响。为了减轻因此产生的不兼容问题，ES6 在附录 B里面规定，浏览器的实现可以不遵守上面的规定，有自己的行为方式。
    f(); //报错 Uncaught TypeError: f is not a function  当执行到这里的时候 由于if是flase 没有执行到f函数声明语句 不会吧 块里面的f 赋值到 函数作用域里面的 f  所以执行函数作用域f报错
}());

// 例1
// GO={a:undefiend}
var a = 0;
// GO={a:0}
console.log("1 a:", a); //0
// GO:{a=1} 是if里面执行到 定义function a() {} 的时候更改的
if (true) {
    // AO={a:function a() {}}
    a = 1;
    //  AO={a:1}
    function a() {} //当执行到这一步的时候 将当前块作用域的 a = 1  赋值给 全局作用域的 a 
    //  AO={a:1}
    //  GO:{a=1}
    a = 5;
    //  AO={a:5}
    console.log("2 a:", a); //5
}
console.log("3 a:", a); //1

// 例2
var a = 0;
console.log("1 a:", a); //0
if (true) {
    a = 1;
    a = 5;
    console.log("2 a:", a); //5
    function a() {}
}
console.log("3 a:", a); //5

// 例3
var a = 0;
console.log("1 a:", a); //0
if (true) {
    function a() {}
    a = 1;
    a = 5;
    console.log("2 a:", a); //5
}
console.log("3 a:", a); //function a {}

// 例4
// GO={a:undefiend}
console.log("1 a:", a); //undefiend
// GO={a:function a() {} } 是if里面执行到 定义function a() {} 的时候更改的
if (true) {
    // AO={a: function a() {} }
    function a() {} //执行到这里 改变GO={a=AO.a=function a() {}}
    a = 1;
    // AO={a: 1 }
    a = 5;
    // AO={a: 5 }
    console.log("2 a:", a); //5
}
console.log("3 a:", a); //function a {}

// 例5 - 里面是var声明不是函数 
// GO={a:undefiend}
console.log("1 a:", a); //undefiend
// GO:{a=1} 是if里面执行到 var a; 的时候更改的
if (true) {
    // AO={a:undefind}
    a = 1;
    //  AO={a:1}
    var a; //当执行到这一步的时候 将当前块作用域的 a = 1  赋值给 全局作用域的 a 
    //  AO={a:1}
    a = 5;
    //  AO={a:5}
    console.log("2 a:", a); //5
}
console.log("3 a:", a); //1

// 例6 - 里面是var声明不是函数 
// GO={a:undefiend}
console.log("1 a:", a); //undefiend
if (false) { //false 走不进来 只是预编译的时候将 var a 提升到块顶部和全局顶部
    // AO={a:undefind}
    a = 1;
    var a;
    a = 5;
    console.log("2 a:", a); //5
}
console.log("3 a:", a); //undefiend