JS precompiled

JS There are three steps to complete the explanation and execution ：1. Syntax analysis ;2. precompile （ Global precompiling 、 Function precompile ）;3. Execute statement .

make a concrete analysis ：

1、 Syntax analysis

Analyze whether the code is correct Lexical analysis

2、 Implicit operation ==> precompile : After the function call Before running the code

2.1 Each call of the function will generate an object Activation Object, abbreviation AO object : Execution time context object

2.2. to AO Object to add members : Names of local variables and formal parameter variables inside the function As AO The property name of the object When the formal parameter is the same as the local variable No effect

2.3. Assign the passed argument to AO Object properties

2.4. Local function declaration , assignment Let the name of the local function be AO Object has the same member name , Assign the function body to this attribute

3. Run code : The pre compiled ones are not running

Case study ：

<script>
    	function fm(a) {
				console.log(a) //100
				var a=10 // to a The assignment is 10
				function  fn () {}
				console.log(a)
			}
			var b=100
			fm(b)
        /*
         analysis ：
        1、 Check the code for errors 
         Call function fm(b)
        2、 precompile 
         So let's create one AO object {}
         Then the names of local variables and formal parameter variables inside the function   As AO The property name of the object  AO:{a:undefined}
         Assign the passed argument to AO Object properties AO:{a:100}
         Let the name of the local function be AO Object has the same member name , Assign the function body to this attribute 
         AO：{a:100,fn:function fn () {}}
        3、 Run code 	  The pre compiled ones are not running 
             here fm In function code ：
            function fm(a) {
                AO：{a:100,fn:function fn () {}}
				console.log(a) //100
			    a=10 // to a The assignment is 10

			}
        */
</script>

When the global scope runs code   There is also precompiled ==> Global precompiling

Unlike function precompiling , What is generated is the object Global Object  (GO).

step ：

1. Generate an object Global Object  (GO)

2. Put all global variables Set to GO The property name

3. Put all function names As GO Member name of , Assign the function body to this member

4. Execute code

Case description ：

<script>
    	    console.log(a) //undefined
			var a = 20
			function fn() {
				console.log(66)
			}
        
            /*
            1、 Check the code for errors 
            2、 Global precompiling ：
            2.1、 Generate an object Global Object  (GO)
			GO:{}
            2.2、 Put all global variables   Set to GO The property name 
			GO:{a:undefend}
            2.3、 Put all function names   As GO Member name of , Assign the function body to this member 
			GO:{a:undefend,fn:function fn(){console.log(66)}}
            3. Execute code 
			GO:{a:undefend==>20,fn:function fn(){console.log(66)}}
            console.log(a) //undefined
            a = 20
            */
</script>

There is another step in global precompiling ==> Run in different environments js The code is different

            GO All members of the object are shallow copied to the environment object window

            node.js There is no such step in the environment

            Expand knowledge : About visiting members  console.log(a) What I visited was GO Members of the object ( If there is no scope in the chain, an error will be reported )

             console.log(window.a) Don't complain Prototype chain did not return undefined