Clean Code: The "Extract Method" Refactoring

If you've ever found yourself staring at a function that's a hundred lines long, trying to figure out what it all does, you know the pain of long methods. They are hard to read, hard to test, and hard to change without breaking something.

"Extract Method" is one of the most common and powerful refactoring techniques. The idea is simple: find a piece of code in a long method that can be grouped together, and move it into its own, well-named function.

From a Long Method to a Clear Story

Let's look at a classic example: a function that processes an order.

// Bad: A long method that handles validation, calculation, and discounts all at once.
function processOrder(order: Order): OrderResult {
  if (order.items.length === 0) {
    return { success: false, error: 'Order has no items' };
  }
  
  let total = 0;
  for (const item of order.items) {
    if (item.price < 0) {
      return { success: false, error: 'Invalid item price' };
    }
    total += item.price * item.quantity;
  }
  
  // Apply discounts
  if (order.customer.type === 'vip') {
    total *= 0.9;
  } else if (order.customer.type === 'premium') {
    total *= 0.95;
  }
  
  const tax = total * 0.1;
  const finalTotal = total + tax;
  
  return { success: true, total: finalTotal };
}

// Good: The main function now reads like a high-level summary.
function processOrder(order: Order): OrderResult {
  const validationResult = validateOrder(order);
  if (!validationResult.isValid) {
    return { success: false, error: validationResult.error };
  }
  
  const subtotal = calculateSubtotal(order.items);
  const discountedTotal = applyDiscounts(subtotal, order.customer);
  const finalTotal = addTax(discountedTotal);
  
  return { success: true, total: finalTotal };
}

function validateOrder(order: Order): ValidationResult {
  if (order.items.length === 0) {
    return { isValid: false, error: 'Order has no items' };
  }
  if (order.items.some(item => item.price < 0)) {
    return { isValid: false, error: 'Invalid item price' };
  }
  return { isValid: true };
}

function calculateSubtotal(items: OrderItem[]): number {
  return items.reduce((total, item) => 
    total + (item.price * item.quantity), 0
  );
}

function applyDiscounts(subtotal: number, customer: Customer): number {
  if (customer.type === 'vip') {
    return subtotal * 0.9;
  }
  if (customer.type === 'premium') {
    return subtotal * 0.95;
  }
  return subtotal;
}

function addTax(total: number): number {
  const taxRate = 0.1;
  return total * (1 + taxRate);
}

The refactored version is much easier to work with. Each function has a single responsibility, and the names of the functions document what they do.

Why Extract Methods?

• Readability: The original method is hard to scan. The refactored version tells a clear story.
• Testability: Each of the smaller functions can be tested in isolation. It's much easier to write a test for calculateSubtotal than for the original, monolithic processOrder.
• Reusability: You might find that you can reuse some of the extracted methods (like calculateSubtotal) in other parts of your application.
• Easier to change: If the discounting logic changes, you know you only need to modify the applyDiscounts function.

Guidelines for Extracting Methods

• Look for comments. Sometimes, a comment is a sign that a piece of code could be extracted into its own function with a name that makes the comment unnecessary.
• Keep it small. A function should ideally do one thing. If you can't give an extracted method a clear, concise name, it might be doing too much.
• No side effects. The best functions to extract are "pure" functions—they take some input, return some output, and don't modify anything else.

Extract Method is a simple but transformative refactoring. It's the key to turning long, procedural code into clean, well-structured, and maintainable object-oriented code.