提升、执行上下文和执行上下文栈

-提升
1.变量声明提升
通过var定义（声明）的变量，在之前就可以直接使用，但不会被赋值
值：undefined
2.函数声明提升
通过function声明的函数，在之前就可以直接调用 (函数表达式不能在定义前调用)
值：函数定义（对象）
3.问题：变量提升和函数提升怎么产生的？

/*
			变量提升简单理解
			*/
		   var a = 3
		   function fn(){
			   console.log(a)
			   var a = 4
		   }
		   fn() //undefined  //变量提升
		   console.log(b)  //undefined     //变量提升
		   
		   fn2() //lala  //函数提升
		   
		   // f3()  //报错，未定义
		   
		   console.log(fn3)  //undifined  (函数表达式创建的函数不会被提前创建)
		   
		   var b = 3
		   function fn2(){
			   console.log('lala')
		   }
		   var fn3 = function(){
			   console.log('lalalalalalala')
		   }

         /*测试题1
			先执行变量提升还是函数提升？
			  先执行变量提升
			*/
		   
			function a(){}
			var a;
			console.log(typeof a)  //function
			
			/*测试题2
			
			*/
		   if(!(b in window)){
			   var b = 1
		   }
		   console.log(b) //undefined
			
			
			/*测试3
			
			*/
		   var c = 1
		   function c(c){
			   console.log(c)
			   var c = 3
		   }
		   c(2)  //报错 c is not a function   函数声明提升,早就被执行好了
		   

测试3理解

 /* 它相当于*/
		   var c;
		   function c(c){
			   console.log(c)
			   var c = 3
		   }
		   c = 1;
		   console.log(c)  //1

执行上下文
1.代码分类（位置）
全局代码
函数（局部）代码
2.全局执行上下文
在执行全局代码前将window确定为全局执行上下文
对全局变量进行预处理 :
var定义的全局变量–>undefined ,添加为window的属性
function声明的全局函数–>赋值（fun）,添加为window的方法
this -->赋值，为window
开始执行全局代码
3.函数执行上下文
在调用函数，准备执行函数体之前，创建对应的函数执行上下文对象
对局部变量进行预处理 ：
形参变量–>赋值（实参）–>添加为执行上下文的属性
arguments -->赋值（实参）–>添加为执行上下文的属性
var定义的局部变量–>undefined，添加为执行上下文的属性
function声明的函数–>赋值（fun）,添加为执行上下文的方法
this -->赋值（使用函数的对象）

//全局执行上下文
		    console.log(window.a)  //undefined
			console.log(window.fn2)  //function(){console.log("lala")}
			console.log(this) //window
			//函数执行上下文
			function myFunction(a1){
				console.log(a1)  //2    
				console.log(m)  //undefined
				console.log(m1)  //f m1(){console.log("m1()")}
				console.log(this)  //window
				m1() //window
				console.log(arguments)  //伪数组[2，3]   
				var m=3
				function m1(){
					console.log(this)
				}
			}
			myFunction(2,3)
		    

• 执行上下文栈
  1.在全局代码执行前，JS引擎会创建一个栈来存储所有执行上下文对象
  2.在全局执行上下文（window）创建后，将其添加到栈中（压栈）
  3.在函数执行上下文创建后，将其添加到栈中（压栈）
  4.在当前函数执行完后，将栈顶的对象移除（出栈）
  5.当所有代码执行完后，栈中只剩下window

		/*
			面试题：
			输出结果是怎样的？ //栈的特点：后进先出
			  gb undefined
			  fb1
			  fb2
			  fb3
			  fe3
			  fe2
			  fe2
			  ge1
			整个过程产生了几个执行上下文？
			  5个
			*/
			console.log('gb '+ i)
			var i =1
			foo(1)
			function foo(i){
						   if(i == 4){
							   return
						   }
						   console.log('fb' +i)
						   foo( i+1 )
						   console.log('fe' +i)
			}
			console.log('ge' +i)