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

函数（高内聚、低耦合）

（1）函数声明

[code]<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）函数组成形式：名称、参数、返回值

注意：

[code]<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）预编译粗略理解：函数声明整体提升，变量声明声明提升

[code]<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就是全局的域）

[code]<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.在函数体里面找到函数声明，值赋予函数体

[code]<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.找到函数声明，值赋予函数体

[code]<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>