DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> JavaScript入門知識 >> AJAX入門 >> AJAX詳解
AJAX 入門必修課:把 JavaScript 的函式從頭理解一遍
編輯:AJAX詳解     

函式是模組化設計的基礎。想寫出結構清楚、好維護的 AJAX 應用,就必須先弄清 JavaScript 的函式究竟和別的語言差在哪裡。最關鍵的一點是:在 JavaScript 中,每個函式都是一個物件。

那些「看起來很奇怪」的宣告方式

先看四種合法寫法:

function func1(...) { ... }          // 具名函式宣告
var func2 = function(...) { ... };   // 函式表達式,指向匿名函式
var func3 = function func4(...) { ... }; // 表達式,但函式本身有名
var func5 = new Function();          // 透過建構子產生

這在其他語言裡幾乎不可能出現。原因就在於函式是物件,可以被賦值、被當成參數傳遞、也可以被動態組裝。

函式物件(Function Object)

JavaScript 的內部物件——Date、Array、String、Function 等——其建構方式由語言本身定義,而非由使用者指定。函式對應的型別就是 Function,因此下列兩段程式完全等價:

function myFunction(a, b) {
    return a + b;
}

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

這就和 var myArray = [] 等同於 var myArray = new Array() 是同一個道理。當解譯器遇到函式宣告語法時,內部會自動構造一個 Function 物件來保存它。

用 new Function() 的語法如下,所有參數都是字串,前 n 個是參數名、最後一個是函式主體:

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

實務上很少這樣寫,因為函式主體通常有很多行,塞成字串之後可讀性極差、也不利於除錯。它真正存在的理由是:要為函式物件掛屬性與方法,必須有 Function 這個型別作為依附點。

立即呼叫與 Hoisting 的差別

在函式宣告後面直接加上括號,就會在建立完成後立刻執行:

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

注意 i 拿到的是回傳值 3,而不是函式本身,因為括號的優先權高於等號。這在需要避免命名污染、或想把長篇程式碼做區塊化封裝時很好用。

另外,這兩種寫法雖然等價,行為上卻有一個關鍵差異:

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

前者建立的是具名函式,可以在呼叫之後才宣告;後者建立的是匿名函式,只是讓變數指向它,因此必須先定義才能呼叫:

func();
var func = function() { alert(1); }   // 錯誤:func 未定義

func();
function func() { alert(1); }         // 正確

func();
var someFunc = function func() { alert(1); };  // 也能正確執行

也就是說,JavaScript 雖然是直譯式語言,但在呼叫時會去檢查整個程式碼中是否存在對應的宣告——而這種「提前可用」的效果,只有用 function funcName() 形式定義的才享有。

typeof 函式會回傳什麼

alert(typeof(Function));        // function
alert(typeof(new Function()));  // function
alert(typeof(Array));           // function
alert(typeof(Object));          // function
alert(typeof(new Array()));     // object
alert(typeof(new Date()));      // object

可見函式本身就是一個建構子(constructor)。所有 typeof 回傳 "function" 的物件都屬於函式物件;反過來說,所有建構子都是物件,但不是所有物件都是建構子。

用 prototype 擴充函式

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

func1.method1();            // 顯示 function
func1.method1.method1();    // 也可以這樣呼叫

最後一行看起來饒舌,但邏輯很清楚:method1 本身也是函式,因此同樣擁有函式物件的屬性與方法——這是一種遞歸的性質。

再往上一層,Object 是所有物件(包含函式物件)的基礎,改寫 Object.prototype 就能讓全部物件共用同一套方法:

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

alert(array1.getType());   // object
alert(func1.getType());    // function

把函式當參數傳遞

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

func1(func2);

這是整個事件機制的地基。例如要在頁面載入後做初始化,寫 window.onload = init; 就是把 init 這個函式物件放進 onload 的呼叫清單裡——注意是 init 而非 init(),加上括號就變成立即執行、把回傳值放進去了。

隱含參數 arguments

每次呼叫函式時,除了宣告的參數之外,還會產生一個名為 arguments 的物件。它像陣列但不是陣列,有 length、可用 arguments[i] 取值,內容是「實際傳入的參數」:

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 屬性,指向函式本身,適合用在匿名函式的遞迴:

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

若不透過 callee 而直接呼叫 sum,實際上是去參照一個外部變數,語意上並沒有表達「呼叫自己」。另外,arguments 不是 Array 的實例——為 Array.prototype 掛上的屬性,在 arguments 上讀會得到 undefined。

apply 與 call

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

兩者作用相同:把函式綁定到另一個物件上執行。差別只在參數傳遞的形式——apply 收陣列,call 收散列參數。第一個參數 thisArg 會成為函式內部 this 的值。

function func1() {
    this.p = "func1-";
    this.A = function(arg) { alert(this.p + arg); };
}
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 上執行後,整個執行環境就跟著搬了過去。這也是 JavaScript 實現「借用方法」與控制 this 指向的主要手段。

最後別把兩個 length 搞混:arguments.length 是實際傳入的參數個數,而函式物件自身的 length 屬性是宣告時定義的參數個數。

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

this 是動態的

var obj1 = new Object();
var obj2 = new Object();
obj1.p = 1;
obj2.p = 2;

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

obj1.getP();          // 1
obj2.getP = obj1.getP;
obj2.getP();          // 2

getP 只定義了一次,掛到不同物件上執行就顯示不同結果。this 並非固定指向定義它的物件,而是指向「當下呼叫它的那個物件」。apply 與 call 本質上就是強制改寫 this 的值。

理解這一點,也就能理解 JavaScript 物件的本質:一個物件就是若干屬性與方法的集合,而同一個方法可以動態地屬於多個集合。由於這種動態性,物件的方法要引用自己的其他成員時,this 不能省略——寫成 alert(p) 會去找外層環境的 p,而不是 obj1 的屬性。

最後一個實務技巧:利用 new 操作函式物件來製造類別的效果,物件名稱同時扮演命名空間的角色:

var namespace1 = new Object();
namespace1.class1 = function() {
    // 初始化物件的程式碼
};
var obj1 = new namespace1.class1();
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved