避免重复执行函数：选择process.env还是全局变量？

Great question—this is a super common optimization scenario when dealing with static, expensive-to-load values in Node.js/Express apps. Let’s break down your options and walk through the best practices here:

Why Global Variables and process.env Aren’t Ideal #

• Global Variables: While the risk of accidental overwriting might be low, using the global object (like global) goes against Node.js’s modular design principles. It creates implicit dependencies across your codebase—other modules won’t know where this value comes from, making debugging and maintenance harder down the line. Plus, in a clustered or multi-worker setup, global variables aren’t shared across workers, which could lead to inconsistencies.
• process.env: This is meant for environment-specific configuration values (like API keys, database credentials) that are set at deployment time, not values fetched from a database at runtime. Shoving your decrypted string into process.env would confuse future developers, as they’d expect those values to come from .env files or system environment variables, not a database query.

The Best Approach: Initialize Once, Share via Module Exports #

The cleanest, most maintainable solution is to load and decrypt your value once during app startup, then expose it through a module that other parts of your app can import. This ensures you only make one database roundtrip and run the decryption logic once, while keeping dependencies explicit and code organized.

Step 1: Create a Dedicated Initialization Module #

Make a module (e.g., decryptedConfig.js) that handles the database query, decryption, and returns the static value:

const mysql = require('mysql2/promise');
const crypto = require('crypto');

// Async function to load and decrypt the value
async function getDecryptedString() {
  // 1. Connect to your database (use your existing config here)
  const connection = await mysql.createConnection({
    host: process.env.DB_HOST,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME
  });

  // 2. Fetch the encrypted buffer from MySQL
  const [rows] = await connection.execute(
    'SELECT encrypted_buffer FROM your_table WHERE id = ?',
    [YOUR_RECORD_ID] // Replace with your actual record identifier
  );
  await connection.end();

  if (!rows[0]?.encrypted_buffer) {
    throw new Error('Encrypted buffer not found in database');
  }

  // 3. Run your decryption logic (replace with your actual method)
  const decrypted = crypto
    .createDecipheriv(
      'aes-256-cbc',
      Buffer.from(process.env.DECRYPTION_KEY, 'hex'),
      Buffer.from(process.env.DECRYPTION_IV, 'hex')
    )
    .update(rows[0].encrypted_buffer)
    .final('utf8');

  return decrypted;
}

// Execute the function once and export the promise (or resolved value)
module.exports = getDecryptedString();

Step 2: Use the Value in Your Express App #

In your main app.js (or wherever you start your server), wait for the initialization to complete before starting your server. You can also attach it to app.locals to make it accessible in all routes:

const express = require('express');
const decryptedStringPromise = require('./decryptedConfig');

const app = express();

// Wait for the decrypted value to load before starting the server
decryptedStringPromise
  .then((decryptedString) => {
    // Make the value available to all routes via app.locals
    app.locals.decryptedString = decryptedString;

    // Example route using the value
    app.get('/', (req, res) => {
      res.send(`Decrypted value: ${req.app.locals.decryptedString}`);
    });

    // Start the server only after initialization succeeds
    app.listen(3000, () => {
      console.log('Server running on http://localhost:3000');
    });
  })
  .catch((err) => {
    console.error('Failed to load decrypted value:', err);
    process.exit(1); // Exit if initialization fails—no point running the app without this value
  });

Bonus: Make the Value Read-Only #

To prevent accidental modification of the static string, wrap it in Object.freeze() when exporting:

const decryptedString = await getDecryptedString();
module.exports = Object.freeze(decryptedString);

Key Advantages of This Approach #

• Performance: Only one database query and decryption run during startup—no repeated overhead.
• Maintainability: Dependencies are explicit; other modules know exactly where the value comes from.
• Reliability: If the initialization fails (e.g., database down, invalid encrypted data), the app exits immediately instead of running in a broken state.
• Scalability: Works seamlessly in clustered setups (each worker will run the initialization once, which is standard for Node.js apps).

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