자바스크립트 명시적 리소스 관리: `using` 및 `await using` 마스터하기

            function readFileContent(filePath) {
  let fileHandle = null;
  try {
    fileHandle = openFile(filePath); // Assume openFile returns a resource handle
    const content = readFromFile(fileHandle);
    return content;
  } finally {
    if (fileHandle && typeof fileHandle.close === 'function') {
      fileHandle.close(); // Ensure the file is closed
    }
  }
}

            

              
                Copy
              
            
          

            class FileHandler {
  constructor(name) {
    this.name = name;
    console.log(`File \"${this.name}\" opened.`);
    this.isOpen = true;
  }

  read() {
    if (!this.isOpen) {
      throw new Error(`File \"${this.name}\" is already closed.`);
    }
    console.log(`Reading from file \"${this.name}\"...`);
    // Simulate reading content
    return `Content of ${this.name}`;
  }

  // The crucial cleanup method
  [Symbol.dispose]() {
    if (this.isOpen) {
      console.log(`Closing file \"${this.name}\"...`);
      this.isOpen = false;
      // Perform actual cleanup here, e.g., close file stream, release handle
    }
  }
}

// Example usage without 'using' (demonstrating the concept)
function processFileLegacy(filename) {
  let handler = null;
  try {
    handler = new FileHandler(filename);
    const data = handler.read();
    console.log(`Read data: ${data}`);
    return data;
  } finally {
    if (handler) {
      handler[Symbol.dispose]();
    }
  }
}

// processFileLegacy('example.txt');

            

              
                Copy
              
            
          

            {
  using resource = new DisposableResource();
  // ... use resource ...
}
// resource[Symbol.dispose]() is automatically called here

            

              
                Copy
              
            
          

            function processFileWithUsing(filename) {
  try {
    using file = new FileHandler(filename);
    const data = file.read();
    console.log(`Read data: ${data}`);
    return data;
  } catch (error) {
    console.error(`An error occurred: ${error.message}`);
    // FileHandler's [Symbol.dispose]() will still be called here
    throw error;
  }
}

// processFileWithUsing('another_example.txt');

            

              
                Copy
              
            
          

            function processMultipleFiles(file1Name, file2Name) {
  using file1 = new FileHandler(file1Name);
  using file2 = new FileHandler(file2Name);

  console.log(`Processing ${file1.name} and ${file2.name}`);
  const data1 = file1.read();
  const data2 = file2.read();
  console.log(`Read: ${data1}, ${data2}`);

  // When this block ends, file2[Symbol.dispose]() will be called first,
  // then file1[Symbol.dispose]() will be called.
}

// processMultipleFiles('input.txt', 'output.txt');

            

              
                Copy
              
            
          

            function createAndProcessFile(filename) {
  const handler = getFileHandler(filename); // Assume getFileHandler returns a disposable FileHandler
  {
    using disposableHandler = handler;
    const data = disposableHandler.read();
    console.log(`Processed: ${data}`);
  }
  // disposableHandler[Symbol.dispose]() called here
}

// createAndProcessFile('config.json');

            

              
                Copy
              
            
          

            class AsyncFileHandler {
  constructor(name) {
    this.name = name;
    console.log(`Async file \"${this.name}\" opened.`);
    this.isOpen = true;
  }

  async readAsync() {
    if (!this.isOpen) {
      throw new Error(`Async file \"${this.name}\" is already closed.`);
    }
    console.log(`Async reading from file \"${this.name}\"...`);
    // Simulate asynchronous reading
    await new Promise(resolve => setTimeout(resolve, 50));
    return `Async content of ${this.name}`;
  }

  // The crucial asynchronous cleanup method
  async [Symbol.asyncDispose]() {
    if (this.isOpen) {
      console.log(`Async closing file \"${this.name}\"...`);
      this.isOpen = false;
      // Simulate an asynchronous cleanup operation, e.g., flushing buffers
      await new Promise(resolve => setTimeout(resolve, 100));
      console.log(`Async file \"${this.name}\" fully closed.`);
    }
  }
}

// Example usage without 'await using'
async function processFileAsyncLegacy(filename) {
  let handler = null;
  try {
    handler = new AsyncFileHandler(filename);
    const content = await handler.readAsync();
    console.log(`Async read data: ${content}`);
    return content;
  } finally {
    if (handler) {
      // Need to await the async dispose if it's async
      if (typeof handler[Symbol.asyncDispose] === 'function') {
        await handler[Symbol.asyncDispose]();
      } else if (typeof handler[Symbol.dispose] === 'function') {
        handler[Symbol.dispose]();
      }
    }
  }
}

// processFileAsyncLegacy('async_example.txt');

            

              
                Copy
              
            
          

            async function processFileWithAwaitUsing(filename) {
  try {
    await using file = new AsyncFileHandler(filename);
    const data = await file.readAsync();
    console.log(`Async read data: ${data}`);
    return data;
  } catch (error) {
    console.error(`An async error occurred: ${error.message}`);
    // AsyncFileHandler's [Symbol.asyncDispose]() will still be awaited here
    throw error;
  }
}

// Example of calling the async function:
// processFileWithAwaitUsing('another_async_example.txt').catch(console.error);

            

              
                Copy
              
            
          

            async function processMultipleAsyncFiles(file1Name, file2Name) {
  await using file1 = new AsyncFileHandler(file1Name);
  await using file2 = new AsyncFileHandler(file2Name);

  console.log(`Processing async ${file1.name} and ${file2.name}`);
  const data1 = await file1.readAsync();
  const data2 = await file2.readAsync();
  console.log(`Async read: ${data1}, ${data2}`);

  // When this block ends, file2[Symbol.asyncDispose]() will be awaited first,
  // then file1[Symbol.asyncDispose]() will be awaited.
}

// Example of calling the async function:
// processMultipleAsyncFiles('async_input.txt', 'async_output.txt').catch(console.error);

            

              
                Copy
              
            
          

            class SyncConfig {
  constructor(name) {
    this.name = name;
    console.log(`Sync config \"${this.name}\" loaded.`);
  }

  getSetting(key) {
    console.log(`Getting setting from ${this.name}`);
    return `value_for_${key}`;
  }

  [Symbol.dispose]() {
    console.log(`Disposing sync config \"${this.name}\"...`);
  }
}

class AsyncDatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    console.log(`Async DB connection to \"${this.connectionString}\" opened.`);
    this.isConnected = true;
  }

  async queryAsync(sql) {
    if (!this.isConnected) {
      throw new Error('Database connection is closed.');
    }
    console.log(`Executing query: ${sql}`);
    await new Promise(resolve => setTimeout(resolve, 70));
    return [{ id: 1, name: 'Sample Data' }];
  }

  async [Symbol.asyncDispose]() {
    if (this.isConnected) {
      console.log(`Closing async DB connection to \"${this.connectionString}\"...`);
      this.isConnected = false;
      await new Promise(resolve => setTimeout(resolve, 120));
      console.log('Async DB connection closed.');
    }
  }
}

async function manageMixedResources(configName, dbConnectionString) {
  try {
    using config = new SyncConfig(configName);
    await using dbConnection = new AsyncDatabaseConnection(dbConnectionString);

    const setting = config.getSetting('timeout');
    console.log(`Retrieved setting: ${setting}`);

    const results = await dbConnection.queryAsync('SELECT * FROM users');
    console.log('Query results:', results);

    // Order of disposal:
    // 1. dbConnection[Symbol.asyncDispose]() will be awaited.
    // 2. config[Symbol.dispose]() will be called.
  } catch (error) {
    console.error(`Error in mixed resource management: ${error.message}`);
    throw error;
  }
}

// Example of calling the async function:
// manageMixedResources('app_settings', 'postgresql://user:pass@host:port/db').catch(console.error);

            

              
                Copy