JavaScript变量按引用传递机制及Mocha外部测试用例的变量传递疑问

Great question! Let’s break this down clearly, combining how JavaScript handles parameter passing with Mocha’s test execution flow.

First: JavaScript’s Core Parameter Passing Rule #

Let’s start with a critical clarification: JavaScript uses pass-by-value for all parameters, but there’s a key behavioral difference between primitive values and reference types:

• Primitive values (including null, a special primitive type): When you pass them as arguments, the function receives a copy of the value. Later changes to the original variable won’t affect this copy.
• Reference types (objects, arrays, etc.): When you pass them, the function receives a copy of the reference (the memory address pointing to the object in memory). The original variable and the function’s parameter both point to the same object—so modifying the object’s properties will be visible to all references pointing to it.

Why Method 1 Fails #

Let’s walk through the exact sequence of events in your first test setup:

1. You declare let response = null inside the describe block.
2. Mocha runs all code inside the describe block synchronously first—this means require('./externalTest.spec.js')(response) executes immediately, long before the before hook runs. At this moment, response is still null.
3. You’re passing the primitive value null to the external function. This creates an independent copy of null in the function’s parameter.
4. Later, the before hook runs and assigns response = await endpointCall()—this changes what the response variable points to (now a response object), but it doesn’t alter the copy of null that was already passed to the external function. So when the external it block runs, it logs the original null copy.

Why Method 2 Works #

Now let’s look at the working approach:

1. You declare let data = {response: null}—this creates an object in memory, and data holds a reference to that object.
2. When you run require('./externalTest.spec.js')(data), you pass a copy of the data reference to the external function. Both the original data variable and the external function’s data parameter point to the same object in memory.
3. The before hook runs and updates data.response = await endpointCall()—this modifies a property of the existing object, not the data reference itself.
4. When the external it block runs, it accesses data.response on the same object that was updated by the before hook, so it sees the full response object.

Key Takeaways #

• Don’t mix up "passing a reference" with true "pass-by-reference"—JavaScript doesn’t support pass-by-reference. All arguments are passed by value, but reference types pass a copy of their memory address.
• Mocha’s describe block executes synchronously, so any require calls inside it run before hooks like before or test blocks like it.
• Wrapping your variable in an object creates a mutable container with a stable reference. Updating the container’s properties will be visible to all code holding that reference.

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