this 是 JavaScript 裡最容易讓人產生錯覺的關鍵字。它不是「指向自己所在的函數」,而是「取決於這個函數當下如何被呼叫」。把這句話記住,本文剩下的內容就只是細節補充。
函數建立後,一個名為 this 的關鍵字就在後台隨之產生。它鏈接到某個物件,而函數正是在這個物件上進行操作。換句話說,this 是對「呼叫該函數的物件」的引用。
var cody = {
living: true,
age: 23,
gender: 'male',
getGender: function () { return cody.gender; }
};
console.log(cody.getGender()); // 'male'
在 getGender 裡,因為身處 cody 物件內部,我們可以用 cody.gender 取值。但也可以用 this 取代,因為此時 this 正指向 cody:
var cody = {
living: true,
age: 23,
gender: 'male',
getGender: function () { return this.gender; }
};
console.log(cody.getGender()); // 'male'
主題聽起來有點繞,其實不必想得太複雜。只要記住:通常 this 指向的是包含該函數的物件,而不是函數本身。當然有例外,例如使用 new、call() 或 apply() 時。
兩個重要提示:
this 就像其他變數一樣,唯一的不同是你不能改寫它。this 在函數被呼叫時才決定,它是關鍵字而非屬性。下面的程式碼中,myObject 有個屬性 sayFoo 指向函數 sayFoo。在全域呼叫 sayFoo() 時,this 指向 window;而透過 myObject.sayFoo() 呼叫時,this 指向 myObject。
var foo = 'foo';
var myObject = { foo: 'I am myObject.foo' };
var sayFoo = function () {
console.log(this['foo']);
};
myObject.sayFoo = sayFoo;
myObject.sayFoo(); // 'I am myObject.foo'
sayFoo(); // 'foo'
同一個函數,兩種呼叫方式,this 就不同。把 window 明確寫出來,關係會更清楚:
window.foo = 'foo';
window.myObject = { foo: 'I am myObject.foo' };
window.sayFoo = function () { console.log(this.foo); };
window.myObject.sayFoo = window.sayFoo;
window.myObject.sayFoo(); // 'I am myObject.foo'
window.sayFoo(); // 'foo'
所以,當多個參考指向同一個函數時,一定要清楚知道 this 會隨呼叫上下文改變。
補充一點:除了 this 之外,所有變數與參數都屬於靜態作用域(lexical scope),也就是「寫在哪裡就固定是什麼」,不會改變。this 是唯一的例外。
不幸的是,在 ECMAScript 3 中,巢狀函數裡的 this 不遵循上述規則——它不指向函數所屬的物件,而是指向 head 物件(也就是瀏覽器的 window)。
var myObject = {
func1: function () {
console.log(this); // myObject
var func2 = function () {
console.log(this); // window,從這裡開始就變了
var func3 = function () {
console.log(this); // 依然是 window
}();
}();
}
};
myObject.func1();
ECMAScript 5 的嚴格模式修正了這個行為。但在那之前,你必須意識到這個陷阱,尤其是在把函數當值傳給另一個函數時:
var foo = {
func1: function (bar) {
bar(); // 印出 window,不是 foo
console.log(this); // 這裡的 this 才是 foo
}
};
foo.func1(function () { console.log(this); });
常見的解法是在父函數中先把 this 存進一個區域變數,再透過作用域鏈在巢狀函數裡使用它。
var myObject = {
myProperty: 'I can see the light',
myMethod: function () {
var that = this; // 把 this(即 myObject)存起來
var helperFunction = function () {
// 透過作用域鏈取得 that,因此仍然印得出 myProperty
console.log(that.myProperty); // 'I can see the light'
console.log(this); // window
}();
}
};
myObject.myMethod();
this 的值通常由呼叫上下文決定,但你可以用 apply() 或 call() 明確指定。這兩個方法就像在說:「嘿,呼叫 X 函數,但請讓 Z 物件作為 this。」
var myObject = {};
var myFunction = function (param1, param2) {
this.foo = param1;
this.bar = param2;
console.log(this); // Object {foo = 'foo', bar = 'bar'}
};
myFunction.call(myObject, 'foo', 'bar');
console.log(myObject); // Object {foo = 'foo', bar = 'bar'}
apply() 用法相同,差別只在參數的傳遞方式:call() 用逗號分隔,apply() 用陣列傳入。
myFunction.apply(myObject, ['foo', 'bar']);
console.log(myObject); // Object {foo = 'foo', bar = 'bar'}
當函數用 new 觸發時,this 指向即將被建立的實例本身。也就是說,在物件真正誕生之前,我們就能用 this 開始描述它。
var Person = function (name) {
this.name = name || 'johndoe'; // this 指向即將建立的實例
};
var cody = new Person('Cody Lindley');
console.log(cody.name); // 'Cody Lindley'
那如果漏寫 new 呢?this 就會指向呼叫 Person 的上下文,此時是 head 物件:
var Person = function (name) {
this.name = name || 'johndoe';
};
var cody = Person('Cody Lindley'); // 注意:沒有 new
console.log(cody.name); // undefined
console.log(window.name); // 'Cody Lindley'
這正是「忘了寫 new」會造成難以追查的 bug 的原因,也是後來 ES6 class 強制要求用 new 的動機之一。
當方法掛在建構函數的 prototype 上時,該方法中的 this 指向呼叫它的實例。
var Person = function (x) {
if (x) { this.fullName = x; }
};
Person.prototype.whatIsMyFullName = function () {
return this.fullName; // this 指向由 Person() 建立的實例
};
var cody = new Person('cody lindley');
var lisa = new Person('lisa lindley');
console.log(cody.whatIsMyFullName(), lisa.whatIsMyFullName());
如果實例本身沒有該屬性,查找會沿原型鏈往上:
Object.prototype.fullName = 'John Doe';
var john = new Person(); // 沒有傳參數,因此實例上沒有 fullName
console.log(john.whatIsMyFullName()); // 'John Doe'
關鍵提示:在 prototype 方法裡,this 指向實例。若實例沒有要找的屬性,那麼一般原型鏈的規則在此同樣適用——它會依序查找實例、Person.prototype,最後是 Object.prototype。