Part 3: Refactoring Techniques and Patterns

Series Navigation: ← Part 2: Code Review Process | Part 4: Testing During Refactoring →

Introduction

In Parts 1 and 2, we established principles and review processes. Now it's time to get hands-on with actual refactoring techniques. These are patterns I've applied repeatedly across my TypeScript microservices, transforming legacy code into maintainable, testable systems.

A year ago, I inherited a payment processing service with a single 2,000-line file containing all the business logic. Through systematic refactoring using the techniques in this article, we transformed it into a well-organized service with proper separation of concerns. The result? Bug reports dropped by 70%, and new features that previously took weeks now take days.

The Refactoring Process

Before You Start

Rule #1: Never refactor without tests.

If tests don't exist, write them first. I learned this the hard way when I "improved" our order service and broke production. Now I follow this workflow religiously:

Write/verify tests for existing behavior
Refactor with tests passing
Verify tests still pass after refactoring
No new functionality during refactoring

The Safety Net

// Step 1: Add tests for current behavior (even if it's ugly)
describe('OrderService - Current Behavior', () => {
  it('should calculate total with tax and shipping', async () => {
    const service = new OrderService();
    const result = await service.calculateTotal({
      items: [
        { price: 100, quantity: 2 },
        { price: 50, quantity: 1 }
      ],
      state: 'CA',
      shippingMethod: 'standard'
    });
    
    // Document current behavior, even if it seems wrong
    expect(result).toBe(272.25); // 250 + 21.25 tax + 1 shipping
  });
});

Once tests are in place, refactor with confidence.

Technique 1: Extract Method

Problem: Long methods doing multiple things

This is the most common refactoring I perform. Functions grow organically until they're doing five different things.

Before: God Method

From my authentication service:

async function loginUser(email: string, password: string) {
  // Validate email format
  if (!email || !email.includes('@')) {
    throw new Error('Invalid email');
  }
  
  // Validate password
  if (!password || password.length < 8) {
    throw new Error('Password too short');
  }
  
  // Find user
  const user = await db.query(
    'SELECT * FROM users WHERE email = ?',
    [email]
  );
  
  if (!user) {
    throw new Error('User not found');
  }
  
  // Check password
  const isValid = await bcrypt.compare(password, user.password_hash);
  
  if (!isValid) {
    throw new Error('Invalid password');
  }
  
  // Check if account is active
  if (!user.is_active) {
    throw new Error('Account disabled');
  }
  
  // Create session
  const sessionId = crypto.randomUUID();
  await db.query(
    'INSERT INTO sessions (id, user_id, expires_at) VALUES (?, ?, ?)',
    [sessionId, user.id, new Date(Date.now() + 24 * 60 * 60 * 1000)]
  );
  
  // Log login
  await db.query(
    'INSERT INTO audit_log (user_id, action, timestamp) VALUES (?, ?, ?)',
    [user.id, 'login', new Date()]
  );
  
  return { user, sessionId };
}

After: Extracted Methods

class AuthenticationService {
  async loginUser(
    email: string, 
    password: string
  ): Promise<LoginResult> {
    this.validateCredentials(email, password);
    
    const user = await this.findAndVerifyUser(email, password);
    
    this.ensureAccountIsActive(user);
    
    const session = await this.createUserSession(user.id);
    
    await this.logLoginEvent(user.id);
    
    return { user, session };
  }

  private validateCredentials(email: string, password: string): void {
    if (!email || !email.includes('@')) {
      throw new InvalidEmailError(email);
    }
    
    if (!password || password.length < 8) {
      throw new WeakPasswordError('Password must be at least 8 characters');
    }
  }

  private async findAndVerifyUser(
    email: string,
    password: string
  ): Promise<User> {
    const user = await this.userRepository.findByEmail(email);
    
    if (!user) {
      throw new UserNotFoundError(email);
    }
    
    const isPasswordValid = await this.passwordService.verify(
      password,
      user.passwordHash
    );
    
    if (!isPasswordValid) {
      throw new InvalidPasswordError();
    }
    
    return user;
  }

  private ensureAccountIsActive(user: User): void {
    if (!user.isActive) {
      throw new AccountDisabledError(user.id);
    }
  }

  private async createUserSession(userId: string): Promise<Session> {
    return await this.sessionService.create(userId, {
      expiresIn: '24h'
    });
  }

  private async logLoginEvent(userId: string): Promise<void> {
    await this.auditLogger.log({
      userId,
      action: 'user.login',
      timestamp: new Date()
    });
  }
}

Benefits:

Main method reads like a story
Each method has single purpose
Easy to test individual steps
Easy to modify one step without affecting others

Technique 2: Extract Class

Problem: A class doing too many things

Before: God Class

From my e-commerce service:

class OrderService {
  async createOrder(customerId: string, items: OrderItem[]) { /* ... */ }
  
  async calculateTax(amount: number, state: string) { /* ... */ }
  
  async calculateShipping(weight: number, destination: string) { /* ... */ }
  
  async validateInventory(items: OrderItem[]) { /* ... */ }
  
  async reserveInventory(items: OrderItem[]) { /* ... */ }
  
  async sendConfirmationEmail(order: Order) { /* ... */ }
  
  async generateInvoice(order: Order) { /* ... */ }
  
  async processPayment(order: Order, paymentMethod: string) { /* ... */ }
}

This class has at least 5 different responsibilities!

After: Extracted Classes

// Core orchestration
class OrderService {
  constructor(
    private orderRepository: OrderRepository,
    private taxCalculator: TaxCalculator,
    private shippingCalculator: ShippingCalculator,
    private inventoryService: InventoryService,
    private paymentService: PaymentService,
    private notificationService: NotificationService,
    private invoiceGenerator: InvoiceGenerator
  ) {}

  async createOrder(
    customerId: string,
    items: OrderItem[]
  ): Promise<Order> {
    // Validate inventory
    await this.inventoryService.validateAvailability(items);
    
    // Calculate costs
    const subtotal = this.calculateSubtotal(items);
    const tax = await this.taxCalculator.calculate(subtotal, customerId);
    const shipping = await this.shippingCalculator.calculate(items, customerId);
    const total = subtotal + tax + shipping;
    
    // Create order
    const order = await this.orderRepository.create({
      customerId,
      items,
      subtotal,
      tax,
      shipping,
      total,
      status: OrderStatus.Pending
    });
    
    // Reserve inventory
    await this.inventoryService.reserve(order.id, items);
    
    return order;
  }

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

// Dedicated tax calculation
class TaxCalculator {
  constructor(
    private customerRepository: CustomerRepository,
    private taxRateRepository: TaxRateRepository
  ) {}

  async calculate(amount: number, customerId: string): Promise<number> {
    const customer = await this.customerRepository.findById(customerId);
    const taxRate = await this.taxRateRepository.getRate(
      customer.state,
      customer.taxExempt
    );
    
    return amount * taxRate;
  }
}

// Dedicated shipping calculation
class ShippingCalculator {
  constructor(
    private customerRepository: CustomerRepository,
    private shippingRateRepository: ShippingRateRepository
  ) {}

  async calculate(
    items: OrderItem[],
    customerId: string
  ): Promise<number> {
    const customer = await this.customerRepository.findById(customerId);
    const totalWeight = this.calculateWeight(items);
    
    return await this.shippingRateRepository.getRate(
      totalWeight,
      customer.shippingZone
    );
  }

  private calculateWeight(items: OrderItem[]): number {
    return items.reduce((sum, item) => 
      sum + (item.weight * item.quantity), 0
    );
  }
}

// Inventory management
class InventoryService {
  constructor(
    private inventoryRepository: InventoryRepository,
    private reservationRepository: ReservationRepository
  ) {}

  async validateAvailability(items: OrderItem[]): Promise<void> {
    for (const item of items) {
      const available = await this.inventoryRepository.getAvailableQuantity(
        item.productId
      );
      
      if (available < item.quantity) {
        throw new InsufficientInventoryError(item.productId, available);
      }
    }
  }

  async reserve(orderId: string, items: OrderItem[]): Promise<void> {
    for (const item of items) {
      await this.reservationRepository.create({
        orderId,
        productId: item.productId,
        quantity: item.quantity,
        expiresAt: new Date(Date.now() + 15 * 60 * 1000) // 15 minutes
      });
    }
  }
}

Benefits:

Each class has single responsibility
Easy to test in isolation
Can reuse components (TaxCalculator in other services)
Changes to tax logic don't affect shipping logic

Technique 3: Replace Conditional with Polymorphism

Problem: Large if/else or switch statements

This pattern appears frequently in payment and notification systems.

Before: Conditional Hell

class PaymentProcessor {
  async processPayment(
    order: Order,
    paymentMethod: string,
    paymentDetails: any
  ) {
    if (paymentMethod === 'credit_card') {
      // Validate credit card
      if (!paymentDetails.cardNumber || !paymentDetails.cvv) {
        throw new Error('Invalid card details');
      }
      
      // Process with credit card gateway
      const result = await fetch('https://card-gateway.com/charge', {
        method: 'POST',
        body: JSON.stringify({
          amount: order.total,
          card: paymentDetails.cardNumber,
          cvv: paymentDetails.cvv
        })
      });
      
      return result.json();
      
    } else if (paymentMethod === 'paypal') {
      // Validate PayPal
      if (!paymentDetails.paypalEmail) {
        throw new Error('Invalid PayPal email');
      }
      
      // Process with PayPal
      const result = await fetch('https://paypal-api.com/payment', {
        method: 'POST',
        body: JSON.stringify({
          amount: order.total,
          email: paymentDetails.paypalEmail
        })
      });
      
      return result.json();
      
    } else if (paymentMethod === 'bank_transfer') {
      // Validate bank account
      if (!paymentDetails.accountNumber || !paymentDetails.routingNumber) {
        throw new Error('Invalid bank details');
      }
      
      // Process bank transfer
      const result = await fetch('https://bank-api.com/transfer', {
        method: 'POST',
        body: JSON.stringify({
          amount: order.total,
          account: paymentDetails.accountNumber,
          routing: paymentDetails.routingNumber
        })
      });
      
      return result.json();
      
    } else {
      throw new Error('Unsupported payment method');
    }
  }
}

Adding a new payment method requires modifying this function!

After: Polymorphic Strategy

// Define interface
interface PaymentProvider {
  validate(details: PaymentDetails): void;
  charge(amount: number, details: PaymentDetails): Promise<PaymentResult>;
}

// Credit card implementation
class CreditCardProvider implements PaymentProvider {
  constructor(
    private gatewayClient: CreditCardGatewayClient,
    private cardValidator: CardValidator
  ) {}

  validate(details: CreditCardDetails): void {
    if (!details.cardNumber || !details.cvv) {
      throw new InvalidPaymentDetailsError('Missing card details');
    }
    
    if (!this.cardValidator.isValid(details.cardNumber)) {
      throw new InvalidCardNumberError(details.cardNumber);
    }
    
    if (!this.cardValidator.isValidCvv(details.cvv)) {
      throw new InvalidCvvError();
    }
  }

  async charge(
    amount: number,
    details: CreditCardDetails
  ): Promise<PaymentResult> {
    this.validate(details);
    
    return await this.gatewayClient.charge({
      amount,
      cardNumber: details.cardNumber,
      cvv: details.cvv,
      expiryDate: details.expiryDate
    });
  }
}

// PayPal implementation
class PayPalProvider implements PaymentProvider {
  constructor(private paypalClient: PayPalClient) {}

  validate(details: PayPalDetails): void {
    if (!details.email || !this.isValidEmail(details.email)) {
      throw new InvalidPaymentDetailsError('Invalid PayPal email');
    }
  }

  async charge(
    amount: number,
    details: PayPalDetails
  ): Promise<PaymentResult> {
    this.validate(details);
    
    return await this.paypalClient.createPayment({
      amount,
      email: details.email
    });
  }

  private isValidEmail(email: string): boolean {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }
}

// Bank transfer implementation
class BankTransferProvider implements PaymentProvider {
  constructor(private bankClient: BankClient) {}

  validate(details: BankTransferDetails): void {
    if (!details.accountNumber || !details.routingNumber) {
      throw new InvalidPaymentDetailsError('Missing bank details');
    }
  }

  async charge(
    amount: number,
    details: BankTransferDetails
  ): Promise<PaymentResult> {
    this.validate(details);
    
    return await this.bankClient.initiateTransfer({
      amount,
      accountNumber: details.accountNumber,
      routingNumber: details.routingNumber
    });
  }
}

// Payment processor uses strategy pattern
class PaymentProcessor {
  private providers: Map<PaymentMethodType, PaymentProvider>;

  constructor(
    creditCardProvider: CreditCardProvider,
    paypalProvider: PayPalProvider,
    bankTransferProvider: BankTransferProvider
  ) {
    this.providers = new Map([
      [PaymentMethodType.CreditCard, creditCardProvider],
      [PaymentMethodType.PayPal, paypalProvider],
      [PaymentMethodType.BankTransfer, bankTransferProvider]
    ]);
  }

  async processPayment(
    order: Order,
    paymentMethod: PaymentMethodType,
    paymentDetails: PaymentDetails
  ): Promise<PaymentResult> {
    const provider = this.providers.get(paymentMethod);
    
    if (!provider) {
      throw new UnsupportedPaymentMethodError(paymentMethod);
    }
    
    return await provider.charge(order.total, paymentDetails);
  }

  registerProvider(
    method: PaymentMethodType,
    provider: PaymentProvider
  ): void {
    this.providers.set(method, provider);
  }
}

Benefits:

Adding new payment method = create new class
No modification of existing code (Open/Closed Principle)
Each provider is independently testable
Clear separation of concerns

Technique 4: Introduce Parameter Object

Problem: Functions with many parameters

Before: Parameter Explosion

async function createUser(
  email: string,
  password: string,
  firstName: string,
  lastName: string,
  phoneNumber: string,
  address: string,
  city: string,
  state: string,
  zipCode: string,
  country: string,
  marketingOptIn: boolean,
  termsAccepted: boolean
) {
  // Implementation
}

// Calling this is painful
await createUser(
  '[email protected]',
  'password123',
  'John',
  'Doe',
  '+1234567890',
  '123 Main St',
  'New York',
  'NY',
  '10001',
  'USA',
  true,
  true
);

After: Parameter Object

interface CreateUserParams {
  email: string;
  password: string;
  profile: {
    firstName: string;
    lastName: string;
    phoneNumber: string;
  };
  address: {
    street: string;
    city: string;
    state: string;
    zipCode: string;
    country: string;
  };
  preferences: {
    marketingOptIn: boolean;
    termsAccepted: boolean;
  };
}

async function createUser(params: CreateUserParams): Promise<User> {
  // Implementation
}

// Much clearer
await createUser({
  email: '[email protected]',
  password: 'password123',
  profile: {
    firstName: 'John',
    lastName: 'Doe',
    phoneNumber: '+1234567890'
  },
  address: {
    street: '123 Main St',
    city: 'New York',
    state: 'NY',
    zipCode: '10001',
    country: 'USA'
  },
  preferences: {
    marketingOptIn: true,
    termsAccepted: true
  }
});

Benefits:

Self-documenting
Easy to add optional fields
Type-safe with TypeScript
Can validate the entire object

Technique 5: Replace Magic Numbers with Constants

Problem: Unexplained numbers in code

Before: Magic Everywhere

async function processOrder(order: Order) {
  if (order.total > 1000) {
    // Apply premium processing
    await processPriority(order, 2);
  } else {
    await processStandard(order, 5);
  }
  
  // Set expiration
  const expiresAt = new Date(Date.now() + 86400000);
  
  // Retry failed payments
  const maxRetries = 3;
  for (let i = 0; i < maxRetries; i++) {
    try {
      await chargePayment(order);
      break;
    } catch (error) {
      await sleep(1000 * Math.pow(2, i));
    }
  }
}

What do these numbers mean?

After: Named Constants

const PREMIUM_ORDER_THRESHOLD = 1000; // USD
const PREMIUM_PROCESSING_HOURS = 2;
const STANDARD_PROCESSING_HOURS = 5;
const ORDER_EXPIRATION_MS = 24 * 60 * 60 * 1000; // 24 hours
const MAX_PAYMENT_RETRIES = 3;
const INITIAL_RETRY_DELAY_MS = 1000;

async function processOrder(order: Order): Promise<void> {
  const isPremiumOrder = order.total > PREMIUM_ORDER_THRESHOLD;
  
  if (isPremiumOrder) {
    await this.processPriority(order, PREMIUM_PROCESSING_HOURS);
  } else {
    await this.processStandard(order, STANDARD_PROCESSING_HOURS);
  }
  
  const expiresAt = new Date(Date.now() + ORDER_EXPIRATION_MS);
  await this.orderRepository.setExpiration(order.id, expiresAt);
  
  await this.retryPayment(order);
}

private async retryPayment(order: Order): Promise<void> {
  for (let attempt = 0; attempt < MAX_PAYMENT_RETRIES; attempt++) {
    try {
      await this.paymentService.charge(order);
      return;
    } catch (error) {
      const delayMs = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt);
      await this.sleep(delayMs);
    }
  }
  
  throw new PaymentFailedError(
    `Payment failed after ${MAX_PAYMENT_RETRIES} attempts`
  );
}

Benefits:

Code explains itself
Easy to modify values
Constants can be moved to configuration
Reduces copy-paste errors

Technique 6: Null Object Pattern

Problem: Null checks everywhere

Before: Null Checks Everywhere

class OrderService {
  async getOrderTotal(orderId: string): Promise<number> {
    const order = await this.orderRepository.findById(orderId);
    
    if (!order) {
      return 0;
    }
    
    let total = 0;
    
    if (order.items) {
      for (const item of order.items) {
        if (item && item.price && item.quantity) {
          total += item.price * item.quantity;
        }
      }
    }
    
    if (order.discount) {
      total -= order.discount.amount || 0;
    }
    
    if (order.shipping) {
      total += order.shipping.cost || 0;
    }
    
    return total;
  }
}

After: Null Object Pattern

class NullOrder implements Order {
  get id(): string {
    return '';
  }
  
  get items(): OrderItem[] {
    return [];
  }
  
  get discount(): Discount {
    return new NullDiscount();
  }
  
  get shipping(): Shipping {
    return new NullShipping();
  }
  
  calculateTotal(): number {
    return 0;
  }
}

class NullDiscount implements Discount {
  get amount(): number {
    return 0;
  }
}

class NullShipping implements Shipping {
  get cost(): number {
    return 0;
  }
}

class OrderService {
  async getOrderTotal(orderId: string): Promise<number> {
    const order = await this.orderRepository.findById(orderId) 
      ?? new NullOrder();
    
    return order.calculateTotal();
  }
}

class Order {
  calculateTotal(): number {
    const itemsTotal = this.items.reduce(
      (sum, item) => sum + (item.price * item.quantity),
      0
    );
    
    const discountAmount = this.discount.amount;
    const shippingCost = this.shipping.cost;
    
    return itemsTotal - discountAmount + shippingCost;
  }
}

Real-World Refactoring: Complete Example

Here's a complete refactoring from my inventory service:

Before (380 lines in one file)

// inventory.service.ts - BEFORE
export class InventoryService {
  async checkAndReserve(orderId: string, items: any[]) {
    for (const item of items) {
      const stock = await db.query(
        'SELECT quantity FROM inventory WHERE product_id = ?',
        [item.productId]
      );
      
      if (!stock || stock.quantity < item.quantity) {
        throw new Error('Insufficient stock');
      }
      
      await db.query(
        'UPDATE inventory SET quantity = quantity - ? WHERE product_id = ?',
        [item.quantity, item.productId]
      );
      
      await db.query(
        'INSERT INTO reservations (order_id, product_id, quantity, created_at) VALUES (?, ?, ?, ?)',
        [orderId, item.productId, item.quantity, new Date()]
      );
    }
    
    // Clean up expired reservations
    await db.query(
      'DELETE FROM reservations WHERE created_at < ?',
      [new Date(Date.now() - 15 * 60 * 1000)]
    );
  }
}

After (Split into focused modules)

// domain/inventory-item.ts
export class InventoryItem {
  constructor(
    public readonly productId: string,
    public readonly quantity: number,
    public readonly reservedQuantity: number
  ) {}

  get availableQuantity(): number {
    return this.quantity - this.reservedQuantity;
  }

  canReserve(requestedQuantity: number): boolean {
    return this.availableQuantity >= requestedQuantity;
  }
}

// domain/reservation.ts
export class Reservation {
  constructor(
    public readonly id: string,
    public readonly orderId: string,
    public readonly productId: string,
    public readonly quantity: number,
    public readonly createdAt: Date,
    public readonly expiresAt: Date
  ) {}

  get isExpired(): boolean {
    return new Date() > this.expiresAt;
  }
}

// repositories/inventory.repository.ts
export class InventoryRepository {
  async findByProductId(productId: string): Promise<InventoryItem | null> {
    const row = await this.db.query(
      'SELECT product_id, quantity, reserved_quantity FROM inventory WHERE product_id = ?',
      [productId]
    );
    
    if (!row) return null;
    
    return new InventoryItem(
      row.product_id,
      row.quantity,
      row.reserved_quantity
    );
  }

  async decrementQuantity(
    productId: string,
    quantity: number
  ): Promise<void> {
    const result = await this.db.query(
      'UPDATE inventory SET quantity = quantity - ? WHERE product_id = ? AND quantity >= ?',
      [quantity, productId, quantity]
    );
    
    if (result.affectedRows === 0) {
      throw new InsufficientInventoryError(productId);
    }
  }
}

// repositories/reservation.repository.ts
export class ReservationRepository {
  async create(data: CreateReservationData): Promise<Reservation> {
    const id = crypto.randomUUID();
    const expiresAt = new Date(Date.now() + 15 * 60 * 1000);
    
    await this.db.query(
      'INSERT INTO reservations (id, order_id, product_id, quantity, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)',
      [id, data.orderId, data.productId, data.quantity, new Date(), expiresAt]
    );
    
    return new Reservation(
      id,
      data.orderId,
      data.productId,
      data.quantity,
      new Date(),
      expiresAt
    );
  }

  async deleteExpired(): Promise<number> {
    const result = await this.db.query(
      'DELETE FROM reservations WHERE expires_at < ?',
      [new Date()]
    );
    
    return result.affectedRows;
  }
}

// services/inventory.service.ts
export class InventoryService {
  constructor(
    private inventoryRepository: InventoryRepository,
    private reservationRepository: ReservationRepository,
    private logger: Logger
  ) {}

  async checkAndReserve(
    orderId: string,
    items: ReservationItem[]
  ): Promise<Reservation[]> {
    // Validate availability for all items first
    await this.validateAvailability(items);
    
    // Create reservations
    const reservations = await this.createReservations(orderId, items);
    
    // Clean up expired reservations asynchronously
    this.cleanupExpiredReservations().catch(error => {
      this.logger.error('Failed to cleanup expired reservations', { error });
    });
    
    return reservations;
  }

  private async validateAvailability(
    items: ReservationItem[]
  ): Promise<void> {
    for (const item of items) {
      const inventory = await this.inventoryRepository.findByProductId(
        item.productId
      );
      
      if (!inventory) {
        throw new ProductNotFoundError(item.productId);
      }
      
      if (!inventory.canReserve(item.quantity)) {
        throw new InsufficientInventoryError(
          item.productId,
          inventory.availableQuantity,
          item.quantity
        );
      }
    }
  }

  private async createReservations(
    orderId: string,
    items: ReservationItem[]
  ): Promise<Reservation[]> {
    const reservations: Reservation[] = [];
    
    for (const item of items) {
      await this.inventoryRepository.decrementQuantity(
        item.productId,
        item.quantity
      );
      
      const reservation = await this.reservationRepository.create({
        orderId,
        productId: item.productId,
        quantity: item.quantity
      });
      
      reservations.push(reservation);
    }
    
    return reservations;
  }

  private async cleanupExpiredReservations(): Promise<void> {
    const deletedCount = await this.reservationRepository.deleteExpired();
    
    if (deletedCount > 0) {
      this.logger.info('Cleaned up expired reservations', { 
        count: deletedCount 
      });
    }
  }
}

Improvements:

Domain models capture business logic
Repositories handle persistence
Service orchestrates workflow
Each class has single responsibility
Easy to test each component
Type-safe throughout
Better error handling

Conclusion

Refactoring is a continuous practice, not a one-time event. Key techniques covered:

Extract Method: Break long functions into focused ones
Extract Class: Separate responsibilities into different classes
Replace Conditional with Polymorphism: Use strategy pattern for variations
Introduce Parameter Object: Group related parameters
Replace Magic Numbers: Use named constants
Null Object Pattern: Eliminate null checks

In Part 4, we'll cover testing strategies during refactoring to ensure we don't break existing functionality.

Series Navigation: ← Part 2: Code Review Process | Part 4: Testing During Refactoring →

PreviousPart 2: Code Review Process and Best Practices NextPart 4: Testing During Refactoring

Last updated 15 hours ago

hashtagIntroduction

hashtagThe Refactoring Process

hashtagBefore You Start

hashtagThe Safety Net

hashtagTechnique 1: Extract Method

hashtagBefore: God Method

hashtagAfter: Extracted Methods

hashtagTechnique 2: Extract Class

hashtagBefore: God Class

hashtagAfter: Extracted Classes

hashtagTechnique 3: Replace Conditional with Polymorphism

hashtagBefore: Conditional Hell

hashtagAfter: Polymorphic Strategy

hashtagTechnique 4: Introduce Parameter Object

hashtagBefore: Parameter Explosion

hashtagAfter: Parameter Object

hashtagTechnique 5: Replace Magic Numbers with Constants

hashtagBefore: Magic Everywhere

hashtagAfter: Named Constants

hashtagTechnique 6: Null Object Pattern

hashtagBefore: Null Checks Everywhere

hashtagAfter: Null Object Pattern

hashtagReal-World Refactoring: Complete Example

hashtagBefore (380 lines in one file)

hashtagAfter (Split into focused modules)

hashtagConclusion

Introduction

The Refactoring Process

Before You Start

The Safety Net

Technique 1: Extract Method

Before: God Method

After: Extracted Methods

Technique 2: Extract Class

Before: God Class

After: Extracted Classes

Technique 3: Replace Conditional with Polymorphism

Before: Conditional Hell

After: Polymorphic Strategy

Technique 4: Introduce Parameter Object

Before: Parameter Explosion

After: Parameter Object

Technique 5: Replace Magic Numbers with Constants

Before: Magic Everywhere

After: Named Constants

Technique 6: Null Object Pattern

Before: Null Checks Everywhere

After: Null Object Pattern

Real-World Refactoring: Complete Example

Before (380 lines in one file)

After (Split into focused modules)

Conclusion