当前位置：首页 > JavaScript

js实现事务

2026-04-06 14:20:49JavaScript

实现事务的基本概念

在JavaScript中实现事务通常指确保一系列操作要么全部成功，要么全部失败回滚。这与数据库事务类似，但需要手动模拟。

使用函数封装事务逻辑

将需要事务化的操作封装到一个函数中，在函数内部处理错误和回滚逻辑。如果任何一步失败，就执行回滚操作。

function transaction(operations) {
  let completed = [];
  try {
    for (let op of operations) {
      const result = op.execute();
      completed.push(op);
      if (op.shouldRollback(result)) {
        throw new Error('Operation failed');
      }
    }
  } catch (error) {
    for (let op of completed.reverse()) {
      op.rollback();
    }
    throw error;
  }
}

使用Proxy实现对象事务

通过Proxy对象可以拦截属性访问和修改，记录原始值以便回滚。

function createTransactionalObject(target) {
  const changes = new Map();

  return new Proxy(target, {
    set(target, property, value) {
      if (!changes.has(property)) {
        changes.set(property, target[property]);
      }
      target[property] = value;
      return true;
    },
    commit() {
      changes.clear();
    },
    rollback() {
      for (const [property, value] of changes) {
        target[property] = value;
      }
      changes.clear();
    }
  });
}

使用数据库事务API

如果使用IndexedDB等浏览器数据库，可以直接使用其事务API。

const request = indexedDB.open('myDB', 1);
request.onsuccess = function(event) {
  const db = event.target.result;
  const transaction = db.transaction(['storeName'], 'readwrite');
  const store = transaction.objectStore('storeName');

  transaction.oncomplete = function() {
    console.log('Transaction completed');
  };

  transaction.onerror = function() {
    console.log('Transaction failed');
  };

  store.put({id: 1, value: 'data'});
};

实现异步事务

对于异步操作，可以使用Promise链式调用和catch处理回滚。

async function asyncTransaction(operations) {
  const completed = [];
  try {
    for (const op of operations) {
      const result = await op.execute();
      completed.push(op);
      if (op.shouldRollback(result)) {
        throw new Error('Operation failed');
      }
    }
  } catch (error) {
    for (const op of completed.reverse()) {
      await op.rollback();
    }
    throw error;
  }
}