Saltar al contenido
Biblioteca estándar

Gestión explícita de recursos: using

Lección 7 de 711 min4 ejercicios

Abrir un archivo, una conexión o una suscripción implica una promesa implícita: cerrarla cuando termines, también si algo falla en el medio. Hasta ahora eso se hacía a mano con try/finally, y era fácil olvidarlo. Con using, el lenguaje lo hace por ti al salir del bloque.

El problema

function abrir(nombre) {
  console.log("abre", nombre);
  return { cerrar: () => console.log("cierra", nombre) };
}

function procesar() {
  const archivo = abrir("datos.txt");
  try {
    console.log("procesando…");
    throw new Error("formato inválido");
  } finally {
    archivo.cerrar();   // hay que acordarse, en cada función
  }
}

try { procesar(); } catch (e) { console.log("error:", e.message); }

Funciona, pero con dos o tres recursos el código se llena de try/finally anidados, y basta un olvido para dejar algo abierto.

using

Un objeto desechable (disposable) tiene un método bajo la clave Symbol.dispose. Si lo declaras con using, ese método se llama automáticamente al salir del bloque, pase lo que pase:

function abrir(nombre) {
  console.log("abre", nombre);
  return {
    nombre,
    [Symbol.dispose]() {
      console.log("cierra", nombre);
    },
  };
}

function procesar() {
  using archivo = abrir("datos.txt");
  console.log("procesando", archivo.nombre);
  throw new Error("formato inválido");
}   // ← aquí se llama a archivo[Symbol.dispose](), aunque haya un error

try { procesar(); } catch (e) { console.log("error:", e.message); }

using declara una constante, como const, y solo se puede usar dentro de bloques, funciones y módulos.

Varios recursos

Con varios using, se liberan en orden inverso al de apertura, como una pila: lo que se abrió después puede depender de lo anterior.

const recurso = (n) => ({ [Symbol.dispose]: () => console.log("libera", n) });

{
  using conexion = recurso("conexión");
  using transaccion = recurso("transacción");
  console.log("trabajando");
}

Si el valor es null o undefined, using simplemente no hace nada al salir: útil para recursos opcionales.

await using

Muchas limpiezas son asíncronas: cerrar una conexión, vaciar datos a disco. Para eso está Symbol.asyncDispose, con await using, que espera a que termine la limpieza:

const esperar = (ms) => new Promise((r) => setTimeout(r, ms));

function conectar(nombre) {
  console.log("conecta", nombre);
  return {
    async [Symbol.asyncDispose]() {
      await esperar(20);
      console.log("desconectó", nombre, "(tardó 20 ms)");
    },
  };
}

async function tarea() {
  await using db = conectar("principal");
  console.log("consultando");
}

await tarea();
console.log("tarea terminada, conexión ya cerrada");

DisposableStack

DisposableStack junta varias limpiezas en un solo objeto desechable. Sirve cuando no sabes de antemano cuántos recursos vas a abrir, o para recursos que no tienen Symbol.dispose:

function prepararPantalla() {
  using pila = new DisposableStack();

  const intervalo = setInterval(() => {}, 1000);
  pila.defer(() => {
    clearInterval(intervalo);
    console.log("intervalo detenido");
  });

  const conexion = pila.use({ [Symbol.dispose]: () => console.log("conexión cerrada") });
  pila.adopt("suscripción", (s) => console.log(s, "cancelada"));

  console.log("pantalla lista");
  // Si algo fallara aquí, todo lo anterior se liberaría solo
  return pila.move();   // transfiere las limpiezas a quien llamó
}

{
  using limpieza = prepararPantalla();
  console.log("usando la pantalla");
}
  • defer(fn) agrega una función de limpieza.
  • use(recurso) agrega un objeto desechable y lo devuelve.
  • adopt(valor, fn) agrega un valor cualquiera con su función de limpieza.
  • move() pasa todo a una pila nueva, para que la función pueda devolver sus recursos sin liberarlos.

AsyncDisposableStack es la versión asíncrona, para await using.

Resumen

  • using x = recurso llama a x[Symbol.dispose]() al salir del bloque, también con errores, return o break.
  • Los recursos se liberan en orden inverso al de apertura.
  • await using y Symbol.asyncDispose para limpiezas asíncronas.
  • DisposableStack (y AsyncDisposableStack) junta limpiezas con defer, use, adopt y move.
  • Reemplaza los try/finally de limpieza, que eran fáciles de olvidar.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Liberar sin olvidarse

Elige una respuesta en cada pregunta.

  1. ¿Qué hace using recurso = abrir()?

  2. Con dos using en el mismo bloque, ¿en qué orden se liberan?

  3. ¿Para qué sirve await using?

  4. ¿Qué es un DisposableStack?

Ordena la salida: Abrir y cerrar en orden

Dos recursos en un bloque. Ordena lo que aparecería en la consola.

function recurso(nombre) {  console.log("abre", nombre);  return {    [Symbol.dispose]() {      console.log("cierra", nombre);    },  };} {  using a = recurso("A");  using b = recurso("B");  console.log("trabajo");}console.log("después del bloque");

Consola, de arriba abajo

  1. cierra B
  2. abre A
  3. después del bloque
  4. trabajo
  5. cierra A
  6. abre B

Detective: Un recurso que no sabe liberarse

El archivo tiene un método para cerrarse, pero using no lo encuentra. Encuentra la línea y elige el arreglo.

Consola

archivo.js:11
  using archivo = abrirArchivo("datos.txt");
        ^

TypeError: Symbol(Symbol.dispose) is not a function

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

Laboratorio: Una conexión que siempre se cierra

Escribe conectar(nombre): un recurso desechable que se cierra solo, aunque haya un error.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime la conexión, la consulta, la desconexión y después el error (pendiente)
  • El objeto implementa Symbol.dispose (pendiente)
  • Se desconecta también sin errores, al salir del bloque (pendiente)

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