Saltar al contenido
Metaprogramación

Proxy y Reflect

Lección 3 de 413 min4 ejercicios

Un Proxy es un objeto que se pone delante de otro y decide qué pasa cada vez que alguien lo lee, lo escribe, le pregunta si tiene una propiedad o lo llama. Es la herramienta de metaprogramación más poderosa del lenguaje: con ella están hechas la reactividad de Vue, muchas librerías de validación y los "objetos mágicos" de algunos ORMs.

Qué mirar en el pizarrón

El proxy (#2) envuelve al objetivo (#1). Fíjate en qué operaciones pasan por una trampa y cuáles no, y en dónde termina guardado cada dato.

En el pizarrón

const objetivo = { nombre: "Ana" }; const proxy = new Proxy(objetivo, {  get(obj, prop) {    console.log(`leyendo ${prop}`);    return Reflect.get(obj, prop) ?? "(no existe)";  },  set(obj, prop, valor) {    if (prop === "edad" && valor < 0) throw new RangeError("edad inválida");    return Reflect.set(obj, prop, valor);  },}); console.log(proxy.nombre);proxy.edad = 31;console.log(proxy.ciudad);console.log(objetivo.edad);

Variables

  1. objetivo→ objeto #1
  2. objeto #1{ nombre: 'Ana' }
  3. proxy→ proxy #2
  4. proxy #2envuelve al #1 · trampas: get, set
Consola(vacía)

new Proxy crea un objeto que envuelve al objetivo. No copia nada: cada operación sobre el proxy pasa primero por el handler, el objeto con las trampas.

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

Ver todos los pasos en texto
  1. Paso 1: new Proxy crea un objeto que envuelve al objetivo. No copia nada: cada operación sobre el proxy pasa primero por el handler, el objeto con las trampas. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana' }, proxy → proxy #2, proxy #2 envuelve al #1 · trampas: get, set.
  2. Paso 2: Leer proxy.nombre no va directo al objeto: ejecuta la trampa get, que recibe el objetivo y el nombre de la propiedad. Lo primero que hace es avisar. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana' }, proxy → proxy #2, proxy #2 trampa get: prop = "nombre".
  3. Paso 3: Reflect.get hace la lectura normal en el objetivo. Lo que devuelve la trampa es lo que recibe quien leyó. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana' } ← Reflect.get, proxy → proxy #2, proxy #2 devuelve "Ana".
  4. Paso 4: Asignar pasa por la trampa set, que valida antes de guardar. 31 es válido: Reflect.set lo guarda en el objetivo y devuelve true. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana', edad: 31 }, proxy → proxy #2, proxy #2 trampa set: edad = 31 ✓.
  5. Paso 5: ciudad no existe: Reflect.get da undefined y la trampa lo cambia por un valor por defecto. Sin proxy, habrías leído undefined. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana', edad: 31 }, proxy → proxy #2, proxy #2 trampa get: "ciudad" no existe.
  6. Paso 6: Leer el objetivo directamente no pasa por ninguna trampa: no se imprime "leyendo". El proxy solo intercepta lo que se hace a través de él. Así funcionan la validación, los valores por defecto y la reactividad de librerías como Vue. Variables: objetivo → objeto #1, objeto #1 { nombre: 'Ana', edad: 31 }, proxy → proxy #2, proxy #2 no interviene.

Objetivo, handler y trampas

new Proxy(objetivo, handler) recibe el objeto que envuelve y un handler, un objeto con las trampas: una función por cada operación que quieras interceptar. Las que no defines, pasan directo al objetivo.

Trampa Intercepta
get(obj, prop, receptor) Leer: p.x, p[x]
set(obj, prop, valor, receptor) Escribir: p.x = 1
has(obj, prop) "x" in p
deleteProperty(obj, prop) delete p.x
ownKeys(obj) Object.keys(p), for...in
apply(fn, this, args) Llamar: p(1, 2) (si el objetivo es una función)
construct(Clase, args) new p()

Hay algunas más, una por cada operación interna del lenguaje.

Reflect: la operación normal

Reflect tiene un método por cada trampa, con los mismos argumentos, que hace lo que el lenguaje haría sin proxy. Así, la trampa agrega su comportamiento y delega el resto:

const registro = [];
const espiado = new Proxy({ a: 1 }, {
  get(obj, prop, receptor) {
    registro.push(`leyó ${String(prop)}`);
    return Reflect.get(obj, prop, receptor);
  },
  set(obj, prop, valor, receptor) {
    registro.push(`escribió ${String(prop)} = ${valor}`);
    return Reflect.set(obj, prop, valor, receptor);
  },
});

espiado.a;
espiado.b = 2;
console.log(registro);

Usa Reflect en lugar de obj[prop]: respeta los getters, los prototipos y los descriptores, y en set devuelve el booleano que la trampa tiene que devolver.

Usos reales

Validación:

function validado(objetivo, reglas) {
  return new Proxy(objetivo, {
    set(obj, prop, valor) {
      const regla = reglas[prop];
      if (regla && !regla(valor)) throw new TypeError(`Valor inválido para ${String(prop)}: ${valor}`);
      return Reflect.set(obj, prop, valor);
    },
  });
}

const usuario = validado({}, { edad: (v) => Number.isInteger(v) && v >= 0 });
usuario.edad = 31;
try {
  usuario.edad = -5;
} catch (e) {
  console.log(e.message);
}

Reactividad: avisar cada vez que algo cambia, que es como Vue actualiza la página.

function reactivo(objetivo, alCambiar) {
  return new Proxy(objetivo, {
    set(obj, prop, valor) {
      const antes = obj[prop];
      const ok = Reflect.set(obj, prop, valor);
      if (antes !== valor) alCambiar(prop, antes, valor);
      return ok;
    },
  });
}

const estado = reactivo({ contador: 0 }, (prop, antes, ahora) => console.log(`${prop}: ${antes} → ${ahora}`));
estado.contador++;
estado.contador++;

Interceptar funciones con apply:

const medido = new Proxy(Math.max, {
  apply(fn, thisArg, args) {
    console.log(`max llamado con ${args.length} argumentos`);
    return Reflect.apply(fn, thisArg, args);
  },
});

console.log(medido(3, 9, 4));

Límites

  • Invariantes: un proxy no puede mentir sobre ciertas cosas del objetivo. Si una propiedad no es configurable ni writable, la trampa get tiene que devolver su valor real, o se lanza un TypeError.
  • Identidad: el proxy y el objetivo son objetos distintos (proxy !== objetivo).
  • Campos privados y objetos nativos: los #campos de una clase y los datos internos de Map, Date o Set no se ven a través del proxy. Llamar proxy.get() sobre un Map envuelto falla, porque this es el proxy y no el Map.
  • Rendimiento: cada operación pasa por una función. En código que se ejecuta millones de veces, se nota.

Resumen

  • Un Proxy envuelve un objeto y sus trampas interceptan operaciones: get, set, has, deleteProperty, apply, construct…
  • Reflect hace la operación normal: úsalo dentro de las trampas para delegar.
  • La trampa set debe devolver true si la asignación funcionó.
  • Usos: validación, valores por defecto, registro, reactividad, índices negativos.
  • Límites: invariantes, identidad distinta, campos privados y nativos, rendimiento.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Interceptar operaciones

Elige una respuesta en cada pregunta.

  1. ¿Qué es un Proxy?

  2. ¿Qué trampa se ejecuta en proxy.nombre?

  3. ¿Para qué sirve Reflect?

  4. ¿Qué debe devolver la trampa set?

Ordena la salida: Índices negativos

Un array envuelto que entiende índices negativos. Ordena lo que aparecería en la consola.

const lista = new Proxy(["a", "b", "c"], {  get(arr, prop, receptor) {    const i = Number(prop);    if (Number.isInteger(i) && i < 0) return arr[arr.length + i];    return Reflect.get(arr, prop, receptor);  },}); console.log(lista[-1]);console.log(lista[0], lista.length);console.log(Array.isArray(lista));console.log("b" in lista, 5 in lista);

Consola, de arriba abajo

  1. true
  2. c
  3. false false
  4. a 3

Detective: Una trampa set que no avisa

La validación debería rechazar solo las edades negativas, pero rechaza todo. Encuentra la línea y elige el arreglo.

Consola

persona.js:9
persona.nombre = "Ana";
               ^

TypeError: 'set' on proxy: trap returned falsish for property 'nombre'

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

Laboratorio: Valores por defecto

Escribe conDefecto(obj, defecto) con un Proxy y Reflect.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime hello y ¿? (pendiente)
  • Respeta los valores que existen aunque sean falsy (pendiente)
  • Usa new Proxy y Reflect (pendiente)

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