Habla sobre el contexto de las funciones en…

El contexto de ejecución de una función (this) en JavaScript determina cómo se llama a la función y qué valores están disponibles dentro de ella. El contexto cambia dinámicamente dependiendo de la forma en que se llama:

Contexto global: Fuera de funciones, this hace referencia al objeto global (window en el navegador, global en Node.js).

// En el navegador
console.log(this === window); // true

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

Contexto de función:
- Llamada estándar: En modo no estricto, this dentro de una función hace referencia al objeto global (si la función no es un método de un objeto). En modo estricto ("use strict";), this será undefined.
```
function showThis() {
  console.log(this);
}

showThis(); // En modo no estricto: Objeto global; En modo estricto: undefined
```
- Llamada como método de un objeto: this hace referencia al objeto al que pertenece el método.
```
const user = {
  name: 'Alice',
  greet: function() {
    console.log("Hola, mi nombre es " + this.name);
  }
};

user.greet(); // Hola, mi nombre es Alice
```
- Con new (constructor): Crea un nuevo objeto, que se convierte en el valor de this dentro de la función constructora, y devuelve ese objeto.
```
function Person(name) {
  this.name = name;
}

const person1 = new Person('Bob');
console.log(person1.name); // Bob
```
- Indicación explícita del contexto (call, apply, bind):
  - call(thisArg, arg1, arg2, ...): Llama a la función con el this especificado y los argumentos listados individualmente.
  - apply(thisArg, [argsArray]): Llama a la función con el this especificado y los argumentos en forma de array.
  - bind(thisArg, arg1, arg2, ...): Devuelve una nueva función con this ligado permanentemente a thisArg y con los argumentos ligados.
```
function introduce(greeting, punctuation) {
  console.log(greeting + ", soy " + this.name + punctuation);
}

const person = { name: 'Charlie' };

introduce.call(person, "Hola", "!");  // Hola, soy Charlie!
introduce.apply(person, ["Hola", "."]); // Hola, soy Charlie.

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

Funciones flecha: No tienen su propio contexto this. Capturan this del ámbito léxico en el que fueron definidas.

const obj = {
  name: 'David',
  sayLater: function() {
    // `this` aquí hace referencia a `obj`
    setTimeout(() => {
      // `this` aquí también hace referencia a `obj` (heredado de `sayLater`)
      console.log("Luego, soy " + this.name);
    }, 1000);
  }
};

obj.sayLater(); // Luego, soy David

Habla sobre el contexto de las funciones en JavaScript.