De unde provine contextul funcției în JavaScript…

Contextul de execuție (sau this) în JavaScript este determinat în momentul apelului funcției, nu în momentul declarării acesteia. Următorii factori influențează valoarea sa:

Contextul global: În afara funcțiilor, this face referire la obiectul global (în browser window, în Node.js global). În modul strict ('use strict'), this în acest caz va fi undefined.
```
// În browser
console.log(this); // window

// În Node.js
console.log(this); // global
```
Apelul unei metode a unui obiect: Dacă o funcție este apelată ca metodă a unui obiect (prin punct), this face referire la acel obiect.
```
const obj = {
  name: 'Obj',
  method: function() {
    console.log(this.name);
  }
};
obj.method(); // Obj
```
Apel "obișnuit" al unei funcții: La un apel simplu de funcție (nu ca metodă), this în modul non-strict face referire la obiectul global. În modul strict, this va fi undefined.
```
function greet() {
  console.log(this);
}
greet(); // window (în modul non-strict) sau undefined (în modul strict)
```
Constructor (cu new): Când o funcție este apelată cu cuvântul cheie new, acționează ca un constructor. this din interiorul funcției face referire la noul obiect creat.
```
function Person(name) {
  this.name = name;
}
const person1 = new Person('Alice');
console.log(person1.name); // Alice
```
Metodele call, apply, bind: Aceste metode permit setarea explicită a valorii this pentru o funcție.
- call și apply apelează funcția imediat, transmitând this ca primul argument. call acceptă ceilalți argumente separat, iar apply îi primește sub formă de array.
- bind returnează o nouă funcție cu this "legat" permanent de primul argument transmis.
```
const anotherObj = { name: 'Another Obj' };

function displayContext() {
  console.log(this.name);
}

displayContext.call(anotherObj); // Another Obj
displayContext.apply(anotherObj); // Another Obj

const boundFunction = displayContext.bind(anotherObj);
boundFunction(); // Another Obj
```

Funcții săgeată: Funcțiile săgeată nu au propriul this. Ele "captură" valoarea this din mediul lexical în care au fost declarate. Acest lucru le face utile pentru callback-uri în interiorul metodelor sau la manipularea evenimentelor DOM.

const objWithArrow = {
  name: 'Arrow Obj',
  method() {
    const arrowFunc = () => {
      console.log(this.name); // `this` este luat din `method` (objWithArrow)
    };
    arrowFunc();
  }
};
objWithArrow.method(); // Arrow Obj

// Comparativ cu o funcție obișnuită
const objWithRegular = {
  name: 'Regular Obj',
  method() {
    const regularFunc = function() {
      console.log(this); // `this` va fi window sau undefined (în modul strict) la apel
    };
    regularFunc();
  }
};
objWithRegular.method(); // window (sau undefined)

Definirea contextului — una dintre caracteristicile cheie ale JavaScript-ului, iar înțelegerea acestor reguli este esențială pentru lucrul corect cu funcțiile și obiectele.

De unde provine contextul funcției în JavaScript?