using

Want more browser support for this feature? Tell us why.

using const using nullundefined [Symbol.dispose]() [Symbol.dispose]()

using name1 = value1;
using name1 = value1, name2 = value2;
using name1 = value1, name2 = value2, /* , */ nameN = valueN;

nameN: JavaScript
valueN: nullundefined [Symbol.dispose]()

forfor...offor await...of

using null undefined

[Symbol.dispose] TypeError

using await using try...catch...finally finally 1 SuppressedError suppressed error SuppressedError

using DisposableStack

Resource getValue [Symbol.dispose]()

class Resource {
  value = Math.random();
  #isDisposed = false;

  getValue() {
    if (this.#isDisposed) {
      throw new Error("");
    }
    return this.value;
  }

  [Symbol.dispose]() {
    this.#isDisposed = true;
    console.log("");
  }
}

`using`

using

{
  using resource = new Resource();
  console.log(resource.getValue());
  // resource 
}

`using`

using

function example() {
  using resource = new Resource();
  return resource.getValue();
}

resource[Symbol.dispose]() getValue() return

function example() {
  using resource = new Resource();
  return () => resource.getValue();
}

example()() example getValue

function example() {
  const resource = new Resource();
  return () => {
    using resource2 = resource;
    return resource2.getValue();
  };
}

const using

`using`

using

using resource = new Resource();
export const value = resource.getValue();
//

export using using export

using resource = new Resource();
export { resource };

`using` `for...of`

for...of using

const resources = [new Resource(), new Resource(), new Resource()];
for (using resource of resources) {
  console.log(resource.getValue());
  // 
}

`using`

using resource1 = new Resource(),
  resource2 = new Resource();

// 

using resource1 = new Resource();
using resource2 = new Resource();

resource2 resource1 resource2 resource1 resource2 resource1

`using`

using null undefined

function acquireResource() {
  // 
  // 
  if (Math.random() < 0.5) {
    return null;
  }
  return new Resource();
}

const maybeResource = acquireResource();

if (maybeResource) {
  using resource = maybeResource;
  console.log(resource.getValue());
} else {
  console.log(undefined);
}

using resource = acquireResource();
console.log(resource?.getValue());

`using`

using

{
  using _ = new Lock();
  // 
  // 
}

_ _

using let const RAII

let useResource;
{
  useResource = () => resource.getValue();
  useResource(); // Error: Cannot access 'resource' before initialization
  using resource = new Resource();
  useResource(); // 
}
useResource(); // Error: Resource is disposed

using

function handleResource(resource) {
  if (resource.getValue() > 0.5) {
    throw new Error("");
  }
}

try {
  using resource = new Resource();
  handleResource(resource);
} catch (e) {
  console.error(e);
}

handleResource handleResource try

using

try {
  const resource = new Resource();
  handleResource(resource);
  resource[Symbol.dispose]();
} catch (e) {
  console.error(e);
}

handleResource() resource[Symbol.dispose]() 2

class CantDisposeMe {
  #name;
  constructor(name) {
    this.#name = name;
  }
  [Symbol.dispose]() {
    throw new Error(`${this.#name} `);
  }
}

let error;

try {
  using resource1 = new CantDisposeMe("resource1");
  using resource2 = new CantDisposeMe("resource2");
  throw new Error("");
} catch (e) {
  error = e;
}

SuppressedError: An error was suppressed during disposal
  suppressed: SuppressedError: An error was suppressed during disposal
    suppressed: Error: resource1 
    error: Error: 
  error: Error: resource2

error SuppressedError error suppressed


ECMAScript Async Explicit Resource Management # prod-UsingDeclaration

MDN

MDN 2026317

GitHub

using

using

using

using

using for...of

using

using

using

MDN

`using`

`using`

`using`

`using` `for...of`

`using`

`using`

`using`