Saltar al contenido
Funciones

this: cómo se decide su valor

Lección 4 de 513 min4 ejercicios

this tiene fama de confuso, pero sigue una regla simple: no importa dónde se escribió la función, sino cómo se la llamó. La misma función puede tener un this distinto en cada llamada. Cuando lo ves así, casi todos los misterios desaparecen.

Qué mirar en el pizarrón

La misma función se llama tres veces de formas distintas. En cada marco de la pila, fíjate qué vale this y de qué parte de la llamada sale.

En el pizarrón

const usuario = {  nombre: "Ana",  saludar() {    return `Hola, soy ${this.nombre}`;  },}; console.log(usuario.saludar()); const suelta = usuario.saludar;console.log(suelta()); const atada = usuario.saludar.bind({ nombre: "Luis" });console.log(atada());

Pilacima

  1. saludar()this = usuario
Consola(vacía)

this no se decide al escribir la función, sino al llamarla. Aquí se llama como usuario.saludar(): lo que está antes del punto es this.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: this no se decide al escribir la función, sino al llamarla. Aquí se llama como usuario.saludar(): lo que está antes del punto es this. Pila: saludar().
  2. Paso 2: this.nombre es usuario.nombre: imprime Hola, soy Ana. Pila: vacía.
  3. Paso 3: suelta guarda la misma función, pero sola: el objeto no viaja con ella. Una función no "pertenece" al objeto donde se escribió. Pila: vacía.
  4. Paso 4: Llamada sin punto: no hay objeto, así que this es undefined. En modo estricto (módulos y clases), this.nombre lanzaría TypeError. Fuera de él, el motor pone en su lugar el objeto global, que no tiene nombre. Pila: suelta().
  5. Paso 5: Es el error más común con this: pasar un método suelto, como callback o desestructurado, y perder su objeto. Pila: vacía.
  6. Paso 6: bind crea una función nueva con this fijado para siempre, sin importar cómo se la llame después. Pila: vacía.
  7. Paso 7: Aunque se llama sin punto, atada ya trae su this: el objeto que se pasó a bind. Pila: atada().
  8. Paso 8: La misma función imprimió tres cosas distintas. La pregunta para saber qué es this nunca es "¿dónde se escribió?", sino "¿cómo se llamó?". Pila: vacía.

Para qué sirve this

this permite escribir un método que trabaje con distintos objetos. Dentro de la función, this es “el objeto con el que me llamaron”:

function describir() {
  return `${this.nombre} (${this.edad})`;
}

const ana = { nombre: "Ana", edad: 31, describir };
const luis = { nombre: "Luis", edad: 27, describir };

console.log(ana.describir());
console.log(luis.describir());

Es la misma función, guardada en dos objetos. Cada llamada usa los datos del objeto que la llamó.

Las reglas

Para saber qué vale this, mira la llamada, en este orden:

Cómo se llama this es
new Funcion() El objeto nuevo que se está creando (lo verás en Clases)
f.call(obj), f.apply(obj) o una función hecha con f.bind(obj) obj
objeto.metodo(), con punto objeto, lo que está antes del punto
f(), sin punto undefined en modo estricto; el objeto global fuera de él

El caso “sin punto” es el que da problemas: como muestra el pizarrón, sacar un método de su objeto lo deja sin this.

call, apply y bind

Las tres te dejan elegir this a mano:

function presentar(saludo, signo) {
  return `${saludo}, soy ${this.nombre}${signo}`;
}

const eva = { nombre: "Eva" };

console.log(presentar.call(eva, "Hola", "!"));     // this = eva, argumentos sueltos
console.log(presentar.apply(eva, ["Hola", "?"]));  // this = eva, argumentos en array

const presentarEva = presentar.bind(eva);           // función nueva, this fijado
console.log(presentarEva("Buenas", "."));

bind es el más usado: sirve para pasar un método como callback sin que pierda su objeto.

Las flechas no tienen this propio

Una función flecha no tiene this: usa el del lugar donde fue escrita, igual que usaría cualquier variable de afuera (scope léxico). Eso las hace perfectas para callbacks dentro de métodos:

const curso = {
  titulo: "JavaScript",
  alumnos: ["Ana", "Luis"],
  listar() {
    // la flecha usa el this de listar(), que es curso
    return this.alumnos.map((a) => `${a} estudia ${this.titulo}`);
  },
};

console.log(curso.listar());

Y por lo mismo, malas como métodos: una flecha escrita directamente en el objeto toma el this de afuera del objeto, no el objeto.

const mal = {
  nombre: "Ana",
  saludar: () => `Hola, ${this?.nombre}`,  // this NO es mal
};

console.log(mal.saludar());

Perder this en un callback

El error más común aparece al pasar un método como callback: la función que lo recibe lo llama sin punto.

const reloj = {
  segundos: 0,
  avanzar() {
    this.segundos++;
    return this.segundos;
  },
};

const pasos = [1, 2, 3];

// pasos.forEach(reloj.avanzar);           // forEach lo llama sin punto: pierde this
pasos.forEach(() => reloj.avanzar());      // solución 1: una flecha que lo llama con punto
pasos.forEach(reloj.avanzar.bind(reloj));  // solución 2: bind

console.log(reloj.segundos);

Resumen

  • this se decide al llamar la función, no al escribirla.
  • Con punto, this es el objeto antes del punto. Sin punto, undefined (modo estricto) o el objeto global.
  • call y apply eligen this para una llamada; bind crea una función con this fijado.
  • Las flechas no tienen this propio: usan el de su entorno.
  • Métodos con sintaxis normal; callbacks dentro de ellos, con flechas.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: ¿Quién es this?

Elige una respuesta en cada pregunta.

  1. En tienda.abrir(), ¿qué es this dentro de abrir?

  2. const f = tienda.abrir; f(); En modo estricto, ¿qué es this?

  3. ¿Qué this tiene una función flecha?

  4. ¿Qué diferencia hay entre call y bind?

Ordena la salida: call, apply y bind

La misma función con call, apply y bind. Ojo con la última línea. Ordena lo que aparecería en la consola.

function presentar(saludo) {  return `${saludo}, soy ${this.nombre}`;} const ana = { nombre: "Ana" };const luis = { nombre: "Luis" }; console.log(presentar.call(ana, "Hola"));console.log(presentar.apply(luis, ["Buenas"])); const deEva = presentar.bind({ nombre: "Eva" });console.log(deEva("Hey"));console.log(deEva.call(ana, "Hola"));

Consola, de arriba abajo

  1. Hola, soy Eva
  2. Buenas, soy Luis
  3. Hola, soy Ana
  4. Hey, soy Eva

Detective: Un método desestructurado

El error salta dentro del método, pero el problema está en cómo se lo llama. Encuentra la línea y elige el arreglo.

Consola

tienda.js:5
    return `Bienvenido a ${this.nombre}`;
                                 ^

TypeError: Cannot read properties of undefined (reading 'nombre')

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un callback que pierde this

El contador debería terminar en 6, pero se queda en 0. Arregla el callback para que no pierda this.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 6 (pendiente)
  • Sigue sumando bien: sumarVarios([4]) deja el valor en 10 (pendiente)
  • El callback de forEach es una flecha (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.