JavaScript 函数

函数的定义
有三种函数的定义的方式：函数声明语句、函数定义表达式、Function 构造函数
函数声明语句
function 函数名([参数列表]) { }
调用：函数名([参数列表])；
函数定义表达式
var 变量名/函数名=function([参数列表]) { }
调用：变量名/函数名([参数列表])；
Function 构造函数
var 变量名 = new Function(“参数1”，“参数2”，“最后一个参数为是函数体”)
调用：变量名/函数名([参数列表])；
注意：
1、js中的函数没有重载，同名函数，会被后面的函数覆盖
2、js中允许有不定数目的参数

							<script type="text/javascript">
										// 函数声明语句
										function f1(a) {
											console.log(a);
										}
										f1(1);
										// 函数定义表达式
										var f2 = function(){
											console.log("函数定义表达式...");
										}
										f2();
										// Function 构造函数
										var f3 = new Function('x','console.log(x)');
										f3("Hello");
										function f4() {
											return true;
										}
										var flag = f4();
										console.log(flag);
										
										function f1() {
											console.log("覆盖...");
										}
										f1();
									</script>

函数的参数
函数的参数
实参可以省略，那么对应形参为undefined
若函数形参同名(一般不会这么干)：在使用时一最后一个值为准
可以给参数默认值：当参数为特殊值时，可以赋予默认值。
参数为值传递，传递副本；引用传递是为传地址，操作的是同一个对象。
函数调用
常用的调用方式：函数名([实参]) ；
存在返回值可以变量接受，若接受无返回值函数则为undefined
1、函数调用模式
2、方法调用模式
3、间接调用模式
call()和apply方法可以用来间接地调用函数
任何函数可以作为任何对象的方法来调用，哪怕这个函数不是那
个对象的方法。
两个方法都可以指定调用的实参。
call()方法使用它自有的实参列表作为函数的实参，apply()方法则要求
以数组的形式传入参数。
匿名函数立即调用
（1） 匿名函数：function([参数]) { }
（2） 调用：(fuction([形参]) { }）([实参])；
在函数中只被使用一次的情况下可以使用这种方式，简便省事
return 语句
作用：在没有返回值的方法中结束方法。
有返回值的方法中，一个是用来结束方法，一个是将值带给调用者。

										<script type="text/javascript">
													// 实参可以省略，那么对应形参为 undefined
													function f1(str) {
														console.log(str);
													}
													f1();
													
													// 若函数形参同名（一般不会这么干）：在使用时以最后一个值为准。
													function f2(a,a) {
														console.log(a);
													}
													f2(10,20);
													
													// 可以给参数默认值：当参数为特殊值时，可以赋予默认值。
													function f3(x) {
														x = x || "xxxx";
														console.log(x);
													}
													f3("哈哈哈");
													function f4(y) {
														(y == null || y == undefined) ? y = "参数为空" : y = y;
														console.log(y);
													}
													//f4();
													f4("啦啦啦啦");
													
													// 参数为值传递，传递副本 ；引用传递时传递地址，操作的是同一个对象。
													// 值传递
													var num = 100;
													function f5 (n) {
														n = 1;
													}
													f5(num);
													console.log(num);
													
													// 引用传递
													var obj = {"name":"张三"};
													var arr = [1,2,3];
													function f6(ob,ar) {
														ob.name= "李四";
														ob = {"name":"zhansgan"};
														ar[0] = 10;
														ar = [4,5,6];
													}
													f6(obj,arr);
													console.log(obj);
													console.log(arr);
													
													console.log("===========函数的调用===========");
													function ff () {
														console.log("函数调用模式...");
													}
													ff();
													
													// 方法调用模式
													var obj = {
														name:"zhangsan",
														age:12,
														sayHello:function(str){
															console.log(this);
															console.log("参数为：" + str);
															console.log("方法调用模式...");
														}
													};
													// 获取对象中的值（通过对象.键）
													console.log(obj.name);
													console.log(obj.sayHello);
													obj.sayHello("张三");
													
													// 间接调用模式
													console.log("间接....");
													var obj = {
														msg:"Hello ~"
													};
													function sum(a,b){
														//console.log(this.msg);
														console.log(this);
														return a + b;
													}
													//var s = sum(1,2);
													//console.log(s);
													var s2 = sum.call(obj,1,2);
													console.log(s2);
													var s3 = sum.apply(obj,[1,2]);
													console.log(s3);
													
													console.log("匿名函数...");
													// 匿名函数立即调用
													(function(x,y) {
														console.log("这是一个匿名函数...");
													})(1,2);
													
													console.log("============");
													
													function test(x) {
														if (x < 100) {
															return "小于100";
														}
														console.log(x)
														return "不小于100";
													}
													var a =test(10);
													console.log(a);
													
													
												</script>

函数作用域
1、全局变量与局部变量同名问题(就近原则)
2、如果没使用var修饰符声明的变量是全局变量
3、函数中的变量名的提升

							<script type="text/javascript">
								// 1、全局变量与局部变量同名问题（就近原则）
								var box = 1;
								function f1(box) {
									// 局部变量
									var box = 10;
									var b = 20;
									console.log(box);
									console.log(this.box);
									
									a = 2; // 全局变量
								}
								f1(box);
								console.log(box);
								
								// console.log(b); // 无法获取函数中的局部变量
								
								// 2、如果没使用var修饰符声明的变量是全局变量
								console.log(a);
								
								// 3、函数中变量名的提升
								function f2(x) {
									// 变量名提升
									//console.log(temp);
									if (x > 1) {
										var temp = x+1;
									}
									console.log(temp);
								}
								f2(10);
								f2(20);
								
								
							</script>