如何在不占用return的情况下通过module.exports导出函数内变量？

Hey there! Let's break down what's going on with that weird { [Function] variableToPass: null } output and walk through better ways to share your variable between files.

First, why are you seeing that output? #

That console log usually happens for one of two reasons:

1. You attached the variable to your function object instead of exporting it as a standalone value, and the variable hasn't been assigned a real value yet when you import it. For example, if you wrote something like this in FileA:

   function myTargetFunction() {
     // Already using return for another value
     return "original return value";
   }
   // Attach variable to the function
   myTargetFunction.variableToPass = null;
   
   // If you assign the variable later (especially asynchronously)
   setTimeout(() => {
     myTargetFunction.variableToPass = "the value I want";
   }, 1000);
   
   module.exports = myTargetFunction;
   

   When you import myTargetFunction in FileB right away, the variable is still null because the assignment hasn't run yet.

2. You tried to use a "global" variable but it's not actually being initialized before import. If you declared the variable inside the function (like window.variableToPass in the browser) but the function hasn't executed yet, the variable will stay null.

Better, more maintainable solutions #

Forget messy global variables—let's use proper JavaScript modular patterns to share state cleanly.

Option 1: Export an object with your function and variable

This is the most straightforward modular approach. Wrap your function and shared variable in an exported object, so you can access both without relying on global scope.

FileA.js:

// Initialize your variable at the module level
let variableToPass = null;

function myTargetFunction() {
  // Update the variable as part of your function logic
  variableToPass = "updated value from function";
  // Keep your original return value
  return "original return value";
}

// Export both the function and a way to access the variable
module.exports = {
  myTargetFunction,
  // Use a getter to avoid accidental direct modification (optional but safer)
  getSharedVariable: () => variableToPass
};

FileB.js:

const { myTargetFunction, getSharedVariable } = require('./FileA');

// First run the function to update the variable
myTargetFunction();
// Then access the updated value
console.log(getSharedVariable()); // Output: "updated value from function"

If your function uses async logic (like API calls), just add async/await:

// FileA.js
async function myTargetFunction() {
  const apiData = await fetch('https://example.com/data');
  variableToPass = apiData.someValue;
  return "original return value";
}

// FileB.js
async function useSharedVariable() {
  await myTargetFunction();
  console.log(getSharedVariable());
}
useSharedVariable();

Option 2: Use a shared state object

For basic value sharing, wrap your variable in an object (since objects are passed by reference in JS) so updates in FileA reflect in FileB instantly.

FileA.js:

const sharedState = {
  variableToPass: null
};

function myTargetFunction() {
  sharedState.variableToPass = "new state value";
  return "original return value";
}

module.exports = { myTargetFunction, sharedState };

FileB.js:

const { myTargetFunction, sharedState } = require('./FileA');

myTargetFunction();
console.log(sharedState.variableToPass); // Output: "new state value"

Option 3: Use an event emitter (for frequent updates)

If your variable changes often and FileB needs to react to those changes, use an event emitter to notify listeners when the value updates.

FileA.js:

const EventEmitter = require('events');
const emitter = new EventEmitter();

let variableToPass = null;

function myTargetFunction() {
  const newValue = "updated value";
  variableToPass = newValue;
  // Emit an event to alert subscribers
  emitter.emit('variable-updated', newValue);
  return "original return value";
}

module.exports = { myTargetFunction, emitter, getSharedVariable: () => variableToPass };

FileB.js:

const { myTargetFunction, emitter } = require('./FileA');

// Listen for updates
emitter.on('variable-updated', (newValue) => {
  console.log("Variable changed to:", newValue);
});

myTargetFunction(); // Triggers the event, logs the new value

Why global variables are a bad idea here #

Global variables create hidden dependencies, lead to naming conflicts, and make debugging a nightmare in larger projects. The modular approaches above keep your code organized, testable, and easy to track.

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