How to extract functions from long methods without breaking code

Extract Method is the most common refactoring in clean code work. You take a block of code inside a large function and move it into its own named function. Done correctly, behavior does not change — only structure does.

When to extract: any block of code that has a comment above it, any nested logic more than two levels deep, and any block you could give a name to.

// Before: comment signals an extraction candidate
function processOrder(order) {
  // Validate stock
  for (const item of order.items) {
    if (item.quantity > inventory[item.id]) {
      throw new Error(`Insufficient stock for ${item.id}`);
    }
  }
  // ... rest of processing
}

Extract the commented block:

function validateStockAvailability(items, inventory) {
  for (const item of items) {
    if (item.quantity > inventory[item.id]) {
      throw new Error(`Insufficient stock for ${item.id}`);
    }
  }
}

function processOrder(order) {
  validateStockAvailability(order.items, inventory);
  // ... rest of processing
}

Safe extraction steps:

1. Identify the block to extract and note every variable it reads and writes.

2. Variables it reads become parameters. Variables it writes become return values.

3. Create the new function. Replace the original block with a call to it.

4. Run your tests to confirm behavior is identical.

If you don't have tests, write a quick manual check before and after. Never extract without verifying behavior — even mechanical refactors can introduce bugs if variable scoping is mishandled.