Node.js グローバルオブジェクトとその危険性

2025年6月20日

Node.js 開発において、グローバルオブジェクトは便利で強力な機能を提供する一方で、適切に理解せずに使用すると深刻な問題を引き起こす可能性があります。

多くの開発者が「とりあえず動く」コードを書く際に、グローバルオブジェクトを無意識に使用してしまいがちです。しかし、このような使い方は後々大きなトラブルの原因となることが少なくありません。

本記事では、Node.js のグローバルオブジェクトの基本的な仕組みから、それらが引き起こす具体的な問題、そして安全な使用方法まで、セキュリティと品質の観点から詳しく解説いたします。特に実際の開発現場で遭遇しやすい問題事例を交えながら、皆さんの Node.js 開発がより安全で保守性の高いものになるよう、実践的な知識をお伝えしていきます。

Node.js グローバルオブジェクトとは

Node.js には、どのモジュールからでもアクセス可能な「グローバルオブジェクト」が存在します。これらは Node.js ランタイムが提供する重要な機能群ですが、その強力さゆえに危険性も伴います。

主要なグローバルオブジェクト

Node.js で利用可能な主要なグローバルオブジェクトを整理してみましょう。

オブジェクト	用途	危険度
global	グローバルスコープへのアクセス	高
process	プロセス情報・制御	高
console	ログ出力	中
Buffer	バイナリデータ操作	中
setTimeout/setInterval	タイマー機能	中
dirname/filename	ファイルパス情報	低

グローバルオブジェクトの基本的な仕組み

javascript// グローバルオブジェクトの確認
console.log('利用可能なグローバルオブジェクト:');
console.log('- global:', typeof global);
console.log('- process:', typeof process);
console.log('- console:', typeof console);
console.log('- Buffer:', typeof Buffer);
console.log('- setTimeout:', typeof setTimeout);

Node.js では、これらのオブジェクトは明示的な import や require なしに使用できます。ブラウザ環境の window オブジェクトと同様の役割を果たしますが、サーバーサイド特有の機能が多く含まれています。

グローバルスコープとモジュールスコープの違い

javascript// app.js - メインファイル
console.log('グローバルスコープでの this:', this); // {}（空オブジェクト）
console.log('global オブジェクト:', global);

// グローバル変数の定義（危険な例）
global.appName = 'MyApplication';
global.version = '1.0.0';

// 別のモジュールから参照
require('./config.js');

javascript// config.js - 設定モジュール
console.log(
  '設定モジュールから appName にアクセス:',
  global.appName
);
console.log(
  '設定モジュールから version にアクセス:',
  global.version
);

// グローバル変数の変更（意図しない副作用の原因）
global.appName = 'ModifiedApp';

このような使い方は、モジュール間で意図しない依存関係を作り出し、デバッグが困難な問題を引き起こします。

各グローバルオブジェクトの詳細と危険性

global オブジェクトの汚染リスク

global オブジェクトは Node.js におけるグローバルスコープへの直接的なアクセス手段です。しかし、このオブジェクトを不適切に使用すると「グローバル汚染」という深刻な問題が発生します。

グローバル汚染の具体例

javascript// 問題のあるコード例
// utils.js
global._ = require('lodash'); // グローバルにライブラリを配置
global.config = {
  database: {
    host: 'localhost',
    port: 5432,
  },
};

// データベース接続用の関数をグローバルに配置
global.connectDB = function () {
  console.log(
    `Connecting to ${global.config.database.host}`
  );
};

javascript// main.js
require('./utils.js');

// 他のモジュールでグローバル変数を使用
console.log(_.isEmpty({})); // lodash をグローバルから使用
global.connectDB(); // グローバル関数を呼び出し

// 意図しない変更が他のモジュールに影響
global.config.database.host = 'production-server';

この例では、以下の問題が発生します：

依存関係の不透明性: どのモジュールがどの機能に依存しているかが分からない
テストの困難さ: グローバル状態のせいで単体テストが書きにくい
名前空間の衝突: 複数のライブラリが同じグローバル変数名を使用する可能性
予期しない副作用: 一つのモジュールでの変更が他のモジュールに影響

安全なグローバルオブジェクトの使用法

javascript// 改善されたコード例
// config.js - 設定は専用モジュールで管理
const config = {
  database: {
    host: process.env.DB_HOST || 'localhost',
    port: parseInt(process.env.DB_PORT) || 5432,
  },
};

module.exports = config;

javascript// database.js - データベース機能は専用モジュール
const config = require('./config');

function connectDB() {
  console.log(
    `Connecting to ${config.database.host}:${config.database.port}`
  );
  // 実際の接続処理
}

module.exports = { connectDB };

javascript// main.js - 明示的な依存関係
const { connectDB } = require('./database');
const _ = require('lodash');

console.log(_.isEmpty({}));
connectDB();

process オブジェクトの不適切な操作

process オブジェクトは Node.js プロセスに関する情報と制御機能を提供しますが、不適切な使用はアプリケーションの安定性とセキュリティに深刻な影響を与えます。

危険な process オブジェクトの使用例

javascript// 危険な例1: 無制限な環境変数アクセス
function getUserCredentials() {
  // 環境変数を直接参照（セキュリティリスク）
  return {
    username: process.env.DB_USER,
    password: process.env.DB_PASSWORD, // 平文パスワードの露出リスク
    apiKey: process.env.SECRET_API_KEY,
  };
}

// 危険な例2: プロセス終了の不適切な処理
function handleError(error) {
  console.error('エラーが発生しました:', error);
  process.exit(1); // 即座にプロセス終了（リソースリークの原因）
}

// 危険な例3: 無制限なメモリ使用量の設定
process.setMaxListeners(0); // 無制限にイベントリスナーを許可

process オブジェクトの安全な使用方法

javascript// 改善された例1: 環境変数の安全な管理
class ConfigManager {
  constructor() {
    this.validateRequiredEnvVars();
  }

  validateRequiredEnvVars() {
    const required = [
      'DB_USER',
      'DB_PASSWORD',
      'SECRET_API_KEY',
    ];
    const missing = required.filter(
      (key) => !process.env[key]
    );

    if (missing.length > 0) {
      throw new Error(
        `必須環境変数が設定されていません: ${missing.join(
          ', '
        )}`
      );
    }
  }

  getDatabaseConfig() {
    return {
      username: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      // パスワードはログに出力しない
      toString() {
        return `Database config for user: ${this.username}`;
      },
    };
  }

  getApiKey() {
    const key = process.env.SECRET_API_KEY;
    // API キーの一部のみを表示
    return {
      key,
      preview: key
        ? `${key.substring(0, 8)}...`
        : 'Not set',
    };
  }
}

javascript// 改善された例2: グレースフルシャットダウン
class GracefulShutdown {
  constructor() {
    this.isShuttingDown = false;
    this.setupSignalHandlers();
  }

  setupSignalHandlers() {
    // SIGTERM シグナルの処理
    process.on('SIGTERM', () => {
      console.log(
        'SIGTERM received, starting graceful shutdown...'
      );
      this.shutdown();
    });

    // SIGINT シグナルの処理（Ctrl+C）
    process.on('SIGINT', () => {
      console.log(
        'SIGINT received, starting graceful shutdown...'
      );
      this.shutdown();
    });

    // 未処理の例外をキャッチ
    process.on('uncaughtException', (error) => {
      console.error('Uncaught Exception:', error);
      this.shutdown(1);
    });

    // 未処理の Promise rejection をキャッチ
    process.on('unhandledRejection', (reason, promise) => {
      console.error(
        'Unhandled Rejection at:',
        promise,
        'reason:',
        reason
      );
      this.shutdown(1);
    });
  }

  async shutdown(exitCode = 0) {
    if (this.isShuttingDown) {
      return;
    }

    this.isShuttingDown = true;

    try {
      // データベース接続のクローズ
      await this.closeDatabase();

      // サーバーのクローズ
      await this.closeServer();

      // その他のリソースのクリーンアップ
      await this.cleanupResources();

      console.log('Graceful shutdown completed');
      process.exit(exitCode);
    } catch (error) {
      console.error('Error during shutdown:', error);
      process.exit(1);
    }
  }

  async closeDatabase() {
    // データベース接続のクローズ処理
    console.log('Closing database connections...');
    // 実装は使用するデータベースライブラリに依存
  }

  async closeServer() {
    // HTTP サーバーのクローズ処理
    console.log('Closing HTTP server...');
    // 実装は使用するサーバーライブラリに依存
  }

  async cleanupResources() {
    // その他のリソースクリーンアップ
    console.log('Cleaning up resources...');
  }
}

// 使用例
const gracefulShutdown = new GracefulShutdown();

Buffer やタイマー関数の落とし穴

Buffer オブジェクトのセキュリティリスク

Buffer は Node.js でバイナリデータを扱うための重要な機能ですが、不適切な使用はメモリリークやセキュリティ脆弱性を引き起こします。

javascript// 危険な Buffer の使用例
function unsafeBufferUsage() {
  // 危険1: 初期化されていないメモリ領域の使用
  const buffer1 = Buffer.allocUnsafe(1024); // メモリの内容が不定
  console.log(
    '初期化されていないバッファ:',
    buffer1.toString()
  );

  // 危険2: 大きなバッファの無制限作成
  const userInput = '1000000'; // ユーザー入力
  const size = parseInt(userInput);
  const buffer2 = Buffer.alloc(size); // DoS攻撃の可能性

  // 危険3: 文字列からバッファへの変換時の問題
  const sensitiveData = 'password123';
  const buffer3 = Buffer.from(sensitiveData);
  // バッファはガベージコレクションされるまでメモリに残る

  return { buffer1, buffer2, buffer3 };
}

javascript// 安全な Buffer の使用方法
class SafeBufferManager {
  constructor() {
    this.maxBufferSize = 1024 * 1024; // 1MB の制限
  }

  createSafeBuffer(size) {
    // サイズの検証
    if (typeof size !== 'number' || size < 0) {
      throw new Error(
        'バッファサイズは正の数値である必要があります'
      );
    }

    if (size > this.maxBufferSize) {
      throw new Error(
        `バッファサイズが制限値 ${this.maxBufferSize} を超えています`
      );
    }

    // 安全な初期化済みバッファを作成
    return Buffer.alloc(size);
  }

  secureStringToBuffer(str) {
    if (typeof str !== 'string') {
      throw new Error('文字列が必要です');
    }

    // 文字列の長さ制限
    if (str.length > 1000) {
      throw new Error('文字列が長すぎます');
    }

    const buffer = Buffer.from(str, 'utf8');

    // セキュリティ: 元の文字列をクリア
    str = null;

    return buffer;
  }

  clearBuffer(buffer) {
    // バッファの内容を安全にクリア
    if (Buffer.isBuffer(buffer)) {
      buffer.fill(0);
    }
  }

  // バッファの安全な比較
  safeCompare(buffer1, buffer2) {
    if (
      !Buffer.isBuffer(buffer1) ||
      !Buffer.isBuffer(buffer2)
    ) {
      return false;
    }

    // タイミング攻撃を防ぐための安全な比較
    return (
      buffer1.length === buffer2.length &&
      buffer1.equals(buffer2)
    );
  }
}

// 使用例
const bufferManager = new SafeBufferManager();

try {
  const safeBuffer = bufferManager.createSafeBuffer(512);
  const stringBuffer =
    bufferManager.secureStringToBuffer('Hello World');

  console.log('安全にバッファを作成しました');

  // 使用後はクリア
  bufferManager.clearBuffer(safeBuffer);
  bufferManager.clearBuffer(stringBuffer);
} catch (error) {
  console.error('バッファ操作エラー:', error.message);
}

タイマー関数のメモリリークリスク

setTimeout や setInterval の不適切な使用は、メモリリークや予期しない動作の原因となります。

javascript// 危険なタイマーの使用例
class ProblematicTimer {
  constructor() {
    this.data = new Array(10000).fill('large data');
    this.startProblematicTimers();
  }

  startProblematicTimers() {
    // 問題1: クリアされないタイマー
    setTimeout(() => {
      console.log('このタイマーはクリアされません');
      this.processData(); // メモリリークの原因
    }, 5000);

    // 問題2: 無限に実行されるインターバル
    setInterval(() => {
      console.log('無限に実行されるタイマー');
      this.data.push('more data'); // メモリ使用量が増加し続ける
    }, 1000);

    // 問題3: 例外処理がないタイマー
    setTimeout(() => {
      throw new Error('未処理のエラー'); // アプリケーションクラッシュの原因
    }, 3000);
  }

  processData() {
    // 大量のデータ処理
    console.log(`Processing ${this.data.length} items`);
  }
}

javascript// 安全なタイマーの使用方法
class SafeTimerManager {
  constructor() {
    this.timers = new Set(); // アクティブなタイマーを追跡
    this.intervals = new Set(); // アクティブなインターバルを追跡
    this.isDestroyed = false;
  }

  safeSetTimeout(callback, delay, ...args) {
    if (this.isDestroyed) {
      console.warn('TimerManager は既に破棄されています');
      return null;
    }

    const wrappedCallback = () => {
      try {
        if (!this.isDestroyed) {
          callback(...args);
        }
      } catch (error) {
        console.error(
          'タイマーコールバックでエラーが発生:',
          error
        );
      } finally {
        this.timers.delete(timerId);
      }
    };

    const timerId = setTimeout(wrappedCallback, delay);
    this.timers.add(timerId);

    return timerId;
  }

  safeSetInterval(callback, interval, ...args) {
    if (this.isDestroyed) {
      console.warn('TimerManager は既に破棄されています');
      return null;
    }

    const wrappedCallback = () => {
      try {
        if (!this.isDestroyed) {
          callback(...args);
        }
      } catch (error) {
        console.error(
          'インターバルコールバックでエラーが発生:',
          error
        );
        // エラーが発生した場合はインターバルを停止
        this.clearInterval(intervalId);
      }
    };

    const intervalId = setInterval(
      wrappedCallback,
      interval
    );
    this.intervals.add(intervalId);

    return intervalId;
  }

  clearTimeout(timerId) {
    if (timerId && this.timers.has(timerId)) {
      clearTimeout(timerId);
      this.timers.delete(timerId);
    }
  }

  clearInterval(intervalId) {
    if (intervalId && this.intervals.has(intervalId)) {
      clearInterval(intervalId);
      this.intervals.delete(intervalId);
    }
  }

  // 条件付きインターバル（自動停止機能付き）
  conditionalInterval(
    callback,
    interval,
    maxExecutions = Infinity
  ) {
    let executionCount = 0;

    const intervalId = this.safeSetInterval(() => {
      executionCount++;

      const shouldContinue = callback(executionCount);

      if (
        shouldContinue === false ||
        executionCount >= maxExecutions
      ) {
        this.clearInterval(intervalId);
      }
    }, interval);

    return intervalId;
  }

  // すべてのタイマーをクリア
  clearAll() {
    // すべてのタイムアウトをクリア
    for (const timerId of this.timers) {
      clearTimeout(timerId);
    }
    this.timers.clear();

    // すべてのインターバルをクリア
    for (const intervalId of this.intervals) {
      clearInterval(intervalId);
    }
    this.intervals.clear();
  }

  // リソースの完全な破棄
  destroy() {
    this.clearAll();
    this.isDestroyed = true;
  }

  // アクティブなタイマーの状態を取得
  getStatus() {
    return {
      activeTimeouts: this.timers.size,
      activeIntervals: this.intervals.size,
      isDestroyed: this.isDestroyed,
    };
  }
}

// 使用例
const timerManager = new SafeTimerManager();

// 安全なタイマーの使用
const timeoutId = timerManager.safeSetTimeout(() => {
  console.log('安全なタイムアウト実行');
}, 2000);

// 条件付きインターバル（最大5回実行）
const intervalId = timerManager.conditionalInterval(
  (count) => {
    console.log(`インターバル実行回数: ${count}`);
    return count < 5; // 5回で停止
  },
  1000,
  5
);

// プロセス終了時のクリーンアップ
process.on('SIGTERM', () => {
  console.log('アプリケーション終了中...');
  timerManager.destroy();
});

これらの安全な実装により、メモリリークや予期しない動作を防ぐことができます。特に長時間実行されるアプリケーションでは、適切なタイマー管理が重要になります。

実際の問題事例

メモリリークの実例

実際の開発現場で発生したグローバルオブジェクトに関連するメモリリークの事例をご紹介します。

事例 1: グローバルキャッシュによるメモリリーク

javascript// 問題のあるコード（実際のプロジェクトから抽出）
// cache.js
global.appCache = new Map();

function setCache(key, value) {
  global.appCache.set(key, value);
  console.log(`キャッシュサイズ: ${global.appCache.size}`);
}

function getCache(key) {
  return global.appCache.get(key);
}

// この実装では、キャッシュが無制限に成長し続ける
module.exports = { setCache, getCache };

javascript// api.js - API エンドポイント
const { setCache, getCache } = require('./cache');

app.get('/api/data/:id', async (req, res) => {
  const { id } = req.params;
  const cacheKey = `data_${id}`;

  let data = getCache(cacheKey);
  if (!data) {
    data = await fetchDataFromDatabase(id);
    setCache(cacheKey, data); // 永続的にキャッシュされる
  }

  res.json(data);
});

// 問題: ユーザーが異なるIDでアクセスするたびに
// キャッシュサイズが増加し、メモリリークが発生

問題の症状:

アプリケーション実行時間の経過とともにメモリ使用量が増加
最終的にサーバーがメモリ不足でクラッシュ
Docker コンテナの OOMKilled エラー

解決策:

javascript// 改善されたキャッシュ実装
class SafeCache {
  constructor(maxSize = 1000, ttl = 3600000) {
    // 1時間のTTL
    this.cache = new Map();
    this.maxSize = maxSize;
    this.ttl = ttl;
    this.timers = new Map();
  }

  set(key, value) {
    // 既存のタイマーをクリア
    if (this.timers.has(key)) {
      clearTimeout(this.timers.get(key));
    }

    // サイズ制限のチェック
    if (
      this.cache.size >= this.maxSize &&
      !this.cache.has(key)
    ) {
      // LRU: 最も古いエントリを削除
      const firstKey = this.cache.keys().next().value;
      this.delete(firstKey);
    }

    // 値を設定
    this.cache.set(key, {
      value,
      timestamp: Date.now(),
    });

    // TTL タイマーを設定
    const timer = setTimeout(() => {
      this.delete(key);
    }, this.ttl);

    this.timers.set(key, timer);
  }

  get(key) {
    const entry = this.cache.get(key);
    if (!entry) {
      return null;
    }

    // TTL チェック
    if (Date.now() > entry.timestamp + this.ttl) {
      this.delete(key);
      return null;
    }

    return entry.value;
  }

  delete(key) {
    if (this.timers.has(key)) {
      clearTimeout(this.timers.get(key));
      this.timers.delete(key);
    }
    return this.cache.delete(key);
  }

  clear() {
    for (const timer of this.timers.values()) {
      clearTimeout(timer);
    }
    this.timers.clear();
    this.cache.clear();
  }

  getStats() {
    return {
      size: this.cache.size,
      maxSize: this.maxSize,
      activeTimers: this.timers.size,
    };
  }
}

// 安全なキャッシュの使用
const appCache = new SafeCache(500, 1800000); // 500エントリ、30分TTL

module.exports = appCache;

事例 2: イベントリスナーの蓄積

javascript// 問題のあるコード
// websocket-handler.js
const WebSocket = require('ws');

class ProblematicWebSocketHandler {
  constructor() {
    this.connections = new Set();
    this.setupGlobalListeners();
  }

  setupGlobalListeners() {
    // 問題: グローバルイベントリスナーが蓄積される
    process.on('SIGTERM', () => {
      console.log('Shutting down...');
      this.closeAllConnections();
    });

    // 新しい接続のたびに同じリスナーが追加される
    global.emitter.on('broadcast', (message) => {
      this.broadcastToAll(message);
    });
  }

  handleConnection(ws) {
    this.connections.add(ws);

    // 各接続に対してリスナーを追加（蓄積される）
    ws.on('message', (data) => {
      this.handleMessage(ws, data);
    });

    ws.on('close', () => {
      this.connections.delete(ws);
    });
  }

  broadcastToAll(message) {
    for (const ws of this.connections) {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(message);
      }
    }
  }
}

// 問題: インスタンスを作成するたびにリスナーが追加される
const handler1 = new ProblematicWebSocketHandler();
const handler2 = new ProblematicWebSocketHandler(); // リスナーが重複

解決策:

javascript// 改善されたWebSocketハンドラー
class SafeWebSocketHandler {
  constructor() {
    this.connections = new Set();
    this.eventListeners = new Map();
    this.isDestroyed = false;
    this.setupEventListeners();
  }

  setupEventListeners() {
    // シングルトンパターンでリスナーの重複を防ぐ
    if (!SafeWebSocketHandler.globalListenersSetup) {
      const shutdownHandler = () => {
        console.log('Shutting down WebSocket handlers...');
        SafeWebSocketHandler.instances.forEach(
          (instance) => {
            instance.destroy();
          }
        );
      };

      process.once('SIGTERM', shutdownHandler);
      process.once('SIGINT', shutdownHandler);

      SafeWebSocketHandler.globalListenersSetup = true;
    }

    // インスタンス固有のリスナー
    const broadcastHandler = (message) => {
      if (!this.isDestroyed) {
        this.broadcastToAll(message);
      }
    };

    global.emitter.on('broadcast', broadcastHandler);
    this.eventListeners.set('broadcast', broadcastHandler);

    // インスタンスを追跡
    SafeWebSocketHandler.instances.add(this);
  }

  handleConnection(ws) {
    if (this.isDestroyed) {
      ws.close();
      return;
    }

    this.connections.add(ws);

    const messageHandler = (data) => {
      if (!this.isDestroyed) {
        this.handleMessage(ws, data);
      }
    };

    const closeHandler = () => {
      this.connections.delete(ws);
      ws.removeListener('message', messageHandler);
      ws.removeListener('close', closeHandler);
    };

    ws.on('message', messageHandler);
    ws.on('close', closeHandler);

    // 接続タイムアウトの設定
    const timeout = setTimeout(() => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.close();
      }
    }, 300000); // 5分

    ws.on('close', () => clearTimeout(timeout));
  }

  broadcastToAll(message) {
    const deadConnections = [];

    for (const ws of this.connections) {
      try {
        if (ws.readyState === WebSocket.OPEN) {
          ws.send(message);
        } else {
          deadConnections.push(ws);
        }
      } catch (error) {
        console.error('Broadcast error:', error);
        deadConnections.push(ws);
      }
    }

    // 無効な接続を削除
    deadConnections.forEach((ws) =>
      this.connections.delete(ws)
    );
  }

  destroy() {
    if (this.isDestroyed) {
      return;
    }

    this.isDestroyed = true;

    // すべての接続を閉じる
    for (const ws of this.connections) {
      try {
        ws.close();
      } catch (error) {
        console.error('Error closing WebSocket:', error);
      }
    }
    this.connections.clear();

    // イベントリスナーを削除
    for (const [event, handler] of this.eventListeners) {
      global.emitter.removeListener(event, handler);
    }
    this.eventListeners.clear();

    // インスタンス追跡から削除
    SafeWebSocketHandler.instances.delete(this);
  }

  getStats() {
    return {
      activeConnections: this.connections.size,
      activeListeners: this.eventListeners.size,
      isDestroyed: this.isDestroyed,
    };
  }
}

// 静的プロパティの初期化
SafeWebSocketHandler.instances = new Set();
SafeWebSocketHandler.globalListenersSetup = false;

module.exports = SafeWebSocketHandler;

予期しない動作の事例

事例 3: グローバル状態の競合

javascript// 問題のあるコード - 複数のモジュールでグローバル状態を共有
// user-session.js
global.currentUser = null;
global.sessionData = {};

function setCurrentUser(user) {
  global.currentUser = user;
  global.sessionData = user.sessionData || {};
}

function getCurrentUser() {
  return global.currentUser;
}

module.exports = { setCurrentUser, getCurrentUser };

javascript// auth-middleware.js
const {
  setCurrentUser,
  getCurrentUser,
} = require('./user-session');

function authMiddleware(req, res, next) {
  const token = req.headers.authorization;

  if (token) {
    const user = validateToken(token);
    setCurrentUser(user); // 他のリクエストに影響
  }

  next();
}

// 問題: 同時リクエストで currentUser が上書きされる

問題の症状:

同時リクエスト処理時に、ユーザー情報が混在
セキュリティ脆弱性（他のユーザーの情報が漏洩）
認証・認可の誤動作

解決策:

javascript// 改善されたセッション管理
class SessionManager {
  constructor() {
    this.sessions = new Map();
    this.cleanupInterval = setInterval(() => {
      this.cleanupExpiredSessions();
    }, 300000); // 5分ごとにクリーンアップ
  }

  createSession(userId, sessionData) {
    const sessionId = this.generateSessionId();
    const session = {
      userId,
      data: sessionData,
      createdAt: Date.now(),
      lastAccessed: Date.now(),
      expiresAt: Date.now() + 24 * 60 * 60 * 1000, // 24時間
    };

    this.sessions.set(sessionId, session);
    return sessionId;
  }

  getSession(sessionId) {
    const session = this.sessions.get(sessionId);
    if (!session) {
      return null;
    }

    if (Date.now() > session.expiresAt) {
      this.sessions.delete(sessionId);
      return null;
    }

    session.lastAccessed = Date.now();
    return session;
  }

  updateSession(sessionId, data) {
    const session = this.sessions.get(sessionId);
    if (session) {
      session.data = { ...session.data, ...data };
      session.lastAccessed = Date.now();
    }
  }

  destroySession(sessionId) {
    return this.sessions.delete(sessionId);
  }

  cleanupExpiredSessions() {
    const now = Date.now();
    for (const [sessionId, session] of this.sessions) {
      if (now > session.expiresAt) {
        this.sessions.delete(sessionId);
      }
    }
  }

  generateSessionId() {
    return require('crypto')
      .randomBytes(32)
      .toString('hex');
  }

  getStats() {
    return {
      activeSessions: this.sessions.size,
      oldestSession: Math.min(
        ...Array.from(this.sessions.values()).map(
          (s) => s.createdAt
        )
      ),
    };
  }

  destroy() {
    if (this.cleanupInterval) {
      clearInterval(this.cleanupInterval);
    }
    this.sessions.clear();
  }
}

// シングルトンインスタンス
const sessionManager = new SessionManager();

module.exports = sessionManager;

javascript// 改善された認証ミドルウェア
const sessionManager = require('./session-manager');

function authMiddleware(req, res, next) {
  const token = req.headers.authorization;

  if (token) {
    try {
      const decoded = validateToken(token);
      const session = sessionManager.getSession(
        decoded.sessionId
      );

      if (session) {
        // リクエストオブジェクトにセッション情報を添付
        req.user = {
          id: session.userId,
          sessionId: decoded.sessionId,
          data: session.data,
        };
      } else {
        return res
          .status(401)
          .json({ error: 'Invalid session' });
      }
    } catch (error) {
      return res
        .status(401)
        .json({ error: 'Invalid token' });
    }
  }

  next();
}

module.exports = authMiddleware;

これらの実例から分かるように、グローバルオブジェクトの不適切な使用は、メモリリーク、セキュリティ脆弱性、予期しない動作など、様々な深刻な問題を引き起こします。次のセクションでは、これらの問題を回避するためのベストプラクティスについて詳しく解説いたします。

安全な使用方法とベストプラクティス

ESLint ルールによる静的解析

グローバルオブジェクトの不適切な使用を防ぐため、ESLint ルールを活用した静的解析を導入しましょう。

javascript// .eslintrc.js
module.exports = {
  env: {
    node: true,
    es2021: true,
  },
  extends: ['eslint:recommended'],
  rules: {
    // グローバル変数の使用を制限
    'no-implicit-globals': 'error',
    'no-global-assign': 'error',

    // process.exit の直接使用を警告
    'no-process-exit': 'warn',

    // 未定義変数の使用を禁止
    'no-undef': 'error',

    // Buffer() コンストラクタの使用を禁止（非推奨）
    'no-buffer-constructor': 'error',

    // console の使用を制限（本番環境では削除）
    'no-console':
      process.env.NODE_ENV === 'production'
        ? 'error'
        : 'warn',
  },

  // カスタムルール
  overrides: [
    {
      files: ['**/*.js'],
      rules: {
        // global オブジェクトへの直接代入を禁止
        'no-restricted-syntax': [
          'error',
          {
            selector:
              'AssignmentExpression[left.object.name="global"]',
            message:
              'global オブジェクトへの直接代入は禁止されています',
          },
          {
            selector:
              'MemberExpression[object.name="process"][property.name="exit"]',
            message:
              'process.exit の直接使用は推奨されません。適切なシャットダウン処理を実装してください',
          },
        ],
      },
    },
  ],
};

モジュール化による依存関係の明確化

javascript// 良い例: 設定管理モジュール
// config/index.js
class ConfigManager {
  constructor() {
    this.config = this.loadConfig();
    this.validateConfig();
  }

  loadConfig() {
    return {
      server: {
        port: parseInt(process.env.PORT) || 3000,
        host: process.env.HOST || 'localhost',
      },
      database: {
        url:
          process.env.DATABASE_URL ||
          'mongodb://localhost:27017/app',
        maxConnections:
          parseInt(process.env.DB_MAX_CONNECTIONS) || 10,
      },
      security: {
        jwtSecret: process.env.JWT_SECRET,
        bcryptRounds:
          parseInt(process.env.BCRYPT_ROUNDS) || 10,
      },
    };
  }

  validateConfig() {
    const required = ['JWT_SECRET'];
    const missing = required.filter(
      (key) => !process.env[key]
    );

    if (missing.length > 0) {
      throw new Error(
        `必須環境変数が設定されていません: ${missing.join(
          ', '
        )}`
      );
    }
  }

  get(path) {
    return this.getNestedValue(this.config, path);
  }

  getNestedValue(obj, path) {
    return path
      .split('.')
      .reduce((current, key) => current?.[key], obj);
  }
}

// シングルトンインスタンス
const configManager = new ConfigManager();
module.exports = configManager;

javascript// 使用例: 明示的な依存関係
// server.js
const express = require('express');
const config = require('./config');

const app = express();

app.listen(
  config.get('server.port'),
  config.get('server.host'),
  () => {
    console.log(
      `Server running on ${config.get(
        'server.host'
      )}:${config.get('server.port')}`
    );
  }
);

依存性注入（DI）パターンの活用

javascript// DI コンテナの実装
class DIContainer {
  constructor() {
    this.services = new Map();
    this.singletons = new Map();
  }

  register(name, factory, options = {}) {
    this.services.set(name, {
      factory,
      singleton: options.singleton || false,
      dependencies: options.dependencies || [],
    });
  }

  resolve(name) {
    const service = this.services.get(name);
    if (!service) {
      throw new Error(`Service '${name}' not found`);
    }

    // シングルトンの場合、既存のインスタンスを返す
    if (service.singleton && this.singletons.has(name)) {
      return this.singletons.get(name);
    }

    // 依存関係を解決
    const dependencies = service.dependencies.map((dep) =>
      this.resolve(dep)
    );

    // インスタンスを作成
    const instance = service.factory(...dependencies);

    // シングルトンの場合、インスタンスを保存
    if (service.singleton) {
      this.singletons.set(name, instance);
    }

    return instance;
  }

  // 循環依存の検出
  detectCircularDependencies() {
    const visited = new Set();
    const recursionStack = new Set();

    const hasCycle = (serviceName) => {
      if (recursionStack.has(serviceName)) {
        return true;
      }
      if (visited.has(serviceName)) {
        return false;
      }

      visited.add(serviceName);
      recursionStack.add(serviceName);

      const service = this.services.get(serviceName);
      if (service) {
        for (const dependency of service.dependencies) {
          if (hasCycle(dependency)) {
            return true;
          }
        }
      }

      recursionStack.delete(serviceName);
      return false;
    };

    for (const serviceName of this.services.keys()) {
      if (hasCycle(serviceName)) {
        throw new Error(
          `Circular dependency detected involving service: ${serviceName}`
        );
      }
    }
  }
}

// 使用例
const container = new DIContainer();

// サービスの登録
container.register('config', () => require('./config'), {
  singleton: true,
});

container.register(
  'database',
  (config) => {
    const mongoose = require('mongoose');
    return mongoose.connect(config.get('database.url'));
  },
  { dependencies: ['config'], singleton: true }
);

container.register(
  'userService',
  (database, config) => {
    return new UserService(database, config);
  },
  { dependencies: ['database', 'config'] }
);

// 循環依存の検出
container.detectCircularDependencies();

// サービスの解決
const userService = container.resolve('userService');

代替手法と解決策

適切な設計パターン

1. Factory パターン

javascript// Factory パターンによる安全なオブジェクト生成
class LoggerFactory {
  static createLogger(type, options = {}) {
    switch (type) {
      case 'console':
        return new ConsoleLogger(options);
      case 'file':
        return new FileLogger(options);
      case 'database':
        return new DatabaseLogger(options);
      default:
        throw new Error(`Unknown logger type: ${type}`);
    }
  }
}

class ConsoleLogger {
  constructor(options) {
    this.level = options.level || 'info';
    this.prefix = options.prefix || '';
  }

  log(level, message) {
    if (this.shouldLog(level)) {
      console.log(
        `${this.prefix}[${level.toUpperCase()}] ${message}`
      );
    }
  }

  shouldLog(level) {
    const levels = ['error', 'warn', 'info', 'debug'];
    return (
      levels.indexOf(level) <= levels.indexOf(this.level)
    );
  }
}

// 使用例
const logger = LoggerFactory.createLogger('console', {
  level: 'info',
  prefix: '[MyApp] ',
});

2. Observer パターン

javascript// Observer パターンによるイベント管理
class EventManager {
  constructor() {
    this.listeners = new Map();
  }

  on(event, listener) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event).add(listener);
  }

  off(event, listener) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).delete(listener);

      // リスナーがなくなったらイベントを削除
      if (this.listeners.get(event).size === 0) {
        this.listeners.delete(event);
      }
    }
  }

  emit(event, ...args) {
    if (this.listeners.has(event)) {
      for (const listener of this.listeners.get(event)) {
        try {
          listener(...args);
        } catch (error) {
          console.error(
            `Error in event listener for '${event}':`,
            error
          );
        }
      }
    }
  }

  removeAllListeners(event) {
    if (event) {
      this.listeners.delete(event);
    } else {
      this.listeners.clear();
    }
  }

  getListenerCount(event) {
    return this.listeners.has(event)
      ? this.listeners.get(event).size
      : 0;
  }
}

// 使用例
const eventManager = new EventManager();

const userLoginHandler = (user) => {
  console.log(`User ${user.name} logged in`);
};

eventManager.on('user:login', userLoginHandler);
eventManager.emit('user:login', { name: 'Alice' });

リファクタリング手法

グローバル状態からモジュール状態への移行

javascript// Before: グローバル状態
global.appState = {
  users: [],
  currentUser: null,
  settings: {},
};

function addUser(user) {
  global.appState.users.push(user);
}

function setCurrentUser(user) {
  global.appState.currentUser = user;
}

javascript// After: モジュール状態
// state/AppState.js
class AppState {
  constructor() {
    this.users = [];
    this.currentUser = null;
    this.settings = {};
  }

  addUser(user) {
    if (!user || typeof user !== 'object') {
      throw new Error('Valid user object is required');
    }

    this.users.push({ ...user });
    return this.users.length - 1; // インデックスを返す
  }

  setCurrentUser(user) {
    if (user && !this.users.includes(user)) {
      throw new Error(
        'User must be added to users array first'
      );
    }

    this.currentUser = user;
  }

  getUsers() {
    return [...this.users]; // 防御的コピー
  }

  getCurrentUser() {
    return this.currentUser
      ? { ...this.currentUser }
      : null;
  }

  updateSettings(newSettings) {
    this.settings = { ...this.settings, ...newSettings };
  }

  getSettings() {
    return { ...this.settings };
  }
}

// シングルトンインスタンス
const appState = new AppState();
module.exports = appState;

まとめ

Node.js のグローバルオブジェクトは、適切に使用すれば強力で便利な機能を提供しますが、不適切な使用は深刻な問題を引き起こす可能性があります。

重要なポイント

観点	危険な使用法	安全な使用法
グローバル汚染	`global` オブジェクトに直接代入	モジュール化と明示的な依存関係
プロセス制御	`process.exit()` の直接使用	グレースフルシャットダウンの実装
メモリ管理	無制限なバッファ作成、タイマーリーク	サイズ制限、適切なクリーンアップ
状態管理	グローバル状態の共有	依存性注入、Factory パターン
エラー処理	未処理例外の放置	包括的なエラーハンドリング