Parlez du contexte des fonctions en JavaScript…

Le contexte d'exécution d'une fonction (this) en JavaScript détermine comment la fonction est appelée et quelles valeurs sont accessibles à l'intérieur. Le contexte change dynamiquement en fonction de la façon dont la fonction est appelée :

Contexte global : Hors des fonctions, this fait référence à l'objet global (window dans le navigateur, global dans Node.js).

// Dans le navigateur
console.log(this === window); // true

// Dans Node.js
console.log(this === global); // true

Contexte de fonction :
- Appel standard : En mode non strict, this à l'intérieur d'une fonction fait référence à l'objet global (si la fonction n'est pas un méthode d'un objet). En mode strict ("use strict";), this sera undefined.
```
function showThis() {
  console.log(this);
}

showThis(); // En mode non strict : Objet global ; En mode strict : undefined
```
- Appel en tant que méthode d'un objet : this fait référence à l'objet auquel appartient la méthode.
```
const user = {
  name: 'Alice',
  greet: function() {
    console.log("Bonjour, je m'appelle " + this.name);
  }
};

user.greet(); // Bonjour, je m'appelle Alice
```
- Avec new (constructeur) : Crée un nouvel objet, qui devient la valeur de this à l'intérieur de la fonction constructeur, et retourne cet objet.
```
function Person(name) {
  this.name = name;
}

const person1 = new Person('Bob');
console.log(person1.name); // Bob
```
- Indication explicite du contexte (call, apply, bind) :
  - call(thisArg, arg1, arg2, ...) : Appelle la fonction avec le this spécifié et les arguments listés séparément.
  - apply(thisArg, [argsArray]) : Appelle la fonction avec le this spécifié et les arguments sous forme de tableau.
  - bind(thisArg, arg1, arg2, ...) : Retourne une nouvelle fonction avec this lié de façon permanente à thisArg et avec des arguments liés.
```
function introduce(greeting, punctuation) {
  console.log(greeting + ", je suis " + this.name + punctuation);
}

const person = { name: 'Charlie' };

introduce.call(person, "Salut", "!");  // Salut, je suis Charlie!
introduce.apply(person, ["Bonjour", "."]); // Bonjour, je suis Charlie.

const boundIntroduce = introduce.bind(person, "Hé");
boundIntroduce("?"); // Hé, je suis Charlie?
```

Fonctions fléchées : N'ont pas leur propre contexte this. Elles capturent this du contexte lexical dans lequel elles ont été définies.

const obj = {
  name: 'David',
  sayLater: function() {
    // `this` ici fait référence à `obj`
    setTimeout(() => {
      // `this` ici fait également référence à `obj` (hérité de `sayLater`)
      console.log("Plus tard, je suis " + this.name);
    }, 1000);
  }
};

obj.sayLater(); // Plus tard, je suis David

Parlez du contexte des fonctions en JavaScript.