修改函数内部的JavaScript对象，出错返回原样

Question

I've got a JavaScript object in JSON format that needs to be modified based of a set input (delete foo or add bar, etc). This input can have cascading effects (delete foo might require foobar to be deleted first, based on a set of rules). If half way through a cascade something breaks I don't want the JavaScript object with half the modifications, I want to go back to the original unmodified object.

I could obviously just send a copy of the object into the modification function then not replace the original if the function returns an error. The issue with this is that the JavaScript object is around 25 megabytes, so a copy of it would mean a significant increase in memory usage by the browser. So I would like to do this without creating a copy of the object. I can just have the initial object be an input to the function and modify it recursively, but then if there is an error after some calls it could return a modified object when I don't want it to.

Would there be a way to do what I am trying to do? Keep track of the changes and easily undo them after an error, or something? Thanks.

Answer 1

It is possible to create a transaction array that records each change made to the object and records enough data about the change such that it can be undone. This is not a trivial amount of work to do. It is somewhat similar to the undo capabilities in a word processor or spreadsheet for example. If you record the right level of information and keep it in order in an array, it should be possible to reverse all the changes. This is not rocket science, but it is a bit of code to write and test.

As mentioned in a comment, the larger question raised here is about a single 25MB object that has to be operated on by one function. I'd personally wonder if you can break up the data into smaller pieces and be able to use smaller copies of things in order to not have to write this whole undo operation.

Also, it's worth considering whether you can pre-flight enough of the operations to know ahead of time whether the code will fail before you've modified the object or not. For example, I've used code before that runs all the same logic as the code that modifies the object, but it doesn't actually modify the object. This allows you to run a pre-flight of the entire operation and thus find out if anything fails some check before you've actually modified the object. Written appropriately, you can use the same code for pre-flight as for actual modification with just an extra flag passed in. How feasible this is depends upon the exact nature of the modification operation, something you haven't disclosed.

Here's an example of such code that handles changes to a specific object property. This could be extended to include array manipulations too.

Working demo: http://jsfiddle.net/jfriend00/ohqL0p06/

Code:

function TransactionSummary() {
    this.transactions = [];
}

TransactionSummary.prototype = {
    deleteProperty: function(parent, property) {
        this.rememberTransaction(parent, property, "delete", parent[property]);
        delete parent[property];
    },
    modifyProperty: function(parent, property, newVal) {
        this.rememberTransaction(parent, property, "modify", parent[property]);
        parent[property] = newVal;
    },
    addProperty: function(parent, property, newVal) {
        this.rememberTransaction(parent, property, "add");
        parent[property] = newVal;
    },
    rememberTransaction: function(parent, property, type, oldVal) {
        this.transactions.push({parent: parent, property: property, type: type, oldVal: oldVal});
    },
    undoTransactions: function() {
        var t;
        while (this.transactions.length) {
            t = this.transactions.pop();
            switch(t.type) {
                case "delete":
                case "modify":
                    t.parent[t.property] = t.oldVal;
                    break;
                case "add":
                    delete parent[property];
                    break;
            }
        }
    }
}