javaScript 面向对象-函数

javascript面向对象：内容非常多 这里制作部分介绍

函数

* Arguments 对象：实现函数的重载的效果
        * 变量的作用域：
            * javascript中，只存在全局域和函数域
            * 在定义局部变量时，不使用"var"修饰符时：被定义为全局变量
            * 在全局变量与局部变量同名时：参看代码
        * 特殊函数：
            * 匿名函数
            * 回调函数
            * 自调函数
            * 私有函数
            * 返回函数的函数

Arguements

 <script type="text/javascript">
  					/*
  					 * * java中的函数，重载
  					 * 		* 节省了命名空间
  					 * 		* 执行效率高
  					 * * javascript中的函数有没有重载?没有
  					 * 		* 当定义多个同名的函数时，最后一个函数会覆盖前面所有的函数
  					 * 		* 当多个函数同名时，最后一个定义的函数起作用
  					 */
//					function add(a,b){
//						return a+b;
//					}
//					
//					function add(a,b,c){
//						return a+b+c;
//					}
//					
//					alert(add(1,2));		//output	NaN NotAnNumber
//					alert(add(1,2,3));		//output	6
					
					//想办法：在javascript中，实现函数重载的效果
					/*
					 * arguments对象：
					 * 	* arguments对象是数组对象
					 * 	* arguments对象的length属性，获取到的是参数的个数
					 */
//					function fn(){
//						alert(arguments.length);
//					}
//					
//					fn();					//output	0
//					fn("a");				//output	1
//					fn("a","b");			//output	2
//					fn("a","b","c");		//output	3
					
					function add(){
						if(arguments.length==2){
							return arguments[0] + arguments[1];
						}else if(arguments.length==3){
							return arguments[0] + arguments[1] + arguments[2];
						}
					}
					
					alert(add(1,2));			//output	3
					alert(add(1,2,3));			//output	6
					
  </script>

函数的定义域

<script type="text/javascript">
  					/*
  					 * * 变量a是全局变量，环境中任意位置都可以访问
  					 * * 变量b是局部变量，只能在函数fn()中访问
  					 * * 在javascript中，只存在全局变量和局部变量
  					 * * 在javascript中，只存在全局域和函数域
  					 */
//					var a = "a";
//					
//					function fn(){
//						var b = "b";
//						
//						alert(a);		//output	a
//						
//						alert(b);		//output	b
//					}
//					
//					fn();
//					alert(a);			//output	a
//					alert(b);			//output	undefind
					
					/*
					 * 在javascript中，不使用修饰符"var"时：
					 * 	* 环境会自动将变量的定义为全局变量
					 * 	* 并不报错
					 */
//					var a = "a";
//					
//					function fn(){
//						b = "b";
//						
//						alert(a);		//output	a
//						
//						alert(b);		//output	b
//					}
//					
//					fn();
//					alert(a);			//output	a
//					alert(b);			//output	b
					
					/*
					 * 全局变量与局部变量同名时：
					 * * 定义了全局变量a，并初始化为"a"
					 * * 定义了函数fn()，有没有执行函数中的代码？没有
					 * 		* 局部变量a，有没有被定义？被定义，但是没有初始化
					 * * 调用函数fn()时
					 * 		* 第一个打印结果，打印的是局部变量a。但是因为局部变量a没有初始化，所以是undefind
					 * 		* 第二个打印结果，打印的是局部变量a。局部变量a初始化了，所以是b
					 */
					var a = "a";
					
					function fn(){
						
						alert(a);		//output	undefind
						
						var a = "b";
						
						alert(a);		//output	b
					}
					
					fn();
					alert(a);			//output	a
  </script>

特殊的函数

<script type="text/javascript">
//  					function add(a,b){
//						return a+b;
//					}
					
					/*
					 * 1 匿名函数：没有名的函数
					 * 	作用：
					 * 		* 可以将匿名函数作为参数传递给其他函数。这样，接收方函数就能利用所传递的函数来完成某些事情。
					 * 		* 可以定义某个匿名函数来执行某些一次性任务
					 */
//					function(){}
					
					/*
					 * one和two函数，叫做回调函数
					 * 回调函数：将函数作为参数传递给其他函数，作为参数的函数就是回调函数
					 */
					function fn(a,b){
						return a() + b();
					}
					
//					var one = function(){return 1;}
//					var two = function(){return 2;}
					
//					alert(fn(one,two));			//output	3
					
					//以上代码可以改写：匿名回调函数
//					alert(fn(function(){return 1;},function(){return 2;}));		//output	3
					
					//定义即调用函数
//					function fn(){
//						alert("javascript");
//					}
//					fn();
//*********************************************************			
					/*
					 * 自调函数：执行一次性任务
					 * 	* 第一个小括号：封装函数体
					 * 	* 第二个小括号：调用封装的函数
					 */
//					(
//						function(){
//							alert("javascript");
//						}
//					)();
					
//					(
//						function(str){
//							alert(str+" javascript");
//						}
//					)("hello");
					
					/*
					 * 私有(内部)函数：内部类
					 * 	* 保证了私有性 ———— 只把必要性的内容暴露给外界，其他所有内容保留在私有空间中
					 * 	* 节省全局域命名空间
					 */
//					function fn(){
//						var a = "javascript";
//						
//						function n(){
//							return a;
//						}
//						
//						return n();
//					}
					
//					alert(fn());		//output	javascript
//					alert(n());			//output	undefind
					
					/*
					 * 返回函数的函数
					 * 	* 在定义一个函数的时候，可以执行两个逻辑代码
					 * 	* 第一个函数，没有真正的返回值
					 */
					function fn(){
						var a = "javascript";
						
						return function(){
							return a;
						}
					}
					
					//alert(fn());		//output	function(){return a;}
					
					//var fun = fn();
					//var fun = function(){return a;}
					
					//alert(fun());		//output	javascript
					
					alert(fn()());		//output	javascript
					
  </script>