Parla del contesto delle funzioni in JavaScript…

Il contesto di esecuzione di una funzione (this) in JavaScript determina come viene chiamata la funzione e quali valori sono disponibili al suo interno. Il contesto cambia dinamicamente a seconda del modo in cui viene chiamata:

Contesto globale: Fuori dalle funzioni, this si riferisce all'oggetto globale (window nel browser, global in Node.js).

// Nel browser
console.log(this === window); // true

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

Contesto di funzione:
- Chiamata standard: In modalità non strict, this all'interno di una funzione si riferisce all'oggetto globale (se la funzione non è un metodo di un oggetto). In modalità strict ("use strict";), this sarà undefined.
```
function showThis() {
  console.log(this);
}

showThis(); // In modalità non strict: Oggetto globale; In modalità strict: undefined
```
- Chiamata come metodo di un oggetto: this si riferisce all'oggetto a cui appartiene il metodo.
```
const user = {
  name: 'Alice',
  greet: function() {
    console.log("Ciao, il mio nome è " + this.name);
  }
};

user.greet(); // Ciao, il mio nome è Alice
```
- Con new (costruttore): Crea un nuovo oggetto, che diventa il valore di this all'interno della funzione costruttrice, e restituisce quell'oggetto.
```
function Person(name) {
  this.name = name;
}

const person1 = new Person('Bob');
console.log(person1.name); // Bob
```
- Indicazione esplicita del contesto (call, apply, bind):
  - call(thisArg, arg1, arg2, ...): Chiama la funzione con il this specificato e gli argomenti elencati singolarmente.
  - apply(thisArg, [argsArray]): Chiama la funzione con il this specificato e gli argomenti sotto forma di array.
  - bind(thisArg, arg1, arg2, ...): Restituisce una nuova funzione con this legato permanentemente a thisArg e con gli argomenti legati.
```
function introduce(greeting, punctuation) {
  console.log(greeting + ", io sono " + this.name + punctuation);
}

const person = { name: 'Charlie' };

introduce.call(person, "Ciao", "!");  // Ciao, io sono Charlie!
introduce.apply(person, ["Salve", "."]); // Salve, io sono Charlie.

const boundIntroduce = introduce.bind(person, "Ehi");
boundIntroduce("?"); // Ehi, io sono Charlie?
```

Funzioni freccia: Non hanno il loro proprio contesto this. catturano this dal contesto lessicale in cui sono state definite.

const obj = {
  name: 'David',
  sayLater: function() {
    // `this` qui si riferisce a `obj`
    setTimeout(() => {
      // `this` qui si riferisce anche a `obj` (eredito da `sayLater`)
      console.log("Più tardi, sono " + this.name);
    }, 1000);
  }
};

obj.sayLater(); // Più tardi, sono David

Parla del contesto delle funzioni in JavaScript.