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>