38

Can anybody explain to me why A is true and B is false? I would have expected B to be true as well.

function MyObject() {

};

MyObject.prototype.test = function () {
    console.log("A", this instanceof MyObject);
    (function () {
        console.log("B", this instanceof MyObject);
    }());
}

new MyObject().test();

update: since ecmascript-6 you can use arrow functions which would make it easy to refer to MyObject like this:

function MyObject() {

};

MyObject.prototype.test = function () {
    console.log("A", this instanceof MyObject);
    (() => {//a change is here, which will have the effect of the next line resulting in true
        console.log("B", this instanceof MyObject);
    })(); //and here is a change
}

new MyObject().test();    
18
  • 8
    Welcome to functional scope in JavaScript. Commented Dec 29, 2011 at 17:09
  • 1
    @zzzzBov: That's not a closure. Commented Dec 29, 2011 at 17:09
  • You might want to use an additional pair of parens to improve readability: ( new MyObject() ).test() Commented Dec 29, 2011 at 17:11
  • @SLaks, I've edited my comment to correctly reflect the usage of the anonymous function, although it is being used as a closure. Commented Dec 29, 2011 at 17:11
  • 1
    No; it's not being used as a closure. It's not closing over anything. Scope is not really relevant. Commented Dec 29, 2011 at 17:12

4 Answers 4

40

Inside of your anonymous function this is the global object.

Inside of test, this is the instance of MyObject on which the method was invoked.


Whenever you call a function like this:

someFunction(); // called function invocation

this is always the global object, or undefined in strict mode (unless someFunction was created with bind** — see below)

Whenever you call a function like this

foo.someMethod();  //called method invocation

this is set to foo


**EcmaScript5 defines a bind function that allows you to create a function that has a pre-set value for this

So this

    var obj = { a: 12 };
    var someFunction = (function () { alert(this.a); }).bind(obj);
    someFunction();

Causes someFucntion to be invoked with this equal to obj, and alerts 12. I bring this up only to note that this is a potential exception to the rule I mentioned about functions invoked as

someFunction();

always having this equal to the global object (or undefined in strict mode)

Sign up to request clarification or add additional context in comments.

2 Comments

The line (function () { alert(this.a); }).bind(obj) is exactly what I was looking for - binding context to an anonymous function. Works perfectly, +1
you can also set the this using func.call(this, arg1, arg2..)
26

this is special. It refers to the object that the function is being called on behalf of (most commonly via dot syntax).

So, in the case of A, the function is being called on behalf of a new MyObject object. B is in a different function that isn't explicitly being called on behalf of any object, so this defaults to the global object (window).

In other words, this changes depending on how the function is called, not where or how it is defined. The fact that you're using an anonymous function (defined inside another function) is coincidental and has no effect on the value of this.

1 Comment

Your statement "this changes depending on how the function is called, not where or how it is defined", can be misleading. In fact, this is simply the called function's owner - and that is in itself always either is explicitly defined or defaults to the global object. myVar.doSomething = doSomething; defines the function myVar.doSomething as doSomething where this will always refer to myVar when calling myVar.doSomething(), regardless of where myVar.doSomething() is called from. Your statement might suggest otherwise.
11

In the anonymous function, this is bound to the global object (window in a browser environment).

There are various ways of accessing the instance:

var self = this;
(function () {
    console.log("B", self instanceof MyObject);
}());

or

(function () {
    console.log("B", this instanceof MyObject);
}).call(this);

Comments

4

this is set based on how you call the function.
Your anonymous function is a normal function call, so this is the global object.

You could write (function() { ... }).call(this) to explicitly call it with your this.

2 Comments

Well, I'm assuming strict mode, so... :)
... so this is undefined.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.