Code Complexity Analyzer

What Is Cyclomatic Complexity?

Cyclomatic complexity (CC), introduced by Thomas McCabe in 1976, counts the number of linearly independent paths through a piece of code. The metric is derived from the control flow graph: each decision point (if, else if, for, while, case, catch, &&, ||, ternary) adds 1 to the base score of 1.

A function with cyclomatic complexity of 1 has a single straight-line path. Every branch doubles potential paths. The standard thresholds are:

• 1–10 — Simple, low risk. Easy to test and understand.
• 11–20 — Moderate complexity. Consider refactoring.
• 21+ — High complexity. Very difficult to test completely. Refactor urgently.

Cyclomatic complexity directly correlates with the minimum number of test cases needed for full branch coverage. A CC of 12 means you need at least 12 test cases to cover all paths.

What Is Cognitive Complexity?

Cognitive complexity, developed by G. Ann Campbell at SonarSource (2018), measures how hard code is to understand, not just how many paths it has. Unlike cyclomatic complexity, cognitive complexity penalizes nesting more heavily — each additional level of nesting adds an extra increment to the penalty for control structures inside it.

The key differences from cyclomatic complexity:

• Nested structures are penalized with a nesting increment (depth x 1 added per control flow statement)
• Logical operators in sequences (a && b && c) count as 1, not 2
• Recursion adds a penalty of 1
• Linear jumps (break, continue with labels) add 1

A function with cognitive complexity above 15 is considered hard to read. Above 25 is considered unmaintainable by most teams.

Nesting Depth and Why It Matters

Nesting depth measures the deepest level of nested control structures in a function. Each if, for, while, try, or switch that contains another adds a level. Deep nesting is the primary driver of cognitive complexity and is one of the most common sources of bugs in production code.

A nesting depth above 4 is a strong signal to extract inner blocks into helper functions. The early-return pattern (guard clauses) and strategy/command patterns are the most effective refactoring techniques for reducing nesting.

How to Reduce Complexity

// HIGH COMPLEXITY — nesting depth 4, CC 7
function processUser(user) {
  if (user) {
    if (user.active) {
      if (user.role === 'admin') {
        if (user.permissions.length > 0) {
          return user.permissions.map(p => p.name);
        }
      }
    }
  }
  return [];
}

// REFACTORED — nesting depth 1, CC 4
function processUser(user) {
  if (!user) return [];
  if (!user.active) return [];
  if (user.role !== 'admin') return [];
  if (user.permissions.length === 0) return [];
  return user.permissions.map(p => p.name);
}

The refactored version uses guard clauses (early returns) to eliminate nesting. This pattern is also called the "bouncer pattern" — fail fast and exit early, so the happy path remains at nesting level 0.