How does the “this” keyword work?

  1. Home
  2. javascript
  3. How does the “this” keyword work?

I have noticed that there doesn’t appear to be a clear explanation of what the this keyword is and how it is correctly (and incorrectly) used in JavaScript on the Stack Overflow site.

I have witnessed some very strange behaviour with it and have failed to understand why it has occurred.

How does this work and when should it be used?

First answer

I recommend reading Mike West‘s article Scope in JavaScript (mirror) first. It is an excellent, friendly introduction to the concepts of this and scope chains in JavaScript.

Once you start getting used to this, the rules are actually pretty simple. The ECMAScript 5.1 Standard defines this:

§11.1.1 The this keyword

The this keyword evaluates to the value of the ThisBinding of the current execution context

ThisBinding is something that the JavaScript interpreter maintains as it evaluates JavaScript code, like a special CPU register which holds a reference to an object. The interpreter updates the ThisBinding whenever establishing an execution context in one of only three different cases:

1. Initial global execution context

This is the case for JavaScript code that is evaluated at the top-level, e.g. when directly inside a <script>:

  alert("I'm evaluated in the initial global execution context!");

  setTimeout(function () {
      alert("I'm NOT evaluated in the initial global execution context.");
  }, 1);

When evaluating code in the initial global execution context, ThisBinding is set to the global object, window (§

Entering eval code

  • …by a direct call to eval()
    ThisBinding is left unchanged; it is the same value as the ThisBinding of the calling execution context (§10.4.2 (2)(a)).

  • …if not by a direct call to eval()
    ThisBinding is set to the global object as if executing in the initial global execution context (§10.4.2 (1)).

§ defines what a direct call to eval() is. Basically, eval(...) is a direct call whereas something like (0, eval)(...) or var indirectEval = eval; indirectEval(...); is an indirect call to eval(). See chuckj’s answer to (1, eval)(‘this’) vs eval(‘this’) in JavaScript? and Dmitry Soshnikov’s ECMA-262-5 in detail. Chapter 2. Strict Mode. for when you might use an indirect eval() call.

Entering function code

This occurs when calling a function. If a function is called on an object, such as in obj.myMethod() or the equivalent obj["myMethod"](), then ThisBinding is set to the object (obj in the example; §13.2.1). In most other cases, ThisBinding is set to the global object (§10.4.3).

The reason for writing “in most other cases” is because there are eight ECMAScript 5 built-in functions that allow ThisBinding to be specified in the arguments list. These special functions take a so-called thisArg which becomes the ThisBinding when calling the function (§10.4.3).

These special built-in functions are:

  • Function.prototype.apply( thisArg, argArray )
  • thisArg [ , arg1 [ , arg2, ... ] ] )
  • Function.prototype.bind( thisArg [ , arg1 [ , arg2, ... ] ] )
  • Array.prototype.every( callbackfn [ , thisArg ] )
  • Array.prototype.some( callbackfn [ , thisArg ] )
  • Array.prototype.forEach( callbackfn [ , thisArg ] )
  • callbackfn [ , thisArg ] )
  • Array.prototype.filter( callbackfn [ , thisArg ] )

In the case of the Function.prototype functions, they are called on a function object, but rather than setting ThisBinding to the function object, ThisBinding is set to the thisArg.

In the case of the Array.prototype functions, the given callbackfn is called in an execution context where ThisBinding is set to thisArg if supplied; otherwise, to the global object.

Those are the rules for plain JavaScript. When you begin using JavaScript libraries (e.g. jQuery), you may find that certain library functions manipulate the value of this. The developers of those JavaScript libraries do this because it tends to support the most common use cases, and users of the library typically find this behavior to be more convenient. When passing callback functions referencing this to library functions, you should refer to the documentation for any guarantees about what the value of this is when the function is called.

If you are wondering how a JavaScript library manipulates the value of this, the library is simply using one of the built-in JavaScript functions accepting a thisArg. You, too, can write your own function taking a callback function and thisArg:

function doWork(callbackfn, thisArg) {
    if (callbackfn != null);

There’s a special case I didn’t yet mention. When constructing a new object via the new operator, the JavaScript interpreter creates a new, empty object, sets some internal properties, and then calls the constructor function on the new object. Thus, when a function is called in a constructor context, the value of this is the new object that the interpreter created:

function MyType() {
    this.someData = "a string";

var instance = new MyType();
// Kind of like the following, but there are more steps involved:
// var instance = {};

Arrow functions

Arrow functions (introduced in ECMA6) alter the scope of this. See the existing canonical question, Arrow function vs function declaration / expressions: Are they equivalent / exchangeable? for more information. But in short:

Arrow functions don’t have their own this…. binding.
Instead, those identifiers are resolved in the lexical scope like any
other variable. That means that inside an arrow function, this…refer(s) to the values of this in the environment
the arrow function is defined in.

Just for fun, test your understanding with some examples

To reveal the answers, mouse over the light yellow boxes.

  1. What is the value of this at the marked line? Why?

    window — The marked line is evaluated in the initial global execution context.

    if (true) {
        // What is `this` here?
  2. What is the value of this at the marked line when obj.staticFunction() is executed? Why?

    obj — When calling a function on an object, ThisBinding is set to the object.

    var obj = {
        someData: "a string"
    function myFun() {
        return this // What is `this` here?
    obj.staticFunction = myFun;
    console.log("this is window:", obj.staticFunction() == window);
    console.log("this is obj:", obj.staticFunction() == obj);

  3. What is the value of this at the marked line? Why?


    In this example, the JavaScript interpreter enters function code, but because myFun/obj.myMethod is not called on an object, ThisBinding is set to window.

    This is different from Python, in which accessing a method (obj.myMethod) creates a bound method object.

    var obj = {
        myMethod: function () {
            return this; // What is `this` here?
    var myFun = obj.myMethod;
    console.log("this is window:", myFun() == window);
    console.log("this is obj:", myFun() == obj);

  4. What is the value of this at the marked line? Why?


    This one was tricky. When evaluating the eval code, this is obj. However, in the eval code, myFun is not called on an object, so ThisBinding is set to window for the call.

    function myFun() {
        return this; // What is `this` here?
    var obj = {
        myMethod: function () {
  5. What is the value of this at the marked line? Why?


    The line; is invoking the special built-in function, which accepts thisArg as the first argument.

    function myFun() {
        return this; // What is `this` here?
    var obj = {
        someData: "a string"
    console.log("this is window:", == window);
    console.log("this is obj:", == obj);

Second answer

Javascript’s this

Simple function invocation

Consider the following function:

function foo() {
foo(); // calling the function

Note that we are running this in the normal mode, i.e. strict mode is not used.

When running in a browser, the value of this would be logged as window. This is because window is the global variable in a web browser’s scope.

If you run this same piece of code in an environment like node.js, this would refer to the global variable in your app.

Now if we run this in strict mode by adding the statement "use strict"; to the beginning of the function declaration, this would no longer refer to the global variable in either of the environments. This is done to avoid confusions in strict mode. this would, in this case just log undefined, because that is what it is, it is not defined.

In the following cases, we would see how to manipulate the value of this.

Calling a function on an object

There are different ways to do this. If you have called native methods in Javascript like forEach and slice, you should already know that the this variable in that case refers to the Object on which you called that function (Note that in javascript, just about everything is an Object, including Arrays and Functions). Take the following code for example.

var myObj = {key: "Obj"};
myObj.logThis = function () {
    // I am a method
myObj.logThis(); // myObj is logged

If an Object contains a property which holds a Function, the property is called a method. This method, when called, will always have it’s this variable set to the Object it is associated with. This is true for both strict and non-strict modes.

Note that if a method is stored (or rather, copied) in another variable, the reference to this is no longer preserved in the new variable. For example:

// continuing with the previous code snippet

var myVar = myObj.thisMethod;
// logs either of window/global/undefined based on mode of operation

Considering a more commonly practical scenario:

var el = document.getElementById('idOfEl');
el.addEventListener('click', function() { console.log(this) });
// the function called by addEventListener contains this as the reference to the element
// so clicking on our element would log that element itself

The new keyword

Consider a constructor function in Javascript:

function Person (name) { = name;
    this.sayHello = function () {
        console.log ("Hello", this);

var awal = new Person("Awal");
// In `awal.sayHello`, `this` contains the reference to the variable `awal`

How does this work? Well, let’s see what happens when we use the new keyword.

  1. Calling the function with the new keyword would immediately initialize an Object of type Person.
  2. The constructor of this Object has its constructor set to Person. Also, note that typeof awal would return Object only.
  3. This new Object would be assigned the prototype of Person.prototype. This means that any method or property in the Person prototype would be available to all instances of Person, including awal.
  4. The function Person itself is now invoked; this being a reference to the newly constructed object awal.

Pretty straightforward, eh?

Note that the official ECMAScript spec nowhere states that such types of functions are actual constructor functions. They are just normal functions, and new can be used on any function. It’s just that we use them as such, and so we call them as such only.

Calling functions on Functions: call and apply

So yeah, since functions are also Objects (and in-fact first class variables in Javascript), even functions have methods which are… well, functions themselves.

All functions inherit from the global Function, and two of its many methods are call and apply, and both can be used to manipulate the value of this in the function on which they are called.

function foo () { console.log (this, arguments); }
var thisArg = {myObj: "is cool"};, 1, 2, 3);

This is a typical example of using call. It basically takes the first parameter and sets this in the function foo as a reference to thisArg. All other parameters passed to call is passed to the function foo as arguments.
So the above code will log {myObj: "is cool"}, [1, 2, 3] in the console. Pretty nice way to change the value of this in any function.

apply is almost the same as call accept that it takes only two parameters: thisArg and an array which contains the arguments to be passed to the function. So the above call call can be translated to apply like this:

foo.apply(thisArg, [1,2,3])

Note that call and apply can override the value of this set by dot method invocation we discussed in the second bullet.
Simple enough 🙂

Presenting…. bind!

bind is a brother of call and apply. It is also a method inherited by all functions from the global Function constructor in Javascript. The difference between bind and call/apply is that both call and apply will actually invoke the function. bind, on the other hand, returns a new function with the thisArg and arguments pre-set. Let’s take an example to better understand this:

function foo (a, b) {
    console.log (this, arguments);
var thisArg = {myObj: "even more cool now"};
var bound = foo.bind(thisArg, 1, 2);
console.log (typeof bound); // logs `function`
console.log (bound);
/* logs `function () { native code }` */

bound(); // calling the function returned by `.bind`
// logs `{myObj: "even more cool now"}, [1, 2]`

See the difference between the three? It is subtle, but they are used differently. Like call and apply, bind will also over-ride the value of this set by dot-method invocation.

Also note that neither of these three functions do any change to the original function. call and apply would return the value from freshly constructed functions while bind will return the freshly constructed function itself, ready to be called.

Extra stuff, copy this

Sometimes, you don’t like the fact that this changes with scope, especially nested scope. Take a look at the following example.

var myObj = {
    hello: function () {
        return "world"
    myMethod: function () {
        // copy this, variable names are case-sensitive
        var that = this;
        // callbacks ftw \o/"args", function () {
            // I want to call `hello` here
            this.hello(); // error
            // but `this` references to `foo` damn!
            // oh wait we have a backup \o/
            that.hello(); // "world"

In the above code, we see that the value of this changed with the nested scope, but we wanted the value of this from the original scope. So we ‘copied’ this to that and used the copy instead of this. Clever, eh?


  1. What is held in this by default?
  2. What if we call the function as a method with Object-dot notation?
  3. What if we use the new keyword?
  4. How do we manipulate this with call and apply?
  5. Using bind.
  6. Copying this to solve nested-scope issues.

Third answer

“this” is all about scope. Every function has its own scope, and since everything in JS is an object, even a function can store some values into itself using “this”. OOP 101 teaches that “this” is only applicable to instances of an object. Therefore, every-time a function executes, a new “instance” of that function has a new meaning of “this”.

Most people get confused when they try to use “this” inside of anonymous closure functions like:

(function(value) {
    this.value = value;
        elt.innerHTML = this.value;        // uh oh!! possibly undefined

So here, inside each(), “this” doesn’t hold the “value” that you expect it to (from

this.value = value;

above it). So, to get over this (no pun intended) problem, a developer could:

(function(value) {
    var self = this;            // small change
    self.value = value;
        elt.innerHTML = self.value;        // phew!! == 2 

Try it out; you’ll begin to like this pattern of programming

Spread the love

Related articles

No Comments Yet.

Leave a comment

Your email address will not be published. Required fields are marked *