¿De dónde proviene el contexto de la función en…

El contexto de ejecución (o this) en JavaScript se determina en el momento en que se llama a la función, no en el momento en que se declara. Los siguientes factores influyen en su valor:

Contexto global: Fuera de las funciones, this hace referencia al objeto global (en el navegador window, en Node.js global). En modo estricto ('use strict'), this en este caso será undefined.
```
// En el navegador
console.log(this); // window

// En Node.js
console.log(this); // global
```
Llamada a un método de un objeto: Si una función se llama como método de un objeto (a través del punto), this hace referencia a ese objeto.
```
const obj = {
  name: 'Obj',
  method: function() {
    console.log(this.name);
  }
};
obj.method(); // Obj
```
Llamada "normal" a una función: En una llamada simple a una función (no como método), this en modo no estricto hace referencia al objeto global. En modo estricto, this será undefined.
```
function greet() {
  console.log(this);
}
greet(); // window (en modo no estricto) o undefined (en modo estricto)
```
Constructor (con new): Cuando una función se llama con la palabra clave new, actúa como constructor. this dentro de la función hace referencia a la nueva instancia del objeto creada.
```
function Person(name) {
  this.name = name;
}
const person1 = new Person('Alice');
console.log(person1.name); // Alice
```
Métodos call, apply, bind: Estos métodos permiten establecer explícitamente el valor de this para una función.
- call y apply llaman a la función inmediatamente, pasando this como primer argumento. call acepta los demás argumentos por separado, mientras que apply los recibe en un array.
- bind devuelve una nueva función con this "atado" permanentemente al primer argumento pasado.
```
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
```

Funciones flecha: Las funciones flecha no tienen su propio this. "Capturan" el valor de this del entorno léxico en el que fueron declaradas. Esto las hace útiles para callbacks dentro de métodos o al trabajar con eventos del DOM.

const objWithArrow = {
  name: 'Arrow Obj',
  method() {
    const arrowFunc = () => {
      console.log(this.name); // `this` se toma del método (objWithArrow)
    };
    arrowFunc();
  }
};
objWithArrow.method(); // Arrow Obj

// Comparar con una función normal
const objWithRegular = {
  name: 'Regular Obj',
  method() {
    const regularFunc = function() {
      console.log(this); // `this` será window o undefined (dependiendo del modo strict) al llamar en este contexto
    };
    regularFunc();
  }
};
objWithRegular.method(); // window (o undefined)

La definición del contexto es una de las características clave de JavaScript, y comprender estas reglas es fundamental para trabajar correctamente con funciones y objetos.

¿De dónde proviene el contexto de la función en JavaScript?