プログラミングの「コード臭」とは？ - 初心者が気づくべきサイン

みなさん、プログラミングで「なんだかこのコード、読みにくいな」「修正しづらいな」と感じたことはありませんか？

そのモヤモヤした感覚こそが、プログラミングの世界で「コード臭」と呼ばれる現象です。 コード臭は、コードが技術的には動作するものの、保守性や可読性に問題があることを示すサインです。

この記事では、プログラミング初心者が知っておくべきコード臭の基本概念から、具体的な検出方法と改善策まで詳しく解説します。 コード臭を早期に発見し、質の高いコードを書けるプログラマーを目指しましょう。

コード臭とは何か

コード臭（Code Smell）とは、コードの表面的な問題を表す概念で、マーティン・ファウラーの著書「リファクタリング」で広く知られるようになりました。

「臭い」という表現は、何かが腐っているサインと同様に、コードに潜在的な問題があることを示唆します。 重要なのは、コード臭があってもプログラムは正常に動作することです。しかし、将来的にバグや保守性の問題を引き起こす可能性が高くなります。

コード臭の特徴

コード臭には以下のような特徴があります。

// コード臭の分析システム
class CodeSmellDetector {
    constructor() {
        this.smellTypes = {
            "structural_smells": {
                "description": "コードの構造に関する問題",
                "examples": ["重複コード", "長いメソッド", "大きなクラス"],
                "impact": "保守性・可読性の低下",
                "difficulty": "初心者でも検出しやすい"
            },
            "object_oriented_smells": {
                "description": "オブジェクト指向設計の問題",
                "examples": ["データクラス", "機能の羨望", "過度な結合"],
                "impact": "設計の柔軟性低下",
                "difficulty": "中級者以上で検出可能"
            },
            "change_preventers": {
                "description": "変更を困難にする問題",
                "examples": ["発散的変更", "散弾銃手術", "平行継承階層"],
                "impact": "変更コストの増大",
                "difficulty": "経験者で検出可能"
            },
            "dispensables": {
                "description": "不要な要素",
                "examples": ["推測による一般性", "デッドコード", "重複コード"],
                "impact": "コードの複雑性増大",
                "difficulty": "初心者でも検出しやすい"
            }
        };
        
        this.detectionMethods = {
            "manual_review": {
                "description": "人間によるコードレビュー",
                "pros": ["文脈理解", "経験活用", "創造的解決"],
                "cons": ["時間がかかる", "主観的", "見落としリスク"],
                "suitable_for": "すべてのレベル"
            },
            "automated_tools": {
                "description": "自動化ツールによる検出",
                "pros": ["高速", "客観的", "一貫性"],
                "cons": ["文脈理解不足", "誤検出", "ツール設定必要"],
                "suitable_for": "初心者から上級者"
            },
            "metrics_analysis": {
                "description": "メトリクス分析による検出",
                "pros": ["定量的", "トレンド把握", "比較可能"],
                "cons": ["表面的", "閾値設定困難", "偽陽性"],
                "suitable_for": "中級者以上"
            }
        };
    }
    
    analyzeCodeQuality(codeBase) {
        """コード品質を分析"""
        const analysis = {
            overall_score: 0,
            detected_smells: [],
            quality_metrics: {},
            improvement_suggestions: [],
            priority_areas: []
        };
        
        // 基本的な品質メトリクスの計算
        analysis.quality_metrics = this.calculateQualityMetrics(codeBase);
        
        // コード臭の検出
        analysis.detected_smells = this.detectSmells(codeBase);
        
        // 全体スコアの計算
        analysis.overall_score = this.calculateOverallScore(analysis.quality_metrics);
        
        // 改善提案の生成
        analysis.improvement_suggestions = this.generateImprovementSuggestions(
            analysis.detected_smells
        );
        
        // 優先改善領域の特定
        analysis.priority_areas = this.identifyPriorityAreas(analysis.detected_smells);
        
        return analysis;
    }
    
    calculateQualityMetrics(codeBase) {
        """品質メトリクスを計算"""
        return {
            complexity: this.calculateComplexity(codeBase),
            duplication: this.calculateDuplication(codeBase),
            test_coverage: this.calculateTestCoverage(codeBase),
            maintainability: this.calculateMaintainability(codeBase),
            readability: this.calculateReadability(codeBase)
        };
    }
    
    detectSmells(codeBase) {
        """コード臭を検出"""
        const detectedSmells = [];
        
        // 構造的なコード臭の検出
        detectedSmells.push(...this.detectStructuralSmells(codeBase));
        
        // オブジェクト指向のコード臭の検出
        detectedSmells.push(...this.detectOOSmells(codeBase));
        
        // 変更阻害要因の検出
        detectedSmells.push(...this.detectChangePreventers(codeBase));
        
        // 不要要素の検出
        detectedSmells.push(...this.detectDispensables(codeBase));
        
        return detectedSmells;
    }
    
    detectStructuralSmells(codeBase) {
        """構造的コード臭を検出"""
        const smells = [];
        
        // 長いメソッドの検出
        const longMethods = this.findLongMethods(codeBase);
        longMethods.forEach(method => {
            smells.push({
                type: "Long Method",
                severity: "medium",
                location: method.location,
                description: `メソッド ${method.name} が ${method.lines} 行と長すぎます`,
                suggestion: "メソッドを小さな機能に分割してください"
            });
        });
        
        // 大きなクラスの検出
        const largeClasses = this.findLargeClasses(codeBase);
        largeClasses.forEach(cls => {
            smells.push({
                type: "Large Class",
                severity: "high",
                location: cls.location,
                description: `クラス ${cls.name} が ${cls.methods} 個のメソッドを持ち大きすぎます`,
                suggestion: "クラスの責任を分割してください"
            });
        });
        
        // 重複コードの検出
        const duplicates = this.findDuplicateCode(codeBase);
        duplicates.forEach(duplicate => {
            smells.push({
                type: "Duplicate Code",
                severity: "high",
                location: duplicate.locations,
                description: `${duplicate.lines} 行の重複コードが検出されました`,
                suggestion: "共通処理を関数やメソッドに抽出してください"
            });
        });
        
        return smells;
    }
    
    generateImprovementSuggestions(detectedSmells) {
        """改善提案を生成"""
        const suggestions = [];
        
        // 深刻度別の提案
        const highSeveritySmells = detectedSmells.filter(smell => smell.severity === "high");
        const mediumSeveritySmells = detectedSmells.filter(smell => smell.severity === "medium");
        
        if (highSeveritySmells.length > 0) {
            suggestions.push({
                priority: "高",
                action: "高深刻度のコード臭を優先的に修正",
                timeline: "1-2週間",
                impact: "保守性の大幅改善"
            });
        }
        
        if (mediumSeveritySmells.length > 0) {
            suggestions.push({
                priority: "中",
                action: "中深刻度のコード臭を段階的に修正",
                timeline: "1ヶ月",
                impact: "コード品質の安定化"
            });
        }
        
        // タイプ別の提案
        const smellTypes = [...new Set(detectedSmells.map(smell => smell.type))];
        smellTypes.forEach(type => {
            suggestions.push({
                priority: "継続",
                action: `${type} パターンの予防策実装`,
                timeline: "継続的",
                impact: "将来的な品質維持"
            });
        });
        
        return suggestions;
    }
    
    createRefactoringPlan(detectedSmells, constraints) {
        """リファクタリング計画を作成"""
        const plan = {
            phases: [],
            timeline: constraints.timeline || "2ヶ月",
            resources: constraints.resources || "1人",
            risk_mitigation: []
        };
        
        // フェーズ分け
        const sortedSmells = detectedSmells.sort((a, b) => {
            const severityOrder = { "high": 3, "medium": 2, "low": 1 };
            return severityOrder[b.severity] - severityOrder[a.severity];
        });
        
        const phaseSize = Math.ceil(sortedSmells.length / 3);
        
        for (let i = 0; i < 3; i++) {
            const phaseSmells = sortedSmells.slice(i * phaseSize, (i + 1) * phaseSize);
            if (phaseSmells.length > 0) {
                plan.phases.push({
                    phase: i + 1,
                    focus: this.determinePhaseeFocus(phaseSmells),
                    smells_to_fix: phaseSmells.length,
                    estimated_effort: this.estimateEffort(phaseSmells),
                    deliverables: this.defineDeliverables(phaseSmells)
                });
            }
        }
        
        // リスク軽減策
        plan.risk_mitigation = [
            "変更前のテストケース作成",
            "段階的なリファクタリング実施",
            "コードレビューの徹底",
            "自動テストの活用"
        ];
        
        return plan;
    }
    
    // ヘルパーメソッド（簡略化）
    calculateComplexity(codeBase) { return Math.floor(Math.random() * 10) + 1; }
    calculateDuplication(codeBase) { return Math.floor(Math.random() * 20); }
    calculateTestCoverage(codeBase) { return Math.floor(Math.random() * 100); }
    calculateMaintainability(codeBase) { return Math.floor(Math.random() * 10) + 1; }
    calculateReadability(codeBase) { return Math.floor(Math.random() * 10) + 1; }
    
    findLongMethods(codeBase) {
        return [
            { name: "processData", lines: 45, location: "file1.js:20" },
            { name: "calculateTotal", lines: 38, location: "file2.js:150" }
        ];
    }
    
    findLargeClasses(codeBase) {
        return [
            { name: "UserManager", methods: 25, location: "user.js:1" }
        ];
    }
    
    findDuplicateCode(codeBase) {
        return [
            { lines: 15, locations: ["file1.js:30-45", "file3.js:80-95"] }
        ];
    }
    
    detectOOSmells(codeBase) { return []; }
    detectChangePreventers(codeBase) { return []; }
    detectDispensables(codeBase) { return []; }
    
    calculateOverallScore(metrics) {
        return (metrics.complexity + metrics.maintainability + metrics.readability) / 3;
    }
    
    identifyPriorityAreas(smells) {
        return smells.filter(smell => smell.severity === "high").map(smell => smell.type);
    }
    
    determinePhaseeFocus(smells) {
        const types = smells.map(s => s.type);
        return types[0] || "一般的な改善";
    }
    
    estimateEffort(smells) {
        return `${smells.length * 2}時間`;
    }
    
    defineDeliverables(smells) {
        return [`${smells.length}個のコード臭の修正`];
    }
}

// 使用例
const detector = new CodeSmellDetector();

// サンプルコードベース
const sampleCodeBase = {
    files: ["file1.js", "file2.js", "file3.js"],
    total_lines: 1500,
    test_lines: 300
};

// コード品質分析
const analysis = detector.analyzeCodeQuality(sampleCodeBase);
console.log("全体品質スコア:", analysis.overall_score);
console.log("検出されたコード臭:", analysis.detected_smells.length);

// リファクタリング計画
const refactoringPlan = detector.createRefactoringPlan(
    analysis.detected_smells,
    { timeline: "1ヶ月", resources: "2人" }
);
console.log("計画フェーズ数:", refactoringPlan.phases.length);

このシステムにより、コード臭を体系的に検出し、改善計画を立てることができます。

なぜコード臭が問題なのか

コード臭が放置されると、以下のような問題が発生します。

• 保守性の低下: 修正や機能追加が困難になる
• バグの増加: 複雑なコードではバグが混入しやすくなる
• 開発効率の悪化: 理解に時間がかかり、開発速度が低下する
• 技術的負債の蓄積: 将来的な開発コストが増大する

初心者のうちからコード臭を意識することで、これらの問題を予防できます。

代表的なコード臭の種類

プログラミング初心者が遭遇しやすい代表的なコード臭を詳しく解説します。

重複コード（Duplicate Code）

最も基本的で検出しやすいコード臭の一つです。

# 重複コード分析システム
class DuplicateCodeAnalyzer:
    def __init__(self):
        self.duplication_types = {
            "exact_duplication": {
                "description": "完全に同じコードの重複",
                "detection_method": "文字列比較",
                "severity": "高",
                "fix_difficulty": "低"
            },
            "structural_duplication": {
                "description": "構造は同じだが変数名等が異なる",
                "detection_method": "AST比較",
                "severity": "中",
                "fix_difficulty": "中"
            },
            "functional_duplication": {
                "description": "同じ機能を異なる実装で実現",
                "detection_method": "意味解析",
                "severity": "中",
                "fix_difficulty": "高"
            }
        }
    
    def detect_duplicates(self, code_files):
        """重複コードを検出"""
        duplicates = []
        
        for i, file1 in enumerate(code_files):
            for j, file2 in enumerate(code_files[i+1:], i+1):
                file_duplicates = self.find_duplicates_between_files(file1, file2)
                duplicates.extend(file_duplicates)
        
        return self.filter_significant_duplicates(duplicates)
    
    def find_duplicates_between_files(self, file1, file2):
        """ファイル間の重複を検出"""
        duplicates = []
        
        # 完全一致の重複を検出
        exact_matches = self.find_exact_matches(file1, file2)
        duplicates.extend(exact_matches)
        
        # 構造的重複を検出
        structural_matches = self.find_structural_matches(file1, file2)
        duplicates.extend(structural_matches)
        
        return duplicates
    
    def find_exact_matches(self, file1, file2):
        """完全一致の重複を検出"""
        matches = []
        
        # 簡略化した例
        lines1 = file1.get("content", "").split('
')
        lines2 = file2.get("content", "").split('
')
        
        min_lines = 5  # 最小重複行数
        
        for i in range(len(lines1) - min_lines + 1):
            for j in range(len(lines2) - min_lines + 1):
                match_length = self.count_consecutive_matches(
                    lines1[i:], lines2[j:]
                )
                
                if match_length >= min_lines:
                    matches.append({
                        "type": "exact_duplication",
                        "file1": file1["name"],
                        "file2": file2["name"],
                        "start1": i + 1,
                        "start2": j + 1,
                        "length": match_length,
                        "severity": "高",
                        "content": '
'.join(lines1[i:i+match_length])
                    })
        
        return matches
    
    def count_consecutive_matches(self, lines1, lines2):
        """連続する一致行数をカウント"""
        count = 0
        min_length = min(len(lines1), len(lines2))
        
        for i in range(min_length):
            if lines1[i].strip() == lines2[i].strip() and lines1[i].strip():
                count += 1
            else:
                break
        
        return count
    
    def create_examples(self):
        """重複コード例を作成"""
        examples = {
            "bad_example": {
                "description": "重複コードがある悪い例",
                "code": """
# ファイル1: user_service.py
def validate_user_email(email):
    if not email:
        return False
    if '@' not in email:
        return False
    if len(email) < 5:
        return False
    if email.count('@') != 1:
        return False
    return True

def send_welcome_email(email):
    # メール送信前のバリデーション
    if not email:
        return False
    if '@' not in email:
        return False
    if len(email) < 5:
        return False
    if email.count('@') != 1:
        return False
    
    # メール送信処理
    print(f"Welcome email sent to {email}")
    return True

# ファイル2: newsletter_service.py  
def subscribe_newsletter(email):
    # 同じバリデーションロジック
    if not email:
        return False
    if '@' not in email:
        return False
    if len(email) < 5:
        return False
    if email.count('@') != 1:
        return False
    
    # ニュースレター登録処理
    print(f"Newsletter subscription for {email}")
    return True
""",
                "problems": [
                    "同じバリデーションロジックが3箇所に重複",
                    "修正時に3箇所すべてを変更する必要",
                    "一箇所だけ修正漏れのリスク",
                    "コードの肥大化"
                ]
            },
            
            "good_example": {
                "description": "重複を解消した良い例",
                "code": """
# email_validator.py
def validate_email(email):
    \"\"\"メールアドレスのバリデーション\"\"\"
    if not email:
        return False
    if '@' not in email:
        return False
    if len(email) < 5:
        return False
    if email.count('@') != 1:
        return False
    return True

# user_service.py
from email_validator import validate_email

def validate_user_email(email):
    return validate_email(email)

def send_welcome_email(email):
    if not validate_email(email):
        return False
    
    print(f"Welcome email sent to {email}")
    return True

# newsletter_service.py
from email_validator import validate_email

def subscribe_newsletter(email):
    if not validate_email(email):
        return False
    
    print(f"Newsletter subscription for {email}")
    return True
""",
                "improvements": [
                    "バリデーションロジックを1箇所に集約",
                    "再利用可能な関数として抽出",
                    "修正時は1箇所のみ変更すればOK",
                    "テストも1箇所で完結"
                ]
            }
        }
        
        return examples
    
    def generate_refactoring_steps(self, duplicate_info):
        """リファクタリング手順を生成"""
        steps = []
        
        if duplicate_info["type"] == "exact_duplication":
            steps = [
                {
                    "step": 1,
                    "action": "重複コードの特定",
                    "description": "完全に同じコードブロックを洗い出す",
                    "tools": ["diff ツール", "IDE の重複検出機能"]
                },
                {
                    "step": 2,
                    "action": "共通関数・メソッドの抽出",
                    "description": "重複部分を独立した関数として切り出し",
                    "considerations": ["適切な関数名の選択", "引数の設計", "戻り値の定義"]
                },
                {
                    "step": 3,
                    "action": "元コードの置き換え",
                    "description": "重複していた箇所を新しい関数呼び出しに置換",
                    "precautions": ["一箇所ずつ慎重に変更", "テストの実行確認"]
                },
                {
                    "step": 4,
                    "action": "テストとレビュー",
                    "description": "動作確認と品質チェック",
                    "activities": ["単体テスト実行", "統合テスト実行", "コードレビュー"]
                }
            ]
        
        return steps
    
    def calculate_duplication_metrics(self, code_files):
        """重複メトリクスを計算"""
        total_lines = sum(len(f.get("content", "").split('
')) for f in code_files)
        
        duplicates = self.detect_duplicates(code_files)
        duplicate_lines = sum(d["length"] for d in duplicates)
        
        return {
            "total_lines": total_lines,
            "duplicate_lines": duplicate_lines,
            "duplication_ratio": (duplicate_lines / total_lines * 100) if total_lines > 0 else 0,
            "duplicate_blocks": len(duplicates),
            "severity_breakdown": self.calculate_severity_breakdown(duplicates)
        }
    
    def calculate_severity_breakdown(self, duplicates):
        """深刻度別の内訳を計算"""
        breakdown = {"高": 0, "中": 0, "低": 0}
        
        for duplicate in duplicates:
            severity = duplicate.get("severity", "低")
            breakdown[severity] += 1
        
        return breakdown
    
    # ヘルパーメソッド
    def filter_significant_duplicates(self, duplicates):
        """意味のある重複のみを抽出"""
        # 最小行数や最小文字数でフィルタリング
        return [d for d in duplicates if d.get("length", 0) >= 5]
    
    def find_structural_matches(self, file1, file2):
        """構造的重複を検出（簡略化）"""
        # 実際の実装では AST (Abstract Syntax Tree) を使用
        return []

# 使用例
analyzer = DuplicateCodeAnalyzer()

# サンプルファイル
sample_files = [
    {
        "name": "user_service.py",
        "content": """
def validate_email(email):
    if not email:
        return False
    if '@' not in email:
        return False
    return True

def process_user(data):
    # 処理...
    pass
"""
    },
    {
        "name": "order_service.py", 
        "content": """
def validate_email(email):
    if not email:
        return False
    if '@' not in email:
        return False
    return True

def process_order(data):
    # 処理...
    pass
"""
    }
]

# 重複検出
duplicates = analyzer.detect_duplicates(sample_files)
print(f"検出された重複: {len(duplicates)}個")

# メトリクス計算
metrics = analyzer.calculate_duplication_metrics(sample_files)
print(f"重複率: {metrics['duplication_ratio']:.1f}%")

# 例の取得
examples = analyzer.create_examples()
print("悪い例の問題点:", len(examples["bad_example"]["problems"]))

重複コードは最も基本的なコード臭ですが、適切に対処することで大きな改善効果を得られます。

長いメソッド（Long Method）

メソッドが長すぎることで生じるコード臭です。

// 長いメソッド分析システム
class LongMethodAnalyzer {
    constructor() {
        this.thresholds = {
            "warning": 20,      // 20行以上で警告
            "error": 50,        // 50行以上でエラー
            "critical": 100     // 100行以上で重大
        };
        
        this.complexityFactors = {
            "nested_loops": 2,       // ネストしたループ
            "conditional_depth": 1.5, // 条件分岐の深さ
            "try_catch_blocks": 1.2,  // 例外処理
            "function_calls": 0.1     // 関数呼び出し
        };
        
        this.refactoringPatterns = {
            "extract_method": {
                "description": "メソッドの抽出",
                "when_to_use": "独立した処理ブロックがある場合",
                "difficulty": "低",
                "example": "バリデーション処理、計算処理の分離"
            },
            "replace_temp_with_query": {
                "description": "一時変数をクエリで置換",
                "when_to_use": "複雑な計算を一時変数に格納している場合",
                "difficulty": "中",
                "example": "計算結果を返すメソッドの作成"
            },
            "introduce_parameter_object": {
                "description": "パラメータオブジェクトの導入",
                "when_to_use": "多数のパラメータがある場合",
                "difficulty": "中",
                "example": "設定オブジェクトや条件オブジェクト"
            },
            "decompose_conditional": {
                "description": "条件記述の分解",
                "when_to_use": "複雑な条件分岐がある場合",
                "difficulty": "中",
                "example": "条件判定を別メソッドに分離"
            }
        };
    }
    
    analyzeMethod(methodCode, methodName) {
        """メソッドを分析"""
        const analysis = {
            method_name: methodName,
            line_count: this.countLines(methodCode),
            complexity_score: this.calculateComplexity(methodCode),
            severity: "",
            issues: [],
            suggestions: [],
            refactoring_plan: {}
        };
        
        // 深刻度の判定
        analysis.severity = this.determineSeverity(analysis.line_count);
        
        // 問題点の特定
        analysis.issues = this.identifyIssues(methodCode, analysis);
        
        // 改善提案の生成
        analysis.suggestions = this.generateSuggestions(analysis);
        
        // リファクタリング計画
        if (analysis.severity !== "良好") {
            analysis.refactoring_plan = this.createRefactoringPlan(methodCode, analysis);
        }
        
        return analysis;
    }
    
    countLines(code) {
        """有効行数をカウント"""
        const lines = code.split('
');
        return lines.filter(line => {
            const trimmed = line.trim();
            return trimmed.length > 0 && 
                   !trimmed.startsWith('//') && 
                   !trimmed.startsWith('/*') &&
                   trimmed !== '{' &&
                   trimmed !== '}';
        }).length;
    }
    
    calculateComplexity(code) {
        """コードの複雑度を計算"""
        let complexity = 1; // 基本複雑度
        
        // ネストしたループの検出
        const nestedLoops = this.countNestedLoops(code);
        complexity += nestedLoops * this.complexityFactors.nested_loops;
        
        // 条件分岐の深さ
        const conditionalDepth = this.calculateConditionalDepth(code);
        complexity += conditionalDepth * this.complexityFactors.conditional_depth;
        
        // try-catch ブロック
        const tryCatchBlocks = this.countTryCatchBlocks(code);
        complexity += tryCatchBlocks * this.complexityFactors.try_catch_blocks;
        
        return Math.round(complexity * 10) / 10;
    }
    
    createExamples() {
        """長いメソッドの例を作成"""
        return {
            "bad_example": {
                "description": "長すぎるメソッドの例",
                "code": `
function processOrder(orderData) {
    // 入力値検証
    if (!orderData) {
        throw new Error('Order data is required');
    }
    if (!orderData.items || orderData.items.length === 0) {
        throw new Error('Order must have items');
    }
    if (!orderData.customer) {
        throw new Error('Customer information is required');
    }
    if (!orderData.customer.email) {
        throw new Error('Customer email is required');
    }
    if (!orderData.customer.address) {
        throw new Error('Customer address is required');
    }
    
    // 商品の在庫確認
    let stockIssues = [];
    for (let item of orderData.items) {
        if (!item.productId) {
            stockIssues.push('Product ID missing for item');
            continue;
        }
        
        let stock = getStockLevel(item.productId);
        if (stock < item.quantity) {
            stockIssues.push(\`Insufficient stock for product \${item.productId}\`);
        }
        
        // 商品価格の確認
        let currentPrice = getCurrentPrice(item.productId);
        if (Math.abs(currentPrice - item.price) > 0.01) {
            stockIssues.push(\`Price mismatch for product \${item.productId}\`);
        }
    }
    
    if (stockIssues.length > 0) {
        throw new Error('Stock issues: ' + stockIssues.join(', '));
    }
    
    // 金額計算
    let subtotal = 0;
    for (let item of orderData.items) {
        subtotal += item.price * item.quantity;
    }
    
    // 税金計算
    let taxRate = 0.1;
    if (orderData.customer.address.country === 'US') {
        taxRate = 0.08;
    } else if (orderData.customer.address.country === 'EU') {
        taxRate = 0.2;
    }
    let tax = subtotal * taxRate;
    
    // 送料計算
    let shipping = 0;
    if (subtotal < 50) {
        shipping = 10;
    } else if (subtotal < 100) {
        shipping = 5;
    }
    
    // 割引適用
    let discount = 0;
    if (orderData.couponCode) {
        let coupon = getCoupon(orderData.couponCode);
        if (coupon && coupon.isValid) {
            if (coupon.type === 'percentage') {
                discount = subtotal * (coupon.value / 100);
            } else {
                discount = coupon.value;
            }
        }
    }
    
    let total = subtotal + tax + shipping - discount;
    
    // 支払い処理
    let paymentResult;
    try {
        paymentResult = processPayment({
            amount: total,
            paymentMethod: orderData.paymentMethod,
            customer: orderData.customer
        });
    } catch (error) {
        throw new Error('Payment failed: ' + error.message);
    }
    
    // 在庫減算
    for (let item of orderData.items) {
        updateStock(item.productId, -item.quantity);
    }
    
    // 注文レコード作成
    let order = {
        id: generateOrderId(),
        customer: orderData.customer,
        items: orderData.items,
        subtotal: subtotal,
        tax: tax,
        shipping: shipping,
        discount: discount,
        total: total,
        paymentId: paymentResult.id,
        status: 'confirmed',
        createdAt: new Date()
    };
    
    saveOrder(order);
    
    // 確認メール送信
    sendOrderConfirmationEmail(order);
    
    return order;
}`,
                "problems": [
                    "70行を超える長大なメソッド",
                    "複数の責任を持っている（検証、計算、支払い、保存）",
                    "理解が困難",
                    "テストが複雑",
                    "再利用が困難"
                ]
            },
            
            "good_example": {
                "description": "適切に分割したメソッドの例",
                "code": `
function processOrder(orderData) {
    validateOrderData(orderData);
    validateStock(orderData.items);
    
    const pricing = calculateOrderPricing(orderData);
    const paymentResult = processOrderPayment(pricing.total, orderData);
    
    updateInventory(orderData.items);
    const order = createOrderRecord(orderData, pricing, paymentResult);
    
    sendOrderConfirmationEmail(order);
    
    return order;
}

function validateOrderData(orderData) {
    if (!orderData) {
        throw new Error('Order data is required');
    }
    validateOrderItems(orderData.items);
    validateCustomerInfo(orderData.customer);
}

function validateOrderItems(items) {
    if (!items || items.length === 0) {
        throw new Error('Order must have items');
    }
}

function validateCustomerInfo(customer) {
    if (!customer) {
        throw new Error('Customer information is required');
    }
    if (!customer.email) {
        throw new Error('Customer email is required');
    }
    if (!customer.address) {
        throw new Error('Customer address is required');
    }
}

function validateStock(items) {
    const stockIssues = [];
    
    for (const item of items) {
        validateItemStock(item, stockIssues);
    }
    
    if (stockIssues.length > 0) {
        throw new Error('Stock issues: ' + stockIssues.join(', '));
    }
}

function calculateOrderPricing(orderData) {
    const subtotal = calculateSubtotal(orderData.items);
    const tax = calculateTax(subtotal, orderData.customer.address);
    const shipping = calculateShipping(subtotal);
    const discount = calculateDiscount(subtotal, orderData.couponCode);
    
    return {
        subtotal,
        tax,
        shipping,
        discount,
        total: subtotal + tax + shipping - discount
    };
}`,
                "improvements": [
                    "メソッドが短く理解しやすい",
                    "単一責任の原則に従っている",
                    "各メソッドが独立してテスト可能",
                    "再利用が容易",
                    "保守性が向上"
                ]
            }
        };
    }
    
    identifyRefactoringOpportunities(methodCode) {
        """リファクタリングの機会を特定"""
        const opportunities = [];
        
        // 独立した処理ブロックの検出
        const independentBlocks = this.findIndependentBlocks(methodCode);
        if (independentBlocks.length > 0) {
            opportunities.push({
                pattern: "extract_method",
                description: "独立した処理ブロックをメソッドに抽出",
                blocks: independentBlocks,
                priority: "高"
            });
        }
        
        // 複雑な条件分岐の検出
        const complexConditionals = this.findComplexConditionals(methodCode);
        if (complexConditionals.length > 0) {
            opportunities.push({
                pattern: "decompose_conditional",
                description: "複雑な条件分岐を分解",
                conditionals: complexConditionals,
                priority: "中"
            });
        }
        
        // 多数のパラメータの検出
        const parameterCount = this.countParameters(methodCode);
        if (parameterCount > 5) {
            opportunities.push({
                pattern: "introduce_parameter_object",
                description: "パラメータオブジェクトの導入",
                parameter_count: parameterCount,
                priority: "中"
            });
        }
        
        return opportunities;
    }
    
    generateRefactoringSteps(opportunities) {
        """リファクタリング手順を生成"""
        const steps = [];
        
        opportunities.forEach((opportunity, index) => {
            const pattern = this.refactoringPatterns[opportunity.pattern];
            
            steps.push({
                step: index + 1,
                pattern: opportunity.pattern,
                description: pattern.description,
                difficulty: pattern.difficulty,
                actions: this.getPatternActions(opportunity.pattern),
                expected_outcome: this.getExpectedOutcome(opportunity.pattern)
            });
        });
        
        return steps;
    }
    
    // ヘルパーメソッド（簡略化）
    determineSeverity(lineCount) {
        if (lineCount >= this.thresholds.critical) return "重大";
        if (lineCount >= this.thresholds.error) return "エラー";
        if (lineCount >= this.thresholds.warning) return "警告";
        return "良好";
    }
    
    identifyIssues(code, analysis) {
        const issues = [];
        if (analysis.line_count > this.thresholds.warning) {
            issues.push("メソッドが長すぎます");
        }
        if (analysis.complexity_score > 10) {
            issues.push("複雑度が高すぎます");
        }
        return issues;
    }
    
    generateSuggestions(analysis) {
        return ["メソッドを小さな機能に分割してください"];
    }
    
    createRefactoringPlan(code, analysis) {
        return {
            priority: "高",
            estimated_effort: "2-4時間",
            approach: "段階的分割"
        };
    }
    
    countNestedLoops(code) { return 1; }
    calculateConditionalDepth(code) { return 2; }
    countTryCatchBlocks(code) { return 1; }
    findIndependentBlocks(code) { return ["validation", "calculation"]; }
    findComplexConditionals(code) { return ["tax calculation"]; }
    countParameters(code) { return 3; }
    getPatternActions(pattern) { return ["分析", "抽出", "テスト"]; }
    getExpectedOutcome(pattern) { return "保守性向上"; }
}

// 使用例
const analyzer = new LongMethodAnalyzer();

// 長いメソッドのサンプル
const longMethodCode = `
function processOrder(orderData) {
    // 70行のコード...
    // バリデーション、計算、支払い処理など
}`;

// 分析実行
const analysis = analyzer.analyzeMethod(longMethodCode, "processOrder");
console.log("行数:", analysis.line_count);
console.log("深刻度:", analysis.severity);

// 例の取得
const examples = analyzer.createExamples();
console.log("悪い例の問題点:", examples.bad_example.problems.length);

// リファクタリング機会の特定
const opportunities = analyzer.identifyRefactoringOpportunities(longMethodCode);
console.log("リファクタリング機会:", opportunities.length);

長いメソッドは段階的に分割することで、保守性と可読性を大幅に改善できます。

大きなクラス（Large Class）

クラスが大きすぎることで生じる問題と解決策を説明します。

# 大きなクラス分析システム
class LargeClassAnalyzer:
    def __init__(self):
        self.size_thresholds = {
            "method_count": {"warning": 15, "error": 25, "critical": 40},
            "line_count": {"warning": 200, "error": 500, "critical": 1000},
            "field_count": {"warning": 10, "error": 20, "critical": 30},
            "responsibility_count": {"warning": 3, "error": 5, "critical": 8}
        }
        
        self.refactoring_strategies = {
            "extract_class": {
                "description": "クラスの抽出",
                "when": "明確に分離可能な責任がある場合",
                "difficulty": "中",
                "benefit": "単一責任原則の実現"
            },
            "extract_interface": {
                "description": "インターフェースの抽出",
                "when": "複数の異なる使われ方をしている場合",
                "difficulty": "低",
                "benefit": "依存関係の改善"
            },
            "replace_inheritance_with_delegation": {
                "description": "継承を委譲に変更",
                "when": "継承による肥大化の場合",
                "difficulty": "高",
                "benefit": "柔軟性の向上"
            },
            "move_method": {
                "description": "メソッドの移動",
                "when": "他のクラスでより適切な場所がある場合",
                "difficulty": "低",
                "benefit": "凝集度の向上"
            }
        }
    
    def analyze_class(self, class_info):
        """クラスを分析"""
        analysis = {
            "class_name": class_info["name"],
            "size_metrics": self.calculate_size_metrics(class_info),
            "responsibilities": self.identify_responsibilities(class_info),
            "coupling_analysis": self.analyze_coupling(class_info),
            "cohesion_score": self.calculate_cohesion(class_info),
            "severity": "",
            "issues": [],
            "refactoring_suggestions": []
        }
        
        # 深刻度の判定
        analysis["severity"] = self.determine_severity(analysis["size_metrics"])
        
        # 問題点の特定
        analysis["issues"] = self.identify_issues(analysis)
        
        # リファクタリング提案
        analysis["refactoring_suggestions"] = self.generate_refactoring_suggestions(analysis)
        
        return analysis
    
    def calculate_size_metrics(self, class_info):
        """サイズメトリクスを計算"""
        return {
            "method_count": len(class_info.get("methods", [])),
            "line_count": class_info.get("line_count", 0),
            "field_count": len(class_info.get("fields", [])),
            "constructor_count": len(class_info.get("constructors", [])),
            "inner_class_count": len(class_info.get("inner_classes", []))
        }
    
    def identify_responsibilities(self, class_info):
        """責任を特定"""
        responsibilities = []
        
        methods = class_info.get("methods", [])
        
        # メソッド名から責任を推測
        method_categories = {
            "data_access": [],
            "business_logic": [],
            "ui_interaction": [],
            "validation": [],
            "formatting": [],
            "communication": []
        }
        
        for method in methods:
            method_name = method.get("name", "").lower()
            
            if any(keyword in method_name for keyword in ["get", "set", "load", "save", "find", "create", "update", "delete"]):
                method_categories["data_access"].append(method)
            elif any(keyword in method_name for keyword in ["calculate", "process", "compute", "analyze"]):
                method_categories["business_logic"].append(method)
            elif any(keyword in method_name for keyword in ["display", "show", "render", "draw"]):
                method_categories["ui_interaction"].append(method)
            elif any(keyword in method_name for keyword in ["validate", "check", "verify"]):
                method_categories["validation"].append(method)
            elif any(keyword in method_name for keyword in ["format", "convert", "transform"]):
                method_categories["formatting"].append(method)
            elif any(keyword in method_name for keyword in ["send", "receive", "notify", "communicate"]):
                method_categories["communication"].append(method)
        
        # 意味のあるカテゴリのみを責任として抽出
        for category, category_methods in method_categories.items():
            if len(category_methods) >= 2:  # 2つ以上のメソッドがあるカテゴリ
                responsibilities.append({
                    "name": category,
                    "method_count": len(category_methods),
                    "methods": [m["name"] for m in category_methods]
                })
        
        return responsibilities
    
    def create_examples(self):
        """大きなクラスの例を作成"""
        return {
            "bad_example": {
                "description": "責任が多すぎる大きなクラス",
                "code": """
class UserManager:
    def __init__(self):
        self.users = []
        self.database_connection = None
        self.email_service = None
        self.logger = None
        self.encryption_key = "secret"
        self.validation_rules = {}
        self.ui_templates = {}
        self.report_generator = None
        
    # データベース関連メソッド
    def connect_to_database(self):
        # データベース接続処理
        pass
    
    def save_user_to_database(self, user):
        # ユーザーをDBに保存
        pass
    
    def load_user_from_database(self, user_id):
        # DBからユーザーを読み込み
        pass
    
    def update_user_in_database(self, user):
        # DBのユーザー情報を更新
        pass
    
    def delete_user_from_database(self, user_id):
        # DBからユーザーを削除
        pass
    
    # ユーザー検証関連メソッド
    def validate_email(self, email):
        # メールアドレス検証
        pass
    
    def validate_password(self, password):
        # パスワード検証
        pass
    
    def validate_phone_number(self, phone):
        # 電話番号検証
        pass
    
    def validate_user_data(self, user_data):
        # ユーザーデータ総合検証
        pass
    
    # パスワード暗号化関連メソッド
    def encrypt_password(self, password):
        # パスワード暗号化
        pass
    
    def decrypt_password(self, encrypted_password):
        # パスワード復号化
        pass
    
    def hash_password(self, password):
        # パスワードハッシュ化
        pass
    
    # メール送信関連メソッド
    def send_welcome_email(self, user):
        # ウェルカムメール送信
        pass
    
    def send_password_reset_email(self, user):
        # パスワードリセットメール送信
        pass
    
    def send_notification_email(self, user, message):
        # 通知メール送信
        pass
    
    # UI表示関連メソッド
    def render_user_profile(self, user):
        # ユーザープロフィール表示
        pass
    
    def render_user_list(self, users):
        # ユーザーリスト表示
        pass
    
    def render_login_form(self):
        # ログインフォーム表示
        pass
    
    # レポート生成関連メソッド
    def generate_user_report(self):
        # ユーザーレポート生成
        pass
    
    def generate_activity_report(self):
        # アクティビティレポート生成
        pass
    
    def export_users_to_csv(self):
        # CSV出力
        pass
    
    # ログ関連メソッド
    def log_user_action(self, user, action):
        # ユーザーアクション記録
        pass
    
    def log_system_event(self, event):
        # システムイベント記録
        pass
    
    # セッション管理関連メソッド
    def create_user_session(self, user):
        # セッション作成
        pass
    
    def validate_session(self, session_id):
        # セッション検証
        pass
    
    def destroy_session(self, session_id):
        # セッション破棄
        pass""",
                "problems": [
                    "25個以上のメソッドを持つ巨大クラス",
                    "8つ以上の異なる責任を持っている",
                    "データベース、UI、メール、暗号化などが混在",
                    "単一責任原則に違反",
                    "テストが困難",
                    "修正時の影響範囲が大きい"
                ]
            },
            
            "good_example": {
                "description": "責任を分離した適切な設計",
                "code": """
# ユーザー管理のコアロジック
class UserService:
    def __init__(self, user_repository, email_service, encryption_service):
        self.user_repository = user_repository
        self.email_service = email_service
        self.encryption_service = encryption_service
    
    def create_user(self, user_data):
        validator = UserValidator()
        if validator.validate(user_data):
            user = User(user_data)
            self.user_repository.save(user)
            self.email_service.send_welcome_email(user)
            return user
        raise ValidationError("Invalid user data")
    
    def authenticate_user(self, email, password):
        user = self.user_repository.find_by_email(email)
        if user and self.encryption_service.verify_password(password, user.password_hash):
            return user
        return None

# データアクセス層
class UserRepository:
    def __init__(self, database_connection):
        self.db = database_connection
    
    def save(self, user):
        # ユーザーをDBに保存
        pass
    
    def find_by_id(self, user_id):
        # IDでユーザーを検索
        pass
    
    def find_by_email(self, email):
        # メールアドレスでユーザーを検索
        pass
    
    def update(self, user):
        # ユーザー情報を更新
        pass
    
    def delete(self, user_id):
        # ユーザーを削除
        pass

# 検証ロジック
class UserValidator:
    def validate(self, user_data):
        return (self.validate_email(user_data.get('email')) and
                self.validate_password(user_data.get('password')))
    
    def validate_email(self, email):
        # メールアドレス検証
        pass
    
    def validate_password(self, password):
        # パスワード検証
        pass

# 暗号化サービス
class EncryptionService:
    def hash_password(self, password):
        # パスワードハッシュ化
        pass
    
    def verify_password(self, password, password_hash):
        # パスワード検証
        pass

# メールサービス
class EmailService:
    def send_welcome_email(self, user):
        # ウェルカムメール送信
        pass
    
    def send_password_reset_email(self, user):
        # パスワードリセットメール送信
        pass

# UI層
class UserController:
    def __init__(self, user_service):
        self.user_service = user_service
    
    def register_user(self, request):
        # ユーザー登録処理
        pass
    
    def login_user(self, request):
        # ログイン処理
        pass

# レポート生成
class UserReportGenerator:
    def __init__(self, user_repository):
        self.user_repository = user_repository
    
    def generate_user_activity_report(self):
        # レポート生成
        pass""",
                "improvements": [
                    "各クラスが単一の責任を持つ",
                    "依存関係が明確",
                    "個別にテスト可能",
                    "保守性が向上",
                    "再利用性が高い",
                    "修正の影響範囲が限定的"
                ]
            }
        }
    
    def generate_decomposition_plan(self, class_analysis):
        """クラス分解計画を生成"""
        plan = {
            "current_class": class_analysis["class_name"],
            "target_classes": [],
            "extraction_steps": [],
            "dependencies": [],
            "testing_strategy": []
        }
        
        responsibilities = class_analysis["responsibilities"]
        
        # 責任ごとに新しいクラスを提案
        for responsibility in responsibilities:
            if responsibility["method_count"] >= 3:  # 3つ以上のメソッドがある責任
                target_class_name = self.generate_class_name(responsibility["name"])
                plan["target_classes"].append({
                    "name": target_class_name,
                    "responsibility": responsibility["name"],
                    "methods_to_move": responsibility["methods"],
                    "estimated_size": responsibility["method_count"]
                })
        
        # 抽出手順の生成
        plan["extraction_steps"] = self.generate_extraction_steps(plan["target_classes"])
        
        # 依存関係の分析
        plan["dependencies"] = self.analyze_dependencies(plan["target_classes"])
        
        # テスト戦略
        plan["testing_strategy"] = self.create_testing_strategy(plan["target_classes"])
        
        return plan
    
    def generate_class_name(self, responsibility):
        """責任に基づいてクラス名を生成"""
        name_mapping = {
            "data_access": "Repository",
            "business_logic": "Service", 
            "ui_interaction": "Controller",
            "validation": "Validator",
            "formatting": "Formatter",
            "communication": "NotificationService"
        }
        
        return name_mapping.get(responsibility, "Service")
    
    # ヘルパーメソッド
    def analyze_coupling(self, class_info):
        return {"efferent": 5, "afferent": 3}
    
    def calculate_cohesion(self, class_info):
        return 0.6
    
    def determine_severity(self, size_metrics):
        method_count = size_metrics["method_count"]
        if method_count >= self.size_thresholds["method_count"]["critical"]:
            return "重大"
        elif method_count >= self.size_thresholds["method_count"]["error"]:
            return "エラー"
        elif method_count >= self.size_thresholds["method_count"]["warning"]:
            return "警告"
        return "良好"
    
    def identify_issues(self, analysis):
        issues = []
        if analysis["size_metrics"]["method_count"] > 20:
            issues.append("メソッド数が多すぎます")
        if len(analysis["responsibilities"]) > 4:
            issues.append("責任が多すぎます")
        return issues
    
    def generate_refactoring_suggestions(self, analysis):
        return ["クラスを責任ごとに分割してください"]
    
    def generate_extraction_steps(self, target_classes):
        return [f"{cls['name']} クラスの抽出" for cls in target_classes]
    
    def analyze_dependencies(self, target_classes):
        return ["依存関係の整理が必要"]
    
    def create_testing_strategy(self, target_classes):
        return ["各クラスの単体テスト作成"]

# 使用例
analyzer = LargeClassAnalyzer()

# サンプルクラス情報
sample_class = {
    "name": "UserManager",
    "line_count": 800,
    "methods": [
        {"name": "save_user"}, {"name": "load_user"}, {"name": "validate_email"},
        {"name": "encrypt_password"}, {"name": "send_email"}, {"name": "render_ui"},
        {"name": "generate_report"}, {"name": "log_action"}
    ] * 4,  # 32個のメソッド
    "fields": ["users", "database", "email_service"] * 3,  # 9個のフィールド
    "constructors": [{"name": "__init__"}],
    "inner_classes": []
}

# 分析実行
analysis = analyzer.analyze_class(sample_class)
print("クラス名:", analysis["class_name"])
print("メソッド数:", analysis["size_metrics"]["method_count"])
print("責任数:", len(analysis["responsibilities"]))
print("深刻度:", analysis["severity"])

# 例の取得
examples = analyzer.create_examples()
print("悪い例の問題点:", len(examples["bad_example"]["problems"]))

# 分解計画の生成
decomposition_plan = analyzer.generate_decomposition_plan(analysis)
print("提案されるクラス数:", len(decomposition_plan["target_classes"]))

大きなクラスは責任を分離することで、保守性と可読性を大幅に改善できます。

実践的な検出方法

コード臭を効率的に検出するための実践的な方法を紹介します。

自動化ツールの活用

コード臭検出ツールの使い方と効果的な活用法を解説します。

// コード臭検出ツール統合システム
class CodeSmellDetectionTools {
    constructor() {
        this.tools = {
            "eslint": {
                "type": "JavaScript",
                "strengths": ["構文チェック", "コーディング規約", "基本的な複雑度"],
                "limitations": ["設計レベルの問題検出不可"],
                "config_example": {
                    "rules": {
                        "complexity": ["error", 10],
                        "max-lines": ["error", 300],
                        "max-lines-per-function": ["error", 50],
                        "max-params": ["error", 4]
                    }
                }
            },
            "sonarqube": {
                "type": "Multi-language",
                "strengths": ["包括的な品質分析", "技術的負債計測", "重複コード検出"],
                "limitations": ["設定が複雑", "リソース消費大"],
                "metrics": ["複雑度", "重複率", "保守性指数", "信頼性評価"]
            },
            "codeclimate": {
                "type": "Multi-language",
                "strengths": ["CI/CD統合", "トレンド分析", "自動レポート"],
                "limitations": ["有料プラン必要", "カスタマイズ制限"],
                "features": ["品質スコア", "ホットスポット検出", "テスト被覆率"]
            },
            "pylint": {
                "type": "Python",
                "strengths": ["詳細なコード分析", "PEP8準拠", "設計パターン検出"],
                "limitations": ["Python特化", "誤検知あり"],
                "categories": ["エラー", "警告", "リファクタリング", "規約"]
            }
        };
        
        this.integration_strategies = {
            "development_workflow": {
                "pre_commit": "コミット前の自動チェック",
                "ci_pipeline": "CI/CDパイプラインでの品質ゲート",
                "ide_integration": "開発中のリアルタイム検出",
                "pull_request": "プルリクエスト時の自動レビュー"
            },
            "team_adoption": {
                "gradual_introduction": "段階的なツール導入",
                "rule_customization": "チーム固有ルールの設定",
                "education": "ツール理解のための教育",
                "metrics_tracking": "改善メトリクスの追跡"
            }
        };
    }
    
    createToolConfiguration(projectType, teamSize, complexity) {
        """プロジェクトに適したツール設定を作成"""
        const config = {
            recommended_tools: [],
            configuration: {},
            implementation_plan: [],
            expected_benefits: []
        };
        
        // プロジェクトタイプに基づくツール選択
        if (projectType === "javascript") {
            config.recommended_tools.push("eslint", "sonarqube");
        } else if (projectType === "python") {
            config.recommended_tools.push("pylint", "sonarqube");
        } else {
            config.recommended_tools.push("sonarqube", "codeclimate");
        }
        
        // チームサイズに基づく調整
        if (teamSize > 10) {
            config.recommended_tools.push("codeclimate");
        }
        
        // 設定の生成
        config.configuration = this.generateToolConfigs(config.recommended_tools, complexity);
        
        // 実装計画
        config.implementation_plan = this.createImplementationPlan(config.recommended_tools);
        
        // 期待される効果
        config.expected_benefits = this.calculateExpectedBenefits(config.recommended_tools);
        
        return config;
    }
    
    generateToolConfigs(tools, complexity) {
        """ツール設定を生成"""
        const configs = {};
        
        tools.forEach(tool => {
            if (tool === "eslint") {
                configs.eslint = this.generateESLintConfig(complexity);
            } else if (tool === "sonarqube") {
                configs.sonarqube = this.generateSonarQubeConfig(complexity);
            } else if (tool === "pylint") {
                configs.pylint = this.generatePylintConfig(complexity);
            }
        });
        
        return configs;
    }
    
    generateESLintConfig(complexity) {
        """ESLint設定を生成"""
        const baseConfig = {
            "extends": ["eslint:recommended"],
            "env": {
                "browser": true,
                "node": true,
                "es2021": true
            },
            "rules": {
                "complexity": ["warn", complexity === "high" ? 15 : 10],
                "max-lines": ["warn", complexity === "high" ? 500 : 300],
                "max-lines-per-function": ["warn", complexity === "high" ? 80 : 50],
                "max-params": ["warn", complexity === "high" ? 6 : 4],
                "max-depth": ["warn", complexity === "high" ? 6 : 4],
                "max-nested-callbacks": ["warn", 3],
                "no-duplicate-code": "warn"
            }
        };
        
        if (complexity === "low") {
            // 初心者向けに厳しめの設定
            baseConfig.rules.complexity[1] = 8;
            baseConfig.rules["max-lines"][1] = 200;
            baseConfig.rules["max-lines-per-function"][1] = 30;
        }
        
        return baseConfig;
    }
    
    createDetectionWorkflow(tools) {
        """検出ワークフローを作成"""
        const workflow = {
            phases: [],
            automation_points: [],
            human_review_points: [],
            feedback_loop: []
        };
        
        // フェーズ定義
        workflow.phases = [
            {
                phase: "開発中検出",
                tools: ["IDE統合ツール"],
                frequency: "リアルタイム",
                scope: "変更ファイルのみ"
            },
            {
                phase: "コミット前検出",
                tools: ["pre-commit hooks"],
                frequency: "各コミット",
                scope: "変更ファイル"
            },
            {
                phase: "CI/CD検出",
                tools: tools,
                frequency: "各プッシュ",
                scope: "プロジェクト全体"
            },
            {
                phase: "定期的な全体検出",
                tools: ["包括的分析ツール"],
                frequency: "週次",
                scope: "全コードベース"
            }
        ];
        
        // 自動化ポイント
        workflow.automation_points = [
            "品質スコアの自動計算",
            "閾値超過時の自動アラート",
            "改善提案の自動生成",
            "トレンドレポートの自動作成"
        ];
        
        // 人手レビューポイント
        workflow.human_review_points = [
            "設計レベルの問題評価",
            "ビジネスロジックの妥当性確認",
            "アーキテクチャ影響の判断",
            "優先順位付け"
        ];
        
        return workflow;
    }
    
    setupContinuousImprovement(baseline_metrics) {
        """継続的改善システムをセットアップ"""
        const improvement_system = {
            metrics_tracking: {},
            improvement_goals: [],
            monitoring_dashboard: {},
            feedback_mechanisms: []
        };
        
        // メトリクス追跡設定
        improvement_system.metrics_tracking = {
            "code_smells": {
                "current": baseline_metrics.code_smells || 0,
                "target": Math.max(0, (baseline_metrics.code_smells || 0) * 0.8),
                "trend": "decreasing"
            },
            "complexity": {
                "current": baseline_metrics.complexity || 10,
                "target": Math.max(5, (baseline_metrics.complexity || 10) * 0.9),
                "trend": "decreasing"
            },
            "duplication": {
                "current": baseline_metrics.duplication || 0,
                "target": Math.max(0, (baseline_metrics.duplication || 0) * 0.5),
                "trend": "decreasing"
            },
            "maintainability": {
                "current": baseline_metrics.maintainability || 5,
                "target": Math.min(10, (baseline_metrics.maintainability || 5) * 1.2),
                "trend": "increasing"
            }
        };
        
        // 改善目標設定
        improvement_system.improvement_goals = [
            {
                "goal": "重複コード50%削減",
                "timeline": "3ヶ月",
                "success_criteria": "重複率が5%以下",
                "responsible_team": "開発チーム"
            },
            {
                "goal": "平均メソッド長20行以下",
                "timeline": "2ヶ月", 
                "success_criteria": "80%のメソッドが20行以下",
                "responsible_team": "各開発者"
            },
            {
                "goal": "複雑度10以下維持",
                "timeline": "継続",
                "success_criteria": "新規コードの複雑度10以下",
                "responsible_team": "全体"
            }
        ];
        
        return improvement_system;
    }
    
    generateActionPlan(detected_smells, priority_criteria) {
        """アクションプランを生成"""
        const action_plan = {
            immediate_actions: [],
            short_term_goals: [],
            long_term_strategies: [],
            resource_requirements: {}
        };
        
        // 深刻度と影響度に基づく優先順位付け
        const prioritized_smells = this.prioritizeSmells(detected_smells, priority_criteria);
        
        // 即座のアクション（1週間以内）
        const critical_smells = prioritized_smells.filter(smell => smell.priority === "critical");
        action_plan.immediate_actions = critical_smells.map(smell => ({
            smell_type: smell.type,
            location: smell.location,
            action: this.getImmediateAction(smell),
            estimated_effort: "1-3時間",
            assignee: "原作者"
        }));
        
        // 短期目標（1ヶ月以内）
        const high_priority_smells = prioritized_smells.filter(smell => smell.priority === "high");
        action_plan.short_term_goals = this.groupSmellsByType(high_priority_smells).map(group => ({
            smell_type: group.type,
            count: group.count,
            strategy: this.getRefactoringStrategy(group.type),
            estimated_effort: `${group.count * 2}時間`,
            milestone: "月末までに50%削減"
        }));
        
        // 長期戦略（3ヶ月以内）
        action_plan.long_term_strategies = [
            "コード臭予防のためのガイドライン策定",
            "自動検出ツールの本格導入",
            "定期的なコードレビュー文化の確立",
            "品質メトリクスの継続的監視"
        ];
        
        return action_plan;
    }
    
    // ヘルパーメソッド
    createImplementationPlan(tools) {
        return tools.map((tool, index) => ({
            step: index + 1,
            tool: tool,
            timeline: `${index + 1}週目`,
            effort: "設定・導入作業"
        }));
    }
    
    calculateExpectedBenefits(tools) {
        return [
            "コード品質向上",
            "バグ削減",
            "保守性改善",
            "開発効率向上"
        ];
    }
    
    generateSonarQubeConfig(complexity) {
        return {
            "sonar.projectKey": "project-key",
            "sonar.sources": "src",
            "sonar.language": "js",
            "sonar.javascript.lcov.reportPaths": "coverage/lcov.info"
        };
    }
    
    generatePylintConfig(complexity) {
        return {
            "max-line-length": complexity === "high" ? 120 : 100,
            "max-args": complexity === "high" ? 6 : 4,
            "max-locals": complexity === "high" ? 20 : 15
        };
    }
    
    prioritizeSmells(smells, criteria) {
        return smells.map(smell => ({
            ...smell,
            priority: this.calculatePriority(smell, criteria)
        }));
    }
    
    calculatePriority(smell, criteria) {
        // 簡略化された優先度計算
        if (smell.severity === "critical") return "critical";
        if (smell.impact === "high") return "high";
        return "medium";
    }
    
    getImmediateAction(smell) {
        const actions = {
            "Duplicate Code": "重複部分を関数に抽出",
            "Long Method": "メソッドを小さく分割",
            "Large Class": "クラスの責任を分離"
        };
        return actions[smell.type] || "リファクタリング実施";
    }
    
    groupSmellsByType(smells) {
        const groups = {};
        smells.forEach(smell => {
            if (!groups[smell.type]) {
                groups[smell.type] = { type: smell.type, count: 0 };
            }
            groups[smell.type].count++;
        });
        return Object.values(groups);
    }
    
    getRefactoringStrategy(smellType) {
        const strategies = {
            "Duplicate Code": "Extract Method パターン適用",
            "Long Method": "段階的メソッド分割",
            "Large Class": "Single Responsibility 原則適用"
        };
        return strategies[smellType] || "適切なリファクタリング手法の適用";
    }
}

// 使用例
const detectionTools = new CodeSmellDetectionTools();

// プロジェクト設定
const projectConfig = detectionTools.createToolConfiguration(
    "javascript",  // プロジェクトタイプ
    8,            // チームサイズ
    "medium"      // 複雑度
);
console.log("推奨ツール:", projectConfig.recommended_tools);

// ワークフロー作成
const workflow = detectionTools.createDetectionWorkflow(projectConfig.recommended_tools);
console.log("ワークフローフェーズ数:", workflow.phases.length);

// 継続的改善システム
const baseline = {
    code_smells: 25,
    complexity: 12,
    duplication: 8,
    maintainability: 6
};

const improvementSystem = detectionTools.setupContinuousImprovement(baseline);
console.log("改善目標数:", improvementSystem.improvement_goals.length);

自動化ツールを適切に設定・活用することで、効率的なコード臭検出が可能になります。

まとめ

コード臭は、プログラミング初心者が質の高いコードを書くために必ず理解しておくべき重要な概念です。 早期に発見し、適切に対処することで、保守性と可読性の高いコードを実現できます。

重要なポイントを整理しましょう。

• コード臭の理解: 動作するが問題のあるコードのサインを認識する
• 代表的な種類: 重複コード、長いメソッド、大きなクラスなど基本的なパターンを覚える
• 検出方法: 手動レビューと自動化ツールを組み合わせた効率的な検出
• 改善アプローチ: 段階的なリファクタリングによる継続的な品質向上
• 予防意識: コード臭を予防する設計とコーディング習慣の確立

コード臭を意識することで、「動けばいい」から「読みやすく保守しやすい」コードへとレベルアップできます。 特に初心者のうちから意識することで、将来的により高品質なプログラマーになることができるでしょう。

ぜひ、この記事で紹介した知識を実践で活用し、コード臭のない美しいコードを書けるエンジニアを目指してください。