Question

I am asking this from a language design point of view. So I am trying to find out

1. What is the rationale for the behavior of this?
2. To what degree the behavior of this was a mistake, or could be improved upon?

---

To clarify why I’m uneasy about this, consider this example:

var a = {}; a.f = function(){ return this; } var f = a.f; // f() != a.f() 

Note how easily the object to which f() belong is lost: separated from a, this becomes the global object (window for browsers).

Now consider:

var newA = function(){     var self = {};     self.f = function(){ return self; }     return self; }  var a = newA(); var f = a.f; // f() == a.f() ! 

Without using this at all, we are able to establish and maintain the object context regardless of where or how the method is used. I can’t help but think that, with the power that closures provide, this becomes superfluous, and perhaps even a little dangerous…

I’m not on some vendetta against this, or looking to start an argument; I’m merely trying to better understand it. I do appreciate that ‘this’ can be useful, but recognize that it can be confusing as well… Certainly confusing to beginners, and perhaps to experts as well in sufficiently obscure cases.

And yet, it remains a heavily-used and seemingly well-respected part of the language, in a time when other core aspects of the language seem fair game for shunning (i.e., Crockford and with or new). What am I missing then, that makes this indispensable?

Answer 1

You seem to be expecting this to behave as it does in certain OO languages, where it always refers to the object a method belongs to.

But in JavaScript, a function can be attached to multiple objects, or no object at all. In your example, you’ve written a function intended to be used in the context of one specific object… But nothing prevents me from taking that function and attaching it to any other object. That’s just the nature of the language – functions are first-class, object membership is optional.

Therefore, this refers to the context in which a function is called. Right now, that’s either an arbitrary object (specified via ., .apply, or .call()) or the global object. In future versions of the language, it will refer to the context in which the function was defined: the global object for global functions, the outer this for inner functions; you can view this as a correction of a design flaw, as in practice being able to refer to the global object using this was not particularly useful.