Default and Implicit this Binding in JavaScript

Default and Implicit this Binding in JavaScript

this has two common binding rules: default (plain call) and implicit (method call). Here is how each works.

Default Binding (Plain Call)

function foo() {
  console.log(this);
}
foo(); // window (non-strict) or undefined (strict)
``
In non-strict mode, `this` is the global object (`window` in browsers). In strict mode, `this` is `undefined`.

### Implicit Binding (Method Call)

```js
const obj = {
  name: "Kunal",
  greet() {
    console.log(this.name);
  },
};
obj.greet(); // "Kunal"
``
The object to the left of the dot at **call time** determines `this`. `obj.greet()` means `this` is `obj`.

### Losing `this` (Detaching a Method)

```js
const obj = { name: "Kunal", greet() { console.log(this.name); } };
const fn = obj.greet;
fn(); // undefined (this is lost   plain call)
``
When you assign a method to a variable and call it, it is a plain call. `this` is not `obj` anymore.

### Callbacks Lose `this`

```js
const obj = { name: "Kunal", greet() { console.log(this.name); } };
setTimeout(obj.greet, 1000); // undefined (detached, plain call)
``
`setTimeout` calls `greet` as a plain function, not as a method of `obj`. `this` is lost.

### Fix: bind, Arrow, or Wrapper

```js
// bind
setTimeout(obj.greet.bind(obj), 1000); // "Kunal"

// arrow wrapper
setTimeout(() => obj.greet(), 1000); // "Kunal"

// arrow method
const obj2 = {
  name: "Kunal",
  greet: () => console.log(this.name), // lexical this (be careful)
};
``
### Nested Objects

```js
const outer = {
  inner: {
    name: "Kunal",
    greet() { console.log(this.name); },
  },
};
outer.inner.greet(); // "Kunal" (this is inner, the immediate object)
``
Only the last object before the method matters.

### The Takeaway

Default binding: plain call, `this` is global/undefined. Implicit binding: method call, `this` is the object to the left of the dot. Detaching a method (assigning to a variable or passing as a callback) loses `this`. Fix with `bind`, arrow wrapper, or arrow method.