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 = recursollama ax[Symbol.dispose]()al salir del bloque, también con errores,returnobreak.- Los recursos se liberan en orden inverso al de apertura.
await usingySymbol.asyncDisposepara limpiezas asíncronas.DisposableStack(yAsyncDisposableStack) junta limpiezas condefer,use,adoptymove.- Reemplaza los
try/finallyde limpieza, que eran fáciles de olvidar.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Liberar sin olvidarse
Resuelto
Elige una respuesta en cada pregunta.
¿Qué hace
using recurso = abrir()?Con dos
usingen el mismo bloque, ¿en qué orden se liberan?¿Para qué sirve
await using?¿Qué es un
DisposableStack?
Ordena la salida: Abrir y cerrar en orden
Resuelto
Dos recursos en un bloque. Ordena lo que aparecería en la consola.
1function recurso(nombre) {2 console.log("abre", nombre);3 return {4 [Symbol.dispose]() {5 console.log("cierra", nombre);6 },7 };8}9 10{11 using a = recurso("A");12 using b = recurso("B");13 console.log("trabajo");14}15console.log("después del bloque");Consola, de arriba abajo
- cierra B
- abre A
- después del bloque
- trabajo
- cierra A
- abre B
Los recursos se abren en orden, el bloque trabaja y, al salir, se liberan en orden inverso: primero B, después A. Todo antes de la línea siguiente al bloque.
Detective: Un recurso que no sabe liberarse
Resuelto
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 functionPaso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Una conexión que siempre se cierra
Resuelto
Escribe conectar(nombre): un recurso desechable que se cierra solo, aunque haya un error.
$ node programa.js
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)
Una solución
1function conectar(nombre) {2 console.log(`conecta ${nombre}`);3 return {4 consultar(sql) {5 console.log(`${nombre}: ${sql}`);6 },7 [Symbol.dispose]() {8 console.log(`desconecta ${nombre}`);9 },10 };11}12 13function trabajar() {14 using db = conectar("principal");15 db.consultar("SELECT 1");16 throw new Error("algo salió mal");17}18 19try {20 trabajar();21} catch (e) {22 console.log("error:", e.message);23}Aunque trabajar se interrumpe con un error, la conexión se cierra antes de que el error llegue al catch. Sin using, harías lo mismo con try/finally, y es fácil olvidarlo.