D'où vient le contexte de la fonction en JavaScript…

Le contexte d’exécution (ou this) en JavaScript est déterminé au moment de l’appel de la fonction, et non au moment de sa déclaration. Les facteurs suivants influencent sa valeur :

Contexte global : Hors des fonctions, this fait référence à l’objet global (dans le navigateur window, dans Node.js global). En mode strict ('use strict'), this dans ce cas sera undefined.
```
// Dans le navigateur
console.log(this); // window

// Dans Node.js
console.log(this); // global
```
Appel d’une méthode d’un objet : Si une fonction est appelée en tant que méthode d’un objet (via le point), this fait référence à cet objet.
```
const obj = {
  name: 'Obj',
  method: function() {
    console.log(this.name);
  }
};
obj.method(); // Obj
```
Appel "normal" d’une fonction : Lors d’un appel simple d’une fonction (pas en tant que méthode), this en mode non strict fait référence à l’objet global. En mode strict, this sera undefined.
```
function greet() {
  console.log(this);
}
greet(); // window (en mode non strict) ou undefined (en mode strict)
```
Constructeur (avec new) : Lorsqu’une fonction est appelée avec le mot-clé new, elle agit comme un constructeur. this à l’intérieur de la fonction fait référence à la nouvelle instance de l’objet créée.
```
function Person(name) {
  this.name = name;
}
const person1 = new Person('Alice');
console.log(person1.name); // Alice
```
Méthodes call, apply, bind : Ces méthodes permettent de définir explicitement la valeur de this pour une fonction.
- call et apply appellent la fonction immédiatement, en passant this comme premier argument. call accepte les autres arguments séparément, tandis que apply les reçoit sous forme de tableau.
- bind retourne une nouvelle fonction avec this "attaché" de façon permanente au premier argument passé.
```
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
```

Fonctions fléchées : Les fonctions fléchées n’ont pas leur propre this. Elles "capturent" la valeur de this de l’environnement lexical dans lequel elles ont été déclarées. Cela les rend utiles pour les callbacks dans des méthodes ou lors de la manipulation d’événements DOM.

const objWithArrow = {
  name: 'Arrow Obj',
  method() {
    const arrowFunc = () => {
      console.log(this.name); // `this` est pris du `method` (objWithArrow)
    };
    arrowFunc();
  }
};
objWithArrow.method(); // Arrow Obj

// Comparer avec une fonction normale
const objWithRegular = {
  name: 'Regular Obj',
  method() {
    const regularFunc = function() {
      console.log(this); // `this` sera window ou undefined (en mode strict) lors de l’appel dans ce contexte
    };
    regularFunc();
  }
};
objWithRegular.method(); // window (ou undefined)

La définition du contexte est une caractéristique clé de JavaScript, et comprendre ces règles est essentiel pour travailler correctement avec des fonctions et des objets.

D'où vient le contexte de la fonction en JavaScript?