JavaScript - this Keyword

Hello there, aspiring JavaScript developers! Today, we're going to embark on an exciting journey into the world of the this keyword. As your friendly neighborhood computer science teacher, I'm here to guide you through this sometimes tricky, but always fascinating, concept. So, grab your favorite beverage, get comfortable, and let's dive in!

What is 'this' keyword?

Imagine you're at a party, and someone shouts, "Hey, you!" Who would turn around? Everyone, right? But if they said, "Hey, Sarah!" only Sarah would respond. In JavaScript, the this keyword is like saying "Hey, you!" to an object. It's a way to refer to the current object in context.

The this keyword is a special identifier that's automatically defined in the scope of every function. But here's the catch - its value is determined by how a function is called. This dynamic nature of this is what makes it both powerful and sometimes confusing.

Which object does the 'this' refer to?

Now, this is where things get interesting. The object that this refers to can change depending on how and where it's used. It's like a chameleon, changing its colors based on its surroundings. Let's look at some scenarios:

Syntax

Before we dive deeper, let's quickly look at how we use this:

console.log(this);

Simple, right? But don't let its simplicity fool you. The magic (or mischief) happens when we use it in different contexts.

JavaScript 'this' in the Global Scope

When used in the global scope (outside of any function), this refers to the global object. In a browser, that's usually the window object.

console.log(this === window); // true

this.myGlobalVar = "I'm global!";
console.log(window.myGlobalVar); // "I'm global!"

Here, this is like the VIP pass that gives you access to the entire party (global scope).

JavaScript 'this' in a Function

When this is used inside a regular function, its value depends on how the function is called.

function showThis() {
    console.log(this);
}

showThis(); // window (in non-strict mode)

In this case, this is like a lost puppy, attaching itself to whatever is around - which in non-strict mode is the global object.

'this' in a Function in Strict Mode

Strict mode is like the strict teacher who doesn't let you get away with anything. In strict mode, this inside a function is undefined unless set explicitly.

"use strict";
function strictThis() {
    console.log(this);
}

strictThis(); // undefined

'this' in a Constructor Function

When a function is used as a constructor (with the new keyword), this refers to the newly created object.

function Person(name) {
    this.name = name;
    this.greet = function() {
        console.log("Hello, I'm " + this.name);
    };
}

const john = new Person("John");
john.greet(); // "Hello, I'm John"

Here, this is like a birth certificate, establishing the identity of the newly born object.

'this' in an Arrow Function

Arrow functions are the rebels of the JavaScript world. They don't bind their own this but inherit it from the enclosing scope.

const obj = {
    name: "Alice",
    sayHello: () => {
        console.log("Hello, " + this.name);
    }
};

obj.sayHello(); // "Hello, undefined"

In this case, this in the arrow function doesn't refer to obj, but to the surrounding scope (likely the global scope).

'this' in the Object Method

When this is used in a method (a function that's a property of an object), it refers to the object the method was called on.

const car = {
    brand: "Toyota",
    getBrand: function() {
        return this.brand;
    }
};

console.log(car.getBrand()); // "Toyota"

Here, this is like a loyal butler, always referring to its master (the object).

'this' in a Child Function of an Object Method

This is where things can get tricky. In a function within a method, this doesn't refer to the object anymore.

const restaurant = {
    name: "Tasty Treats",
    getMenu: function() {
        function displayName() {
            console.log(this.name);
        }
        displayName();
    }
};

restaurant.getMenu(); // undefined

In this case, this in displayName() refers to the global object, not restaurant.

JavaScript 'this' in Event Handlers

In event handlers, this typically refers to the element that received the event.

<button id="myButton">Click me!</button>

<script>
document.getElementById("myButton").addEventListener("click", function() {
    console.log(this); // <button id="myButton">Click me!</button>
});
</script>

Here, this is like a spotlight, focusing on the star of the show - the element that was clicked.

Explicit Function Binding in JavaScript

Sometimes, we want to be the boss and tell this exactly what it should be. We can do this using call(), apply(), or bind().

const person1 = { name: "Alice" };
const person2 = { name: "Bob" };

function sayHello() {
    console.log("Hello, " + this.name);
}

sayHello.call(person1); // "Hello, Alice"
sayHello.apply(person2); // "Hello, Bob"

const boundHello = sayHello.bind(person1);
boundHello(); // "Hello, Alice"

These methods are like a director, telling this exactly which role to play.

JavaScript 'this' Precedence

Now, let's summarize the precedence of this binding:

Rule	Precedence
new keyword	1 (Highest)
Explicit binding (call, apply, bind)	2
Method invocation	3
Function invocation	4 (Lowest)

Remember, arrow functions are special and always inherit this from their surrounding scope.

And there you have it, folks! We've journeyed through the land of this, exploring its many faces and quirks. Remember, understanding this is like learning to ride a bike - it might be wobbly at first, but with practice, you'll be zooming around in no time. Keep coding, keep exploring, and most importantly, keep having fun with JavaScript!

Credits: Image by storyset