DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> JavaScript入門知識 >> AJAX入門 >> AJAX詳解
JavaScript 函式詳解:從函式物件到 this 指標
編輯:AJAX詳解     

函式是模組化程式設計的基礎,要撰寫複雜的 Ajax 應用,必須對函式有更深入的了解。JavaScript 中的函式與其他語言很不同:每個函式都是作為一個物件被維護和執行的。透過函式物件的性質,可以很方便地把函式指派給變數,或作為參數傳遞。

先看幾種宣告函式的合法語法:

function func1(…){…}
var func2 = function(…){…};
var func3 = function func4(…){…};
var func5 = new Function();

認識函式物件(Function Object)

可以用 function 關鍵字定義函式並指定名稱,透過名稱呼叫。在 JavaScript 執行時,函式都是被維護為一個物件,這就是函式物件。

函式物件與使用者自訂的物件有本質區別,這一類物件被稱為內部物件,例如日期物件(Date)、陣列物件(Array)、字串物件(String)都屬於內部物件。這些內建物件的建構子由 JavaScript 本身定義:執行 new Array() 會回傳一個物件,內部有一套機制來初始化它,而不是由使用者指定建構方式。

函式物件對應的型別是 Function,正如陣列對應 Array、日期對應 Date。因此可以透過 new Function() 建立函式物件,也可以用 function 關鍵字。拿陣列的建立來對照就很清楚:

var myArray = [];
// 等價於
var myArray = new Array();

同樣地,下面兩段程式碼都是建立一個函式 myFunction:

function myFunction(a,b){
      return a+b;
}
// 等價於
var myFunction = new Function("a","b","return a+b");

由此不難看出函式物件的本質:function 宣告只是語法糖,直譯器內部遇到這種語法時,會自動建構一個 Function 物件,把函式當作內部物件來儲存和執行。函式變數名與普通變數名有同樣的命名規範,差別只在函式變數名後面可以接括號與參數列來呼叫。

用 new Function() 的形式建立函式並不常見,因為函式體通常有多條語句,把它們塞進一個字串參數會讓程式碼可讀性很差。其語法為:

var funcName = new Function(p1, p2, ..., pn, body);

參數都是字串,p1 到 pn 是參數名稱列表,body 是函式體。可以不指定任何參數建立空函式。要注意 p1 到 pn 也可以是逗號分隔的參數列表,因此以下三種寫法等價:

new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")

JavaScript 之所以引入 Function 型別並提供 new Function() 語法,是因為要為函式物件添加屬性和方法時,必須借助 Function 這個型別。

注意:函式宣告後面直接加括號,代表建立完成後立即呼叫:

var i = function (a,b){
      return a+b;
}(1,2);
alert(i);

這段程式會顯示 i 等於 3。i 存的是回傳值而不是函式,因為括號的優先級高於等號。這種寫法不常見,但如果你想在很長的程式碼中做模組化設計或避免命名衝突,它是個不錯的解法。

另外,以下兩種建立函式的方法雖然等價:

function funcName(){
      // 函式體
}
// 等價於
var funcName = function(){
      // 函式體
}

但前者建立的是有名函式,後者建立的是無名函式,只是讓一個變數指向它。使用上僅有一點差別:有名函式可以在呼叫之後才定義,而無名函式必須在呼叫之前就已定義。

也就是說,下面的寫法會發生 func 未定義的錯誤:

func1();
var func1 = function(){ alert("ok"); };

而這樣則能正確執行:

function func1(){ alert("ok"); }
func1();

可見儘管 JavaScript 是直譯式語言,它在函式呼叫時會檢查整個程式碼中是否存在對應的函式定義,但只有以 function funcName() 形式定義的才有效,匿名函式不行。

函式物件與其他內部物件的關係

除了函式物件,還有很多內部物件:Object、Array、Date、RegExp、Math、Error。這些名稱實際上代表一個型別,可以透過 new 運算子回傳物件。但函式物件與其他物件不同:用 typeof 得到函式物件的型別時,它會回傳字串 "function",而 typeof 一個陣列或其他物件時回傳的是 "object"。

alert(typeof(Function)));
alert(typeof(new Function()));
alert(typeof(Array));
alert(typeof(Object));
alert(typeof(new Array()));
alert(typeof(new Date()));
alert(typeof(new Object()));

執行後可以發現:前四條顯示 "function",後三條顯示 "object"。可見 new 一個 function 實際上回傳的是函式,這與其他型別有很大不同——Array、Object 等透過 new 回傳的都是普通物件。所有 typeof 回傳 "function" 的物件都是函式物件,也稱為建構子(constructor)。因此,所有建構子都是物件,但不是所有物件都是建構子。

既然函式本身也是物件,可以推測 Function 型別的作用:為函式物件本身定義方法和屬性。借助 prototype 可以很方便地擴充 Function:

Function.prototype.method1 = function(){
      alert("function");
}
function func1(a,b,c){
      return a+b+c;
}
func1.method1();
func1.method1.method1();

最後一句話呼叫了 method1 這個函式物件的 method1 方法。看起來有點繞,但仔細看語法就很清楚:這是遞迴的定義,因為 method1 本身也是函式,同樣具備函式物件的屬性和方法,所有對 Function 型別的擴充都具有這種遞迴性質。

Function 是所有函式物件的基礎,而 Object 則是所有物件(包括函式物件)的基礎。在 JavaScript 中,任何一個物件都是 Object 的執行個體,因此可以修改 Object 型別,讓所有物件都具有一些通用的屬性和方法:

Object.prototype.getType = function(){
      return typeof(this);
}
var array1 = new Array();
function func1(a,b){
      return a+b;
}
alert(array1.getType());
alert(func1.getType());

這段程式為所有物件加上 getType 方法,兩條 alert 分別顯示 "object" 與 "function"。

將函式作為參數傳遞

每個函式都被表示為一個特殊的物件,可以將其指派給變數,再透過該變數呼叫。作為一個變數,它可以以參數形式傳給另一個函式:

function func1(theFunc){
      theFunc();
}
function func2(){
      alert("ok");
}
func1(func2);

最後一句把 func2 作為物件傳給 func1 的形參 theFunc,再由 func1 內部呼叫。事實上,「把函式作為參數傳遞」或「把函式指派給變數」是所有事件機制的基礎。

例如若需要在頁面載入時做初始化,可以先定義 init 函式,再用 window.onload = init; 把它綁到載入完成事件上。這裡的 init 就是一個函式物件,它被加入了 window 的 onload 事件列表。

隱含參數 arguments

函式呼叫時,除了指定的參數外,還會建立一個隱含物件 arguments。它是一個類似陣列但不是陣列的物件:可以用 arguments[index] 取值,也有 length 屬性,但並非陣列。它儲存的是實際傳給函式的參數,而不侷限於函式宣告時定義的參數列表:

function func(a,b){
      alert(a);
      alert(b);
      for(var i=0; i<arguments.length; i++)
          alert(arguments[i]);
    }
func(1,2,3);

執行時會依序顯示 1、2、1、2、3。因此即使宣告函式時不指定參數列表,仍然可以透過 arguments 取得所有傳入的參數,這帶來很大的彈性。

arguments 的另一個屬性是 callee,它代表對函式物件本身的引用,有利於實作無名函式的遞迴或保證函式的封裝性。例如用遞迴計算 1 到 n 的自然數之和:

var sum = function(n){
      if(1==n) return 1;
      else return n + sum(n-1);
}
alert(sum(100));

函式內部包含了對 sum 自身的呼叫。但對 JavaScript 來說,函式名只是一個變數名,在函式內部呼叫 sum 相當於呼叫一個全域變數,不能很好地體現「呼叫自身」,所以改用 arguments.callee 會是較好的做法:

var sum = function(n){
      if(1==n) return 1;
      else return n + arguments.callee(n-1);
}
alert(sum(100));

callee 並不是 arguments 不同於陣列物件的唯一特徵,下面的程式碼說明 arguments 不是由 Array 型別建立:

Array.prototype.p1 = 1;
alert(new Array().p1);
function func(){
      alert(arguments.p1);
}
func();

執行後第一個 alert 顯示 1,表示陣列物件擁有屬性 p1;而 func 呼叫顯示 "undefined",可見 p1 不是 arguments 的屬性,arguments 並不是一個陣列物件。

apply、call 方法與 length 屬性

JavaScript 為函式物件定義了兩個方法:apply 與 call,作用都是把函式綁定到另一個物件上執行,僅在參數定義方式上有差別:

Function.prototype.apply(thisArg, argArray);
Function.prototype.call(thisArg[, arg1[, arg2…]]);

從原型可見,第一個參數都取名為 thisArg,也就是所有函式內部的 this 指標都會被指派為 thisArg,這就實現了「把函式作為另一個物件的方法執行」的目的。以下程式碼說明兩者的運作方式:

// 定義 func1,具有屬性 p 和方法 A
function func1(){
      this.p = "func1-";
      this.A = function(arg){
          alert(this.p + arg);
      }
}
// 定義 func2,具有屬性 p 和方法 B
function func2(){
      this.p = "func2-";
      this.B = function(arg){
          alert(this.p + arg);
      }
}
var obj1 = new func1();
var obj2 = new func2();
obj1.A("byA");    // 顯示 func1-byA
obj2.B("byB");    // 顯示 func2-byB
obj1.A.apply(obj2, ["byA"]); // 顯示 func2-byA
obj2.B.apply(obj1, ["byB"]); // 顯示 func1-byB
obj1.A.call(obj2, "byA");  // 顯示 func2-byA
obj2.B.call(obj1, "byB");  // 顯示 func1-byB

可以看出,obj1 的方法 A 綁定到 obj2 執行後,整個函式的執行環境就轉移到 obj2,即 this 指向 obj2。最後四行說明了 apply 與 call 在參數形式上的差異:apply 接受陣列,call 則是逐個列出參數。

與 arguments 的 length 屬性不同,函式物件還有一個 length 屬性,它表示函式定義時所指定參數的個數,而非呼叫時實際傳遞的數量。例如:

function sum(a,b){
      return a+b;
}
alert(sum.length);

會顯示 2。

深入理解 this 指標

this 指標是物件導向程式設計中的重要概念,代表目前執行的物件。在實作物件的方法時,可以用 this 取得該物件自身的引用。

與其他物件導向語言不同,JavaScript 的 this 是一個動態變數:方法內的 this 並不總是指向定義該方法的那個物件,上一節 apply 與 call 的例子已經說明了這點。

再看一個例子:

var obj1 = new Object();
obj1.p = 1;
obj1.getP = function(){
      alert(this.p);
}
var obj2 = new Object();
obj2.p = 2;
obj2.getP = obj1.getP;
obj1.getP();
obj2.getP();

執行結果分別顯示 1 與 2。可見 getP 只定義了一次,在不同場合執行呈現了不同結果,這是 this 指標變化所決定的:在 obj1 的 getP 中 this 指向 obj1,在 obj2 中則指向 obj2,並透過 this 引用到兩個物件都具有的屬性 p。

由此可見,JavaScript 的 this 是一個動態變化的變數,它標明了目前執行該函式的物件。由 this 的性質,也能更好地理解 JavaScript 中物件的本質:一個物件就是由一個或多個屬性(方法)組成的集合,每個集合元素不是僅能屬於一個集合,而是可以動態地屬於多個集合。這樣,一個方法由誰呼叫,this 就指向誰。

實際上,前面介紹的 apply 與 call 都是透過強制改變 this 的值來實作的,使 this 指向參數所指定的物件,從而達到「把一個物件的方法作為另一個物件的方法執行」的效果。

每個物件集合的元素(即屬性或方法)也是一個獨立的單位,全域函式與作為物件方法定義的函式之間沒有任何區別,因為可以把全域函式與變數看作 window 物件的方法和屬性。也可以用 new 運算子操作一個物件的方法來回傳物件,這樣一個物件的方法就可以定義成類別的形式,其中的 this 則會指向新建的物件。這時物件名可以起到命名空間的作用,這是使用 JavaScript 做物件導向設計的一個技巧:

var namespace1 = new Object();
namespace1.class1 = function(){
      // 初始化物件的程式碼
}
var obj1 = new namespace1.class1();

這裡就可以把 namespace1 看成一個命名空間。

由於物件屬性(方法)具有動態變化的特性,一個物件的兩個屬性(方法)之間互相引用時,必須透過 this 指標,而在其他語言中 this 關鍵字是可以省略的。例如:

obj1.getP = function(){
      alert(this.p);  // this 指向 obj1
}

這裡的 this 不可省略,不能寫成 alert(p),否則 getP 會去引用上下文環境中的 p 變數,而不是 obj1 的屬性。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved