《Eloquent JavaScript》第一版异常清理代码的变量重置逻辑问询

Let’s start by restating the code for clarity:

var currentThing = null;
function processThing(thing) {
  var prevThing = currentThing;
  currentThing = thing;
  /* do complicated processing... */
  currentThing = prevThing;
}

What’s the logic behind currentThing = prevThing at the end? #

This line exists to restore the shared currentThing variable to its original state before the function ran. Here’s the full flow to put it in context:

1. First, we take a "snapshot" of currentThing’s value before we start processing the new thing, storing it in prevThing.
2. We update currentThing to the incoming thing—this makes the current item available to any code that relies on this shared variable during the complex processing step.
3. Once processing finishes (successfully or, with proper error handling, even if it fails), we reset currentThing back to the snapshot value we saved.

Why does this pattern matter? #

This is a defensive programming technique to avoid unintended side effects with shared state:

• currentThing is a shared variable (likely global or module-scoped) that other parts of your code might depend on. If we skipped resetting it, after processThing runs, currentThing would stay set to the last processed item. This could break other functions that expect it to be null (or its previous value).
• Tied directly to the "Cleaning up after Exceptions" section: This pattern is designed to work with try/finally blocks. If the complex processing throws an error, wrapping that code in a try and putting the currentThing = prevThing line in a finally guarantees the shared state is always restored—even when exceptions occur. This prevents your application from getting stuck in an inconsistent state after a failure.

In short, this ensures that calling processThing doesn’t leave lasting, unexpected changes to shared state that could break other parts of your program.

内容的提问来源于stack exchange，提问作者Osi