Limits of Backbone.Model.previousAttributes for Rolling Back a Failed save()

Direct answers

1. previousAttributes() captures the state immediately before the most recent set() call, not the last successful save(). Each set() overwrites the snapshot, so multiple unsaved mutations collapse to a single step back.
2. Yes, a manual deep clone before save() is the only reliable way to restore nested objects and arrays. The built-in snapshot is shallow; nested references are shared with the current attributes.
3. Reapplying the snapshot with {silent: true} suppresses change and change:attribute events for that set() call. The model's internal state still updates; only event notification is skipped.

Why the snapshot is shallow and limited

In Backbone 1.x, the model keeps a single _previousAttributes object. On every model.set(attrs), the current attributes are shallow-copied into _previousAttributes before the new values are merged. Two consequences follow:

• After model.set({a: 1}); model.set({a: 2});, previousAttributes() returns {a: 1}, not the original state. There is no history stack, so you cannot walk back through several unsaved edits.
• If a nested value is mutated in place (for example model.get('items').push(3)) without calling set(), the snapshot is never refreshed, yet the nested array inside previousAttributes() is the same object reference, so it already reflects the mutation. The revert is silently incomplete.

Steps for a reliable silent rollback

1. Before calling model.save(), take a deep copy of the attributes:

   var snapshot = _.cloneDeep(model.attributes);
   // or, for plain JSON-safe data:
   // var snapshot = JSON.parse(JSON.stringify(model.attributes));

2. In the error handler, reapply the snapshot silently:

   model.set(snapshot, {silent: true});

3. If you also need model.hasChanged() to report false afterward, reset the changed hash:

   model.changed = {};

Verification

You can confirm each behavior in a console:

• Set an attribute twice and check that previousAttributes() only reflects the penultimate state.
• Mutate a nested array in place and observe that the snapshot's copy of that array changed too.
• Attach a change listener, then reapply the snapshot with {silent: true} and confirm the listener never fires.

One caveat: JSON.parse(JSON.stringify(...)) drops functions, Date objects become strings, and circular structures throw, so prefer _.cloneDeep when attributes contain non-JSON values.