JavaScript 的新超能力：显式资源管理

显式资源管理提案引入了一种确定性方法，用于显式管理文件句柄、网络连接等资源的生命周期。该提案为语言增加了以下内容：using 和 await using 声明，当资源退出作用域时会自动调用处置方法；[Symbol.dispose]() 和 [Symbol.asyncDispose]() 符号，用于清理操作。asyncDispose]() 符号；两个新的全局对象 DisposableStack 和 AsyncDisposableStack，作为聚合一次性资源的容器；SuppressedError，作为一种新的错误类型（既包含最近抛出的错误，也包含被抑制的错误），用于处理在资源处置过程中发生错误的情况，以及可能掩盖从主体或其他资源的处置中抛出的现有错误的情况。这些新增功能通过提供对资源处置的细粒度控制，使开发人员能够编写出更健壮、更高效、更易维护的代码。

`using` 和`await using`声明

显性资源管理提案的核心在于 using 和 await using声明。using 声明是为同步资源设计的，可确保在声明资源的作用域退出时调用可处置资源的 [Symbol.dispose]() 方法。对于异步资源，await using 声明的作用与此类似，但它能确保调用 [Symbol.asyncDispose]() 方法，并确保调用的结果与 [Symbol.asyncDispose]() 方法的结果一致。元素周期表

let responsePromise = null;

async function readFile(url) {  
    if (!responsePromise) {
        // Only fetch if we don't have a promise yet
        responsePromise = fetch(url);
    }
    const response = await responsePromise;
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const processedData = await processData(response);

    // Do something with processedData
    ...
 }

async function processData(response) {
    const reader = response.body.getReader();
    let done = false;
    let value;
    let processedData;
    
    while (!done) {
        ({ done, value } = await reader.read());
        if (value) {
            // Process data and save the result in processedData
            ...
            // An error is thrown here!
        }
    }
    
    // Because the error is thrown before this line, the stream remains locked.
    reader.releaseLock(); 

    return processedData;
  }
 
 readFile('https://example.com/largefile.dat');

因此，在使用流时，开发人员必须使用 try...finally 块，并将 reader.releaseLock() 放在 finally 中。这种模式可以确保 reader.releaseLock() 始终被调用。

async function processData(response) {
    const reader = response.body.getReader();
    let done = false;
    let value;
    let processedData;
    
    try {
        while (!done) {
            ({ done, value } = await reader.read());
            if (value) {
                // Process data and save the result in processedData
                ...
                // An error is thrown here!
            }
        }
    } finally {
        // The reader's lock on the stream will be always released.
        reader.releaseLock();
    }

    return processedData;
  }
 
 readFile('https://example.com/largefile.dat');

编写此代码的另一种方法是创建一个一次性对象 readerResource，其中包含阅读器（response.body.getReader()）和调用 this.reader.releaseLock() 的 [Symbol.dispose]() 方法。using 声明可确保在代码块退出时调用 readerResource[Symbol.dispose]()，而且不再需要记住调用 releaseLock，因为 using 声明会处理它。将来可能会在流等网络 API 中集成 [Symbol.dispose] 和 [Symbol.asyncDispose]，这样开发人员就不必手动编写封装对象了。

 async function processData(response) {
    const reader = response.body.getReader();
    let done = false;
    let value;

    // Wrap the reader in a disposable resource
    using readerResource = {
        reader: response.body.getReader(),
        [Symbol.dispose]() {
            this.reader.releaseLock();
        },
    };
    const { reader } = readerResource;

    let done = false;
    let value;
    let processedData;
    while (!done) {
        ({ done, value } = await reader.read());
        if (value) {
            // Process data and save the result in processedData
            ...
            // An error is thrown here!
        }
    }
    return processedData;
  }
 // readerResource[Symbol.dispose]() is called automatically.

 readFile('https://example.com/largefile.dat');

`DisposableStack` 和 `AsyncDisposableStack`

为了进一步方便管理多个一次性资源，该提案引入了 DisposableStack 和 AsyncDisposableStack。这些基于堆栈的结构允许开发人员以协调的方式分组和处置多个资源。资源被添加到堆栈中，当同步或异步处置堆栈时，资源将按照添加时的相反顺序进行处置，以确保正确处理它们之间的任何依赖关系。这简化了处理涉及多个相关资源的复杂情况时的清理过程。这两种结构都提供了用于添加资源或处置操作的 use()、adopt() 和 defer() 等方法，以及用于触发清理的 dispose() 或 asyncDispose() 方法。DisposableStack 和 AsyncDisposableStack 分别具有 [Symbol.dispose]() 和 [Symbol.asyncDispose]()，因此它们可以与 using 和 await using 关键字一起使用。它们为在定义的作用域内管理多个资源的处置提供了一种健壮的方法。

让我们看看每种方法并举例说明：

use(value) 将一个资源添加到栈顶。

{
    const readerResource = {
        reader: response.body.getReader(),
        [Symbol.dispose]() {
            this.reader.releaseLock();
            console.log('Reader lock released.');
        },
    };
    using stack = new DisposableStack();
    stack.use(readerResource);
}
// Reader lock released.

adopt(value,onDispose)会将一个不可丢弃的资源和一个丢弃回调添加到堆栈顶部。

{
    using stack = new DisposableStack();
    stack.adopt(
      response.body.getReader(), reader = > {
        reader.releaseLock();
        console.log('Reader lock released.');
      });
}
// Reader lock released.

defer(onDispose) 会在堆栈顶部添加一个处置回调。这对于添加没有关联资源的清理操作非常有用。

{
    using stack = new DisposableStack();
    stack.defer(() => console.log("done."));
}
// done.

move() 会将当前堆栈中的所有资源移动到一个新的 DisposableStack 中。如果需要将资源的所有权转移到代码的另一部分，这将非常有用。

{
    using stack = new DisposableStack();
    stack.adopt(
      response.body.getReader(), reader = > {
        reader.releaseLock();
        console.log('Reader lock released.');
      });
    using newStack = stack.move();
}
// Here just the newStack exists and the resource inside it will be disposed.
// Reader lock released.

DisposableStack 中的 dispose() 和 AsyncDisposableStack 中的 asyncDispose() 用来处置该对象中的资源。

{
    const readerResource = {
        reader: response.body.getReader(),
        [Symbol.dispose]() {
            this.reader.releaseLock();
            console.log('Reader lock released.');
        },
    };
    let stack = new DisposableStack();
    stack.use(readerResource);
    stack.dispose();
}
// Reader lock released.

可用性

明确资源管理已在 Chromium 134 和 V8 v13.8 中发布。

阅读余下内容

javascript| 2025-05-20