#### New Binding (Constructor Functions):
When a function is invoked with the new keyword, JavaScript creates a new object and sets this to point to that object.
```js
function Person(name) {
  this.name = name;
}

const person1 = new Person("Marko");
console.log(person1.name); // Marko
```

#### Implicit Binding:
When a function is called as a method of an object, this refers to the object that owns the method — the one to the left of the dot.
```js
const person = {
  name: "Marko",
  hi() {
    console.log("Hi, " + this.name);
  }
};

person.hi(); // Hi, Marko
```


#### Explicit Binding:
You can manually set the value of this using .call(), .apply(), or .bind().
```js
function greet() {
  console.log("Hi, " + this.name);
}

const person = { name: "Marko" };

greet.call(person);  // Hi, Marko
greet.apply(person); // Hi, Marko

const boundGreet = greet.bind(person);
boundGreet();        // Hi, Marko

```

#### Arrow Functions: Lexical this
Arrow functions don’t bind their own this. Instead, they inherit this from the surrounding lexical context (the scope in which they were defined).
```js
const person = {
  name: "Marko",
  greet() {
    const arrow = () => {
      console.log("Arrow:", this.name); //  Inherits from greet() → "Marko"
    };

    function regular() {
      console.log("Regular:", this.name); //  `this` is undefined or global
    }

    arrow();
    regular();
  }
};

person.greet();


```

This in Javascript: The four Binding Rules

The four main binding rules: implicit, explicit, new, default and arrow functions