DIV CSS 佈局教程網

JavaScript 的 arguments、caller、callee、call 與 apply 詳解
編輯:JavaScript綜合知識     

這幾個名詞經常被一起提起,但它們分屬不同範疇:arguments 與 callee 是函式內部的隱含特性,caller 是函式物件上的屬性,call 與 apply 則是函式物件的方法。以下逐一釐清。

arguments:函式的隱含參數集合

arguments 物件代表目前執行中的函式,以及呼叫它的函式所傳入的參數。

格式:[function.]arguments[n],其中 function 是可選的函式名稱,n 是從 0 起的參數索引。

說明:arguments 是在函式被呼叫時,除了宣告的參數之外另外建立的一個隱藏物件。它「類似陣列但不是陣列」——說它類似,是因為可以透過 arguments[n] 存取單一參數,也有 length 屬性;說它不是,是因為它缺少陣列的各種方法。此外,arguments 儲存的是「實際傳入的參數」,不受函式宣告的參數列表限制,而且無法顯式建立,只在函式執行期間存在。

// arguments 的用法
function ArgTest(a, b){
  var i, s = "The ArgTest function expected ";
  var numargs = arguments.length;   // 實際傳入的參數數量
  var expargs = ArgTest.length;     // 宣告時期望的參數數量
  if (expargs < 2) s += expargs + " argument. ";
  else s += expargs + " arguments. ";
  if (numargs < 2) s += numargs + " was passed.";
  else s += numargs + " were passed.";
  s += "\n\n";
  for (i = 0; i < numargs; i++){     // 取出各參數內容
    s += " Arg " + i + " = " + arguments[i] + "\n";
  }
  return (s);
}

這裡有個關鍵區別:arguments.length 是實際傳入的參數個數,而 函式名稱.length 是宣告時定義的形參數目。兩者不相等是合法的,這也是 JavaScript 能實作「可變參數」的原因。

下面這段示範 arguments 並不是陣列:

Array.prototype.selfvalue = 1;
alert(new Array().selfvalue);     // 顯示 1,表示陣列物件有此屬性

function testAguments(){
  alert(arguments.selfvalue);   // 顯示 undefined
}

既然 arguments 具備陣列的存取性質,為何說它不是陣列?這個實驗給出了答案:為 Array.prototype 加上屬性後,真正的陣列能取到值,而 arguments 取到 undefined,可見兩者的原型鏈不同,arguments 並非陣列物件。

實務上因此常需要轉換:var args = Array.prototype.slice.call(arguments),或用 ES6 的剩餘參數寫法 function foo(...args),後者得到的是真正的陣列。

caller:誰呼叫了我

caller 回傳一個對函式的參考,該函式呼叫了目前的函式。

格式:functionName.caller,其中 functionName 是目前執行函式的名稱。

說明:caller 只有在函式執行時才有定義。若函式是被最上層直接呼叫,caller 的值為 null。若在字串情境下使用,結果等同於 functionName.toString(),也就是顯示該函式的反編譯文字。

// caller 的用法
function callerDemo() {
  if (callerDemo.caller) {
    var a = callerDemo.caller.toString();
    alert(a);
  } else {
    alert("this is a top function");
  }
}
function handleCaller() {
  callerDemo();
}

要特別注意:caller 已在 ES5 的嚴格模式下被移除,在非嚴格模式下存取它也是被禁止的(會拋出 TypeError)。這是因為它能讓程式碼任意走訪呼叫堆疊,構成資訊外洩與優化障礙。除錯時若需要呼叫堆疊,請用 console.trace() 或 Error 物件的 stack 屬性。

callee:對自身函式的參考

callee 回傳目前正在執行的 Function 物件,也就是所指定函式的內容本身。

格式:[function.]arguments.callee。

說明:callee 是 arguments 物件的成員,表示對函式物件本身的參考。它最適合用在匿名函式的遞迴,因為匿名函式沒有名稱可供自我呼叫。

// callee 可印出本身
function calleeDemo() {
  alert(arguments.callee);
}

// 用於驗證形參與實參數量
function calleeLengthDemo(arg1, arg2) {
  if (arguments.length == arguments.callee.length) {
    alert("形參與實參數量相符");
    return;
  } else {
    alert("實參長度:" + arguments.length);
    alert("形參長度:" + arguments.callee.length);
  }
}

// 遞迴計算
var sum = function(n){
  if (n <= 0) return 1;
  else return n + arguments.callee(n - 1);
}

比較一般寫法就能看出差異:

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

一般寫法中,函式內部引用了 sum 這個變數名。函式運算式所指派的僅是一個變數,函式內呼叫 sum 等同於呼叫一個外部變數,語意上並未清楚表達「呼叫自己」。若這個變數後來被重新赋值,遞迴就會出錯。callee 直接指向函式物件本身,不受外部變數變動影響。

不過 callee 同樣在 ES5 嚴格模式下被禁用。現代做法是為具名函式運算式命名,該名稱在函式體內部即為唯讀的自身參考:

var sum = function factorial(n){
  return n <= 1 ? 1 : n * factorial(n - 1);
};

apply 與 call:改變函式的 this 指向

這兩個方法的作用相同——把函式綁定到另一個物件上執行,差別只在參數的傳遞方式:

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

呼叫後,函式內部所有的 this 都會指向 thisArg,藉此可以把一個函式當作另一個物件的方法來執行。

apply 的說明:若 argArray 不是有效的陣列或 arguments 物件,會導致 TypeError。若未提供 argArray 與 thisArg,Global 物件會被用作 thisArg,且無法傳入任何參數。

call 的說明:call 會把函式的物件上下文從初始的上下文改為 thisArg 指定的新物件。若未提供 thisArg,Global 物件被用作 thisArg。

如何選擇:參數數量固定時用 call,參數來源是陣列時用 apply。ES6 之後有了更好的選擇——用展開語法 func(...argsArray) 可以完全取代 apply,語意更清楚:

Math.max.apply(null, [1, 5, 3]);    // 舊寫法
Math.max(...[1, 5, 3]);           // 新寫法

應用技巧:以 call 實作「繼承」

使用 call 與 apply 還有一層妙用:套用另一個函式(建構函式)之後,目前的函式就具備了對方的方法與屬性,這也就是所謂的「繼承」。

// 繼承的示範
function base() {
  this.member = "dnnsun_Member";
  this.method = function() {
    window.alert(this.member);
  }
}
function extend() {
  base.call(this);
  window.alert(member);
  window.alert(this.method);
}

呼叫 base.call(this) 之後,extend 的 this 被傳進 base 執行,於是 base 裡掛在 this 上的屬性與方法都變成了 extend 實例的一部分。這種「借用建構函式」的做法在 ES6 class 普及之前是最常見的繼承手法。

順帶一提,Prototype 函式庫正是用 apply 來建立它的類別定義模式:

var Class = {
  create: function() {
    return function() {
      this.initialize.apply(this, arguments);
    }
  }
}

解析:這個物件只有一個 create 方法,它回傳一個函式作為類別,而該函式同時也是建構函式。建構時它呼叫 initialize,這個方法在建立類別實例時定義。透過這個途徑,就實現了 Prototype 的類別建立模式。這裡用 apply 而非 call 是因為要把建構時收到的所有參數原封不動轉交給 initialize,而參數數量事先未知。

使用方式:

var vehicle = Class.create();
vehicle.prototype = {
  initialize: function(type){
    this.type = type;
  },
  showSelf: function(){
    alert("this vehicle is " + this.type);
  }
}
var moto = new vehicle("Moto");
moto.showSelf();

現代寫法對照

這五個特性中,arguments 與 call/apply 至今仍常用,callee 與 caller 則已被淘汰。ES6 之後的對應寫法如下:

  • arguments → 剩餘參數 function foo(...args),得到真正的陣列
  • arguments.callee → 具名函式運算式,如 var f = function fact(n){...}
  • fn.caller → console.trace() 或 new Error().stack
  • fn.apply(ctx, arr) → fn.call(ctx, ...arr) 或 fn(...arr)
  • 原型繼承 → class 與 extends、super()

理解這些舊機制的價值在於讀懂既有程式碼,以及真正搞清 this 綁定的運作原理——這個知識在使用現代框架時同樣關鍵,因為 React 的 class 元件、Vue 的 methods 都建立在相同的規則之上。

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