JavaScript（四）主要内容：函数和预编译

函数（高内聚、低耦合）

（1）函数声明

<script type="text/javascript">

	//函数声明
	//1.
	function test(){

	}

	//2.命名函数表达式（忽略函数名）
	var test = function abc(){

	}
	console.log(test);	//function abc(){}
	console.log(abc);	//报错 abc is not undefined

	//3.匿名函数表达式
	var test = function(){

	}

	//1方式： test.name:test  2方式： test.name:abc   3方式： test.name:test


</script>

（2）函数组成形式：名称、参数、返回值

注意：

<script type="text/javascript">
	
	//1.
	function test(a,b,c,d){		//a,b相当于在函数里面var a;var b;  	a,b为形式参数

		//（1）.arguments		实参列表
		console.log(arguments);		//Arguments(3) [1, 2, 3]

		//（2）.length    形参个数
		console.log(test.length);	//4

	}
	test(1,2,3);	//1,2,3为实际参数
	//注意：形参和实参个数不同时，不报错
			//a = arguments[0]; b = arguments[1];  ...... (一个变化，对应的也变化)



	//2.当实参列表确定了，就不会改变了
	function demo(a,b){
		b = 2;
		console.log(arguments[1]);	//undefined
	}
	demo(1);


	//3.函数最后自动加return

</script>

js运行三部曲：语法分析、预编译、解释执行

      js特点：单线程、解释性语言

（1）预编译粗略理解：函数声明整体提升，变量声明声明提升

<script type="text/javascript">

	//1.函数声明整体提升
	test();		
	function test(){
		console.log("123");		//123
	}

	//2.变量声明   声明提升
	console.log(a);		//undefined
	var a = "123";


	//第一段代码相当于
	function test(){	//整体提升
		console.log("123");
	}
	test();

	//第二段代码相当于
	var a;	//声明提升
	console.log(a);
	a = "123";

</script>

（2）预编译深层理解

理解前：

      暗示全局变量（imply global）：任何变量，如果变量未经声明就赋值，此变量为全局对象（window）所有。

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

    （window就是全局的域）

<script type="text/javascript">

	function test(){
		var a = b = 123;	//连续赋值，过程：b = 123;var a = b; 此时的b是未经声明就赋值了,为全局对象（window）所有
	}
	test();
	console.log(a);		//报错
	console.log(window.a);		//undefined
	console.log(b);		//123

</script>

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

A.预编译过程（函数中的预编译）：

        a.创建AO对象（Activation Object：作用域 / 执行期上下文）

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

        c.将实参值和形参统一

        d.在函数体里面找到函数声明，值赋予函数体

<script type="text/javascript">

	function test(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(){}

	}
	test(1);

	// 预编译过程：
	// a.创建AO对象             AO{}
	// b.找形参和变量声明，将形参名和变量作为AO属性名，值为undefined    AO{a:undefined,b:undefined}
	// c.将实参值和形参统一           AO{a:1, b:undefined}
	// d.在函数体里面找到函数声明，值赋予函数体      AO{a:function a(){},b:undefined,d:function d(){}}

</script>

B.预编译过程（全局中的预编译：没有第三步）：

        a.创建GO对象（Global Object：作用域 / 执行期上下文        GO就是window)

        b.找变量声明，将变量作为GO属性名，值为undefined

        c.找到函数声明，值赋予函数体

<script type="text/javascript">

        // a.GO{}
	// b.GO{ test:undefined }
	// c.GO{ test:function test(){ ... } }

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

	function test(test){

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

		var test = 234;

		console.log(test);		//234

		function test(){

		}

		console.log(test);		//234

	}

	test(1);

	// AO{}
	// AO{ test:undefined }
	// AO{ test:1 }
	// AO{ test:function test(){} }

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

	var test = 123;

	console.log(test);		//123

</script>