Erzählen Sie vom Kontext von Funktionen in…

Der Ausführungs-Kontext einer Funktion (this) in JavaScript bestimmt, wie die Funktion aufgerufen wird und welche Werte innerhalb der Funktion zugänglich sind. Der Kontext ändert sich dynamisch je nach Aufrufart:

Globaler Kontext: Außerhalb von Funktionen bezieht sich this auf das globale Objekt (window im Browser, global in Node.js).
```
// Im Browser
console.log(this === window); // true

// In Node.js
console.log(this === global); // true
```
Funktionskontext:
- Standardaufruf: Im nicht-strengen Modus verweist this innerhalb einer Funktion auf das globale Objekt (sofern die Funktion kein Methodenteil eines Objekts ist). Im strengen Modus ("use strict";) ist this undefined.
```
function showThis() {
  console.log(this);
}

showThis(); // Im nicht-strengen Modus: Globales Objekt; Im strengen Modus: undefined
```
- Aufruf als Method eines Objekts: this verweist auf das Objekt, zu dem die Methode gehört.
```
const user = {
  name: 'Alice',
  greet: function() {
    console.log("Hallo, mein Name ist " + this.name);
  }
};

user.greet(); // Hallo, mein Name ist Alice
```
- Mit new (Konstruktor): Erstellt ein neues Objekt, das zum Wert von this innerhalb der Konstruktorfunktion wird, und gibt dieses Objekt zurück.
```
function Person(name) {
  this.name = name;
}

const person1 = new Person('Bob');
console.log(person1.name); // Bob
```
- Explizite Angabe des Kontexts (call, apply, bind):
  - call(thisArg, arg1, arg2, ...): Ruft die Funktion mit dem angegebenen this und den einzelnen Argumenten auf.
  - apply(thisArg, [argsArray]): Ruft die Funktion mit dem angegebenen this und den Argumenten in einem Array auf.
  - bind(thisArg, arg1, arg2, ...): Gibt eine neue Funktion zurück, bei der this dauerhaft an thisArg gebunden ist und die an die Argumente gebunden sind.
```
function introduce(greeting, punctuation) {
  console.log(greeting + ", ich bin " + this.name + punctuation);
}

const person = { name: 'Charlie' };

introduce.call(person, "Hallo", "!");  // Hallo, ich bin Charlie!
introduce.apply(person, ["Hallo", "."]); // Hallo, ich bin Charlie.

const boundIntroduce = introduce.bind(person, "Hey");
boundIntroduce("?"); // Hey, ich bin Charlie?
```

Arrow-Funktionen: Haben keinen eigenen this-Kontext. Sie erfassen this aus dem umgebenden lexikalischen Geltungsbereich, in dem sie definiert wurden.

const obj = {
  name: 'David',
  sayLater: function() {
    // `this` hier bezieht sich auf `obj`
    setTimeout(() => {
      // `this` hier bezieht sich ebenfalls auf `obj` (geerbt aus `sayLater`)
      console.log("Später, ich bin " + this.name);
    }, 1000);
  }
};

obj.sayLater(); // Später, ich bin David

Erzählen Sie vom Kontext von Funktionen in JavaScript.