What is this in JavaScript?

this in JavaScript is a keyword that indicates the execution context of a function. Its value is determined by how the function is called.

Usually, this points to the global object (in browsers, window) in the case of a regular function call, unless in strict mode.

In strict mode ('use strict'), in the same scenario, this will be undefined.

When calling an object method, this refers to the object itself.

const obj = {
  method: function() {
    console.log(this); // obj
  }
};
obj.method();

When calling a constructor (new with a function), this points to the newly created instance.

function Constructor() {
  console.log(this); // instance of Constructor
}
const instance = new Constructor();

When using call, apply, bind, this is explicitly set as the first argument.

function greet() {
  console.log(`Hello, ${this.name}!`);
}

const person = { name: 'Alice' };

greet.call(person); // Hello, Alice!
greet.apply(person); // Hello, Alice!

const boundGreet = greet.bind(person);
boundGreet(); // Hello, Alice!

In arrow functions, this does not have its own context. It is lexically inherited from the scope where the arrow function was defined.

const obj2 = {
  name: 'Bob',
  greet: function() {
    const arrowGreet = () => {
      console.log(`Hello from ${this.name}!`); // `this` refers to obj2
    };
    arrowGreet();
  }
};
obj2.greet(); // Hello from Bob!

const obj3 = {
  name: 'Charlie',
  greet: () => {
    console.log(`Hello from ${this.name}!`); // `this` refers to window (or undefined in strict mode), not obj3
  }
};
obj3.greet(); // Hello from undefined! (or error)

The this context can be non-obvious, especially when passing callbacks or in asynchronous operations. Understanding the rules of this binding is critical for correct JavaScript behavior.