forEachの実務的な使い方｜業務で頻出するパターン集

未分類

forEachの実務的な使い方｜業務で頻出するパターン集

プログラミング実務において、配列やコレクションのイテレーション処理は日々の業務の中核となります。その中でもforEachは最も基本的で汎用的なメソッドです。本記事では、教科書的な使い方ではなく、実際の業務現場で遭遇する実践的なパターンを中心に解説します。

1. forEachの基本的な仕組み

forEachは、配列の各要素に対して指定されたコールバック関数を実行するメソッドです。JavaScript/TypeScriptではArrayプロトタイプに組み込まれており、Python的にはforループの関数型表現に相当します。

基本的な特性：

  • 戻り値はundefined（チェーンできない）
  • ループの途中で抜けることができない（breakが使えない）
  • 同期処理を基本とする
  • 各要素に対して副作用（ログ出力、データ更新など）を伴う処理に適している

2. 業務でのユースケース

ユースケース1：データベースへの一括更新処理

実務では、APIレスポンスで取得した複数のレコードをデータベースに保存する場面が頻繁に発生します。以下は、ユーザーデータを一件ずつ保存する実装例です。

// 実務例：APIから取得したユーザーデータをDBに保存
interface User {
  id: number;
  name: string;
  email: string;
  registrationDate: Date;
}

async function saveUsersFromAPI(users: User[]): Promise<void> {
  const logger = console; // 実務ではloggerライブラリを使用
  
  users.forEach(async (user) => {
    try {
      const timestamp = new Date().toISOString();
      logger.info(`Processing user: ${user.id}`, { timestamp });
      
      // DBにユーザーを保存（実務では適切なORM/DBクライアントを使用）
      await database.users.create({
        externalId: user.id,
        name: user.name,
        email: user.email,
        registeredAt: user.registrationDate,
        syncedAt: new Date()
      });
      
      logger.info(`User ${user.id} saved successfully`);
    } catch (error) {
      logger.error(`Failed to save user ${user.id}`, {
        error: error instanceof Error ? error.message : 'Unknown error',
        userId: user.id
      });
      // 実務では、ここでアラート送信やリトライロジックを実装
    }
  });
}

ユースケース2：複数のAPIエンドポイントへの並列リクエスト

実務では、複数のデータソースから情報を並列に取得する必要があります。以下は、複数のユーザーIDに対して個別のAPIリクエストを送信する例です。

// 実務例：複数ユーザーの詳細情報をバッチ取得
interface UserDetail {
  userId: number;
  profile: string;
  lastLoginDate: Date;
  subscriptionStatus: 'active' | 'inactive' | 'suspended';
}

async function fetchUserDetailsInBatch(userIds: number[]): Promise<Map<number, UserDetail>> {
  const userDetailsMap = new Map<number, UserDetail>();
  const requestPromises: Promise<void>[] = [];
  
  // 実務ではリクエスト数の制限（Concurrency Control）が重要
  const CONCURRENT_REQUESTS = 5;
  let activeRequests = 0;
  
  userIds.forEach((userId) => {
    const promise = (async () => {
      // 同時リクエスト数を制御
      while (activeRequests >= CONCURRENT_REQUESTS) {
        await new Promise(resolve => setTimeout(resolve, 100));
      }
      
      activeRequests++;
      try {
        const response = await fetch(`/api/users/${userId}/details`);
        const data: UserDetail = await response.json();
        userDetailsMap.set(userId, data);
      } catch (error) {
        console.error(`Failed to fetch details for user ${userId}`, error);
        // エラーハンドリング：デフォルト値を設定するか、スキップするか判定
      } finally {
        activeRequests--;
      }
    })();
    
    requestPromises.push(promise);
  });
  
  await Promise.all(requestPromises);
  return userDetailsMap;
}

ユースケース3：ログ集計とレポート生成

実務では、ログファイルやイベントデータを処理して集計レポートを生成する場面があります。

#!/usr/bin/env python3
# 実務例：アクセスログの集計とレポート生成

from datetime import datetime
from typing import List, Dict, DefaultDict
from collections import defaultdict

class LogAnalyzer:
    def __init__(self):
        self.hourly_stats = defaultdict(int)
        self.error_counts = defaultdict(int)
        self.user_sessions = defaultdict(list)
    
    def process_logs(self, log_entries: List[Dict]) -> None:
        \"\"\"実務的なログ処理：複数の集計を同時に実行\"\"\"
        
        log_entries.forEach(lambda log: self._process_single_log(log))
    
    def _process_single_log(self, log: Dict) -> None:
        try:
            # ログのタイムスタンプから時間を抽出
            timestamp = datetime.fromisoformat(log['timestamp'])
            hour_key = timestamp.strftime('%Y-%m-%d %H:00')
            
            # 時間帯別のアクセス数を集計
            self.hourly_stats[hour_key] += 1
            
            # エラーログをカウント
            if log.get('level') == 'ERROR':
                error_type = log.get('error_code', 'UNKNOWN')
                self.error_counts[error_type] += 1
            
            # ユーザーセッション情報を記録
            user_id = log.get('user_id')
            if user_id:
                self.user_sessions[user_id].append({
                    'timestamp': timestamp,
                    'action': log.get('action'),
                    'duration_ms': log.get('duration_ms')
                })
        
        except Exception as e:
            print(f\"Error processing log entry: {e}\")
            # 実務では、このようなエラーは監視対象になる

# 実際の使用例
def generate_daily_report(log_file_path: str) -> Dict:
    \"\"\"実務：ログファイルから日次レポートを生成\"\"\"
    
    analyzer = LogAnalyzer()
    logs = []
    
    # ファイルから全ログを読み込み（実務では大規模ファイル処理に注意）
    with open(log_file_path, 'r') as f:
        import json
        for line in f:
            try:
                logs.append(json.loads(line))
            except json.JSONDecodeError:
                print(f\"Skipping malformed JSON line: {line.strip()}\")
    
    # ログを処理
    analyzer.process_logs(logs)
    
    # レポートを生成
    return {
        'generated_at': datetime.now().isoformat(),
        'total_logs': len(logs),
        'hourly_stats': dict(analyzer.hourly_stats),
        'error_summary': dict(analyzer.error_counts),
        'total_errors': sum(analyzer.error_counts.values()),
        'unique_users': len(analyzer.user_sessions)
    }

3. よくある応用パターン

パターン1：条件付き処理と途中終了の代替案

forEachはループを途中で抜けられないという制限があります。実務では条件に応じた途中終了が必要な場合があります。以下は適切な代替パターンです。

// パターンA：some()を使用（条件で終了する場合）
function processUntilError(items: any[]): boolean {
  let hasError = false;
  
  items.some((item) => {
    try {
      processItem(item);
      return false; // 継続
    } catch (error) {
      console.error('Error occurred', error);
      hasError = true;
      return true; // ループを終了
    }
  });
  
  return hasError;
}

// パターンB：every()を使用（全て成功する場合をチェック）
function validateAllItems(items: any[]): boolean {
  return items.every((item) => {
    try {
      validateItem(item);
      return true;
    } catch (error) {
      console.error(`Validation failed for item: ${item.id}`, error);
      return false;
    }
  });
}

// パターンC：forEachは副作用用、条件判定は別途
function processWithCondition(items: any[]): void {
  const validItems = items.filter(item => item.status === 'active');
  
  validItems.forEach((item) => {
    executeBusinessLogic(item);
  });
}

パターン2：インデックスと複数要素への同時アクセス

実務では、現在の要素だけでなく、前後の要素や配列内のインデックスにアクセスする必要があります。

// 実務例：連続したデータの差分を計算
interface DataPoint {
  timestamp: Date;
  value: number;
}

function calculateDifferentials(dataPoints: DataPoint[]): void {
  dataPoints.forEach((current, index, array) => {
    // インデックスを使用して前の要素にアクセス
    if (index > 0) {
      const previous = array[index - 1];
      const timeDiff = current.timestamp.getTime() - previous.timestamp.getTime();
      const valueDiff = current.value - previous.value;
      const rate = timeDiff > 0 ? valueDiff / timeDiff : 0;
      
      console.log(`Data point ${index}: Rate of change = ${rate}`);
    }
    
    // 次の要素にもアクセス可能
    if (index < array.length - 1) {
      const next = array[index + 1];
      // 前後の要素を比較した処理をここで実行
    }
  });
}

パターン3：非同期処理のシーケンシャル実行

よくある誤りとして、forEach内でawaitを使用しても並列実行されてしまうことがあります。実務では、処理の順序が重要な場合があります。

// ❌ 誤りのパターン：並列実行されてしまう
async function wrongSequentialProcessing(items: any[]): Promise<void> {
  items.forEach(async (item) => {
    await processAsync(item); // これは並列実行される！
  });
  // forEachが即座に完了し、非同期処理はバックグラウンドで実行
}

// ✅ 正しいパターン1：forループで順序を保証
async function correctSequentialProcessing1(items: any[]): Promise<void> {
  for (const item of items) {
    await processAsync(item); // 順序が保証される
    console.log(`Processed item ${item.id}`);
  }
}

// ✅ 正しいパターン2：reduceで順序を保証（関数型スタイル）
async function correctSequentialProcessing2(items: any[]): Promise<void> {
  await items.reduce(
    async (previousPromise, item) => {
      await previousPromise;
      await processAsync(item);
      console.log(`Processed item ${item.id}`);
    },
    Promise.resolve()
  );
}

// 実務例：データベーストランザクションでの順序の重要性
async function processOrderItems(orderId: string, items: OrderItem[]): Promise<void> {
  try {
    await database.transaction(async (tx) => {
      let totalAmount = 0;
      
      // 各商品を順序通りに処理（在庫確認→確保→会計）
      for (const item of items) {
        // 1. 在庫を確認
        const stock = await tx.checkStock(item.productId);
        if (stock < item.quantity) {
          throw new Error(`Insufficient stock for product ${item.productId}`);
        }
        
        // 2. 在庫を確保
        await tx.reserveStock(item.productId, item.quantity);
        
        // 3. 金額を計算
        const price = await tx.getPrice(item.productId);
        totalAmount += price * item.quantity;
        
        console.log(`Item ${item.productId} processed: Qty=${item.quantity}, Subtotal=${price * item.quantity}`);\n      }
      
      // 4. 最終的に注文を確定
      await tx.updateOrder(orderId, { status: 'confirmed', total: totalAmount });
    });
  } catch (error) {
    console.error(`Order processing failed: ${error}`);
    throw error;
  }
}

パターン4：グループ化と集約

実務では、配列の要素をグループ化して処理することがあります。

#!/usr/bin/env python3
# 実務例：ユーザーアクティビティをグループ化して分析

from typing import List, Dict
from datetime import datetime
from itertools import groupby

class ActivityAnalyzer:
    def __init__(self, activities: List[Dict]):
        self.activities = activities
        self.grouped_results = {}
    
    def analyze_by_user_and_date(self) -> Dict[str, Dict]:
        \"\"\"ユーザーと日付でグループ化して分析\"\"\"
        
        # ユーザーごとにグループ化
        grouped_by_user = {}
        for activity in self.activities:
            user_id = activity['user_id']
            if user_id not in grouped_by_user:
                grouped_by_user[user_id] = []
            grouped_by_user[user_id].append(activity)
        
        # 各ユーザーのアクティビティを日付でグループ化して処理
        result = {}
        for user_id, user_activities in grouped_by_user.items():
            result[user_id] = {}
            
            # 日付でグループ化
            sorted_activities = sorted(user_activities, 
                                      key=lambda x: x['timestamp'][:10])
            
            current_date = None
            for activity in sorted_activities:
                activity_date = activity['timestamp'][:10]
                
                if activity_date != current_date:
                    current_date = activity_date
                    result[user_id][current_date] = {
                        'count': 0,
                        'actions': [],
                        'duration_total_ms': 0
                    }
                
                # 同じ日付のアクティビティを集約
                day_stats = result[user_id][current_date]
                day_stats['count'] += 1
                day_stats['actions'].append(activity['action'])
                day_stats['duration_total_ms'] += activity.get('duration_ms', 0)
        
        return result\n\n# 実際の使用例\ndef generate_user_activity_report(activities: List[Dict]) -> Dict:\n    \"\"\"ユーザーアクティビティレポート生成\"\"\"\n    analyzer = ActivityAnalyzer(activities)\n    grouped = analyzer.analyze_by_user_and_date()\n    \n    # さらに処理：各ユーザーの統計情報を計算\n    report = {}\n    for user_id, date_data in grouped.items():\n        total_actions = sum(day['count'] for day in date_data.values())\n        total_duration = sum(day['duration_total_ms'] for day in date_data.values())\n        \n        report[user_id] = {\n            'total_activity_days': len(date_data),\n            'total_actions': total_actions,\n            'total_duration_ms': total_duration,\n            'avg_action_duration_ms': total_duration / total_actions if total_actions > 0 else 0,\n            'daily_breakdown': date_data\n        }\n    \n    return report

4. 注意点と実務的な落とし穴

注意点1：メモリ管理と大規模データセット

実務では、数百万件のレコードを処理する場合があります。全データをメモリに読み込むforEachは危険です。

// ❌ 危険：大規模データセットを全部メモリに読み込み\nasync function processAllUsersDangerous(databaseQuery: any): Promise<void> {\n  const allUsers = await databaseQuery.getAll(); // ❌ 100万件がメモリに！\n  allUsers.forEach((user) => {\n    // 処理\n  });\n}\n\n// ✅ 安全：ストリーミング処理またはバッチ処理\nasync function processAllUsersWithBatching(databaseQuery: any, batchSize: number = 1000): Promise<void> {\n  let offset = 0;\n  let hasMore = true;\n  \n  while (hasMore) {\n    // 1バッチずつ取得\n    const batch = await databaseQuery.limit(batchSize).offset(offset).getAll();\n    \n    if (batch.length === 0) {\n      hasMore = false;\n      break;\n    }\n    \n    // バッチを処理\n    batch.forEach((user) => {\n      processUser(user);\n    });\n    \n    offset += batchSize;\n    console.log(`Processed ${offset} users...`);\n  }\n}\n\n// 実務例：ストリーミング処理（Nodeでの実装）\nasync function processUsersWithStream(filePath: string): Promise<void> {\n  const fs = require('fs').promises;\n  const readline = require('readline');\n  \n  const fileStream = fs.createReadStream(filePath);\n  const rl = readline.createInterface({\n    input: fileStream,\n    crlfDelay: Infinity\n  });\n  \n  for await (const line of rl) {\n    const user = JSON.parse(line);\n    // 1行ずつ処理できるため、メモリ効率が良い\n    await processUserAsync(user);\n  }\n}

注意点2：エラーハンドリングと例外の伝播

実務では、ループ内の例外をどう処理するかは重要な設計判断です。

// パターン1：全体的な成功/失敗判定
async function processWithErrorCollection(items: any[]): Promise<{ success: number; failed: number; errors: any[] }> {\n  const results = { success: 0, failed: 0, errors: [] };\n  \n  for (const item of items) {\n    try {\n      await processItem(item);\n      results.success++;\n    } catch (error) {\n      results.failed++;\n      results.errors.push({\n        itemId: item.id,\n        error: error instanceof Error ? error.message : 'Unknown error',\n        timestamp: new Date().toISOString()\n      });\n    }\n  }\n  \n  // ログに記録（実務では監視システムに送信）\n  console.log(`Processing complete: ${results.success} success, ${results.failed} failed`);\n  if (results.failed > 0) {\n    console.warn(`Errors occurred:`, results.errors);\n  }\n  \n  return results;\n}\n\n// パターン2：一部失敗時の部分的な成功を許可\nasync function processWithPartialSuccess(items: any[]): Promise<any[]> {\n  const results = await Promise.allSettled(\n    items.map(item => processItem(item))\n  );\n  \n  const successResults = results\n    .map((result, index) => ({\n      index,\n      status: result.status,\n      value: result.status === 'fulfilled' ? result.value : null,\n      error: result.status === 'rejected' ? result.reason : null\n    }))\n    .filter(r => r.status === 'fulfilled');\n  \n  console.log(`Partial success: ${successResults.length}/${items.length} items processed`);\n  return successResults;\n}\n\n// パターン3：サーキットブレーカー（エラーが多い場合は処理を中止）\nasync function processWithCircuitBreaker(items: any[], errorThreshold: number = 0.5): Promise<void> {\n  let errorCount = 0;\n  const maxErrors = Math.ceil(items.length * errorThreshold);\n  \n  for (const item of items) {\n    if (errorCount > maxErrors) {\n      console.error(`Circuit breaker triggered: Error rate exceeded ${errorThreshold * 100}%`);\n      throw new Error('Processing halted due to high error rate');\n    }\n    \n    try {\n      await processItem(item);\n    } catch (error) {\n      errorCount++;\n      console.warn(`Error processing item ${item.id}, count: ${errorCount}/${maxErrors}`);\n    }\n  }\n}

注意点3：パフォーマンスと計算量

実務では、forEach内で複雑な計算を実行すると、全体のパフォーマンスが低下します。

// ❌ 非効率：forEach内でフィルタリングと検索を繰り返す\nfunction inefficientProcessing(users: User[], bannedEmails: string[]): void {\n  users.forEach((user) => {\n    // O(n)の線形検索が毎回実行される（全体ではO(n²)）\n    if (bannedEmails.includes(user.email)) {\n      return;\n    }\n    processUser(user);\n  });\n}\n\n// ✅ 効率的：前処理でSet化して高速化\nfunction efficientProcessing(users: User[], bannedEmails: string[]): void {\n  const bannedSet = new Set(bannedEmails); // O(n)の前処理\n  \n  users.forEach((user) => {\n    if (bannedSet.has(user.email)) { // O(1)の高速検索\n      return;\n    }\n    processUser(user);\n  });\n}\n\n// 実務例：複雑な集計処理の最適化\ninterface Transaction {\n  id: string;\n  userId: string;\n  amount: number;\n  category: string;\n  date: Date;\n}\n\n// ❌ 非効率な実装\nfunction calculateUserStatisticsInefficient(transactions: Transaction[]): Map<string, any> {\n  const userStats = new Map();\n  \n  transactions.forEach((tx) => {\n    // 毎回ユーザー統計を取得・更新\n    let stats = userStats.get(tx.userId);\n    if (!stats) {\n      // 毎回新しいオブジェクトを作成\n      stats = {\n        totalAmount: 0,\n        transactionCount: 0,\n        categories: new Map(),\n        dates: []\n      };\n    }\n    \n    // 毎回Mapをチェック\n    let categoryCount = stats.categories.get(tx.category) || 0;\n    stats.categories.set(tx.category, categoryCount + 1);\n    \n    stats.totalAmount += tx.amount;\n    stats.transactionCount++;\n    stats.dates.push(tx.date);\n    \n    userStats.set(tx.userId, stats);\n  });\n  \n  return userStats;\n}\n\n// ✅ 効率的な実装：事前に構造を用意\nfunction calculateUserStatisticsEfficient(transactions: Transaction[]): Map<string, any> {\n  const userStats = new Map();\n  \n  // 初期化済みのMap構造を事前に用意\n  const initializeUserStats = (userId: string) => ({\n    totalAmount: 0,\n    transactionCount: 0,\n    categories: new Map(),\n    dates: []\n  });\n  \n  transactions.forEach((tx) => {\n    // 存在しない場合のみ初期化\n    if (!userStats.has(tx.userId)) {\n      userStats.set(tx.userId, initializeUserStats(tx.userId));\n    }\n    \n    const stats = userStats.get(tx.userId)!; // 既存であることが保証されている\n    \n    // インクリメント操作を直接実行\n    const categoryCount = (stats.categories.get(tx.category) ?? 0) + 1;\n    stats.categories.set(tx.category, categoryCount);\n    \n    stats.totalAmount += tx.amount;\n    stats.transactionCount++;\n  });\n  \n  return userStats;\n}

注意点4：スコープとクロージャの問題

実務では、ループ内で定義された変数のスコープ管理が重要です。
タイトルとURLをコピーしました