Refactoring

A thorough reference covering 89 refactoring techniques and code smells — featuring PHP 8.3+ examples, rationale, step-by-step mechanics, and before/after comparisons.

Refactoring Techniques (67)

Composing Methods

• Extract Method — Pull code fragments into named methods → reference

• Inline Method — Substitute a method call with its body → reference

• Extract Variable — Give complex expressions meaningful names through explanatory variables → reference

• Inline Temp — Substitute a temporary variable with its expression → reference

• Replace Temp with Query — Swap temp variables for method calls → reference

• Split Temporary Variable — Assign separate variables for separate purposes → reference

• Remove Assignments to Parameters — Introduce local variables rather than reassigning parameters → reference

• Replace Method with Method Object — Convert a complex method into its own class → reference

• Substitute Algorithm — Swap an algorithm for a clearer alternative → reference

Moving Features Between Objects

• Move Method — Relocate a method to the class that depends on it most → reference

• Move Field — Relocate a field to the class that depends on it most → reference

• Extract Class — Divide a class that handles too much → reference

• Inline Class — Consolidate a class that does too little → reference

• Hide Delegate — Introduce methods that conceal delegation chains → reference

• Remove Middle Man — Allow clients to call the delegate directly → reference

• Introduce Foreign Method — Attach a missing method to a class you cannot modify → reference

• Introduce Local Extension — Build a wrapper or subclass for a library class → reference

Organizing Data

• Self Encapsulate Field — Route field access through getters even within the class → reference

• Replace Data Value with Object — Promote primitive data to a rich object → reference

• Change Value to Reference — Convert value objects into reference objects → reference

• Change Reference to Value — Convert reference objects into value objects → reference

• Replace Array with Object — Swap arrays used as data structures for proper objects → reference

• Duplicate Observed Data — Keep domain data in sync with the UI via Observer → reference

• Change Unidirectional to Bidirectional — Introduce back-references when needed → reference

• Change Bidirectional to Unidirectional — Eliminate unnecessary back-references → reference

• Replace Magic Number with Symbolic Constant — Assign meaningful names to magic numbers → reference

• Encapsulate Field — Restrict field visibility, expose accessors → reference

• Encapsulate Collection — Expose read-only views of collections → reference

• Replace Type Code with Class — Swap type codes for enums or classes → reference

• Replace Type Code with Subclasses — Swap type codes for a class hierarchy → reference

• Replace Type Code with State/Strategy — Swap behavior-affecting type codes for State/Strategy → reference

• Replace Subclass with Fields — Eliminate subclasses that differ only in constants → reference

Simplifying Conditional Expressions

• Decompose Conditional — Break complex conditionals into named methods → reference

• Consolidate Conditional Expression — Merge conditions that produce the same result → reference

• Consolidate Duplicate Conditional Fragments — Hoist identical code outside of conditionals → reference

• Remove Control Flag — Swap control flags for break/return/continue → reference

• Replace Nested Conditional with Guard Clauses — Flatten nested conditionals using early returns → reference

• Replace Conditional with Polymorphism — Swap conditionals for polymorphic method calls → reference

• Introduce Null Object — Swap null checks for a null object → reference

• Introduce Assertion — Insert assertions to document assumptions → reference

Simplifying Method Calls

• Rename Method — Choose method names that reveal their purpose → reference

• Add Parameter — Introduce new parameters to support additional data → reference

• Remove Parameter — Drop unused method parameters → reference

• Separate Query from Modifier — Divide methods that both return values and change state → reference

• Parameterize Method — Unify similar methods by adding a parameter → reference

• Replace Parameter with Explicit Methods — Produce separate methods for each parameter value → reference

• Preserve Whole Object — Pass the entire object rather than individual values → reference

• Replace Parameter with Method Call — Derive values internally instead of passing them in → reference

• Introduce Parameter Object — Bundle related parameters into an object → reference

• Remove Setting Method — Eliminate setters for fields assigned only at creation → reference

• Hide Method — Narrow the visibility of unused public methods → reference

• Replace Constructor with Factory Method — Use factory methods for complex object creation → reference

• Replace Error Code with Exception — Throw exceptions rather than returning error codes → reference

• Replace Exception with Test — Validate conditions upfront instead of catching exceptions → reference

Dealing with Generalization

• Pull Up Field — Promote identical fields to the superclass → reference

• Pull Up Method — Promote identical methods to the superclass → reference

• Pull Up Constructor Body — Promote shared constructor logic to the superclass → reference

• Push Down Method — Relocate a method to the subclass that uses it → reference

• Push Down Field — Relocate a field to the subclass that uses it → reference

• Extract Subclass — Carve out a subclass for a subset of features → reference

• Extract Superclass — Hoist shared behavior into a parent class → reference

• Extract Interface — Define a shared interface for common operations → reference

• Collapse Hierarchy — Merge superclass and subclass when they are too similar → reference

• Form Template Method — Generalize similar methods into a template → reference

• Replace Inheritance with Delegation — Swap inheritance for composition → reference

• Replace Delegation with Inheritance — Swap excessive delegation for inheritance → reference

Code Smells (22)

Bloaters

• Long Method — Methods that have grown excessively long → reference

• Large Class — Classes that try to handle too much → reference

• Primitive Obsession — Excessive use of primitives instead of small objects → reference

• Long Parameter List — Methods accepting too many parameters → reference

• Data Clumps — Groups of data that repeatedly appear together → reference

Object-Orientation Abusers

• Alternative Classes with Different Interfaces — Similar classes with mismatched method signatures → reference

• Refused Bequest — Subclasses that disregard inherited behavior → reference

• Switch Statements — Complex switch/match constructs that should be polymorphism → reference

• Temporary Field — Fields populated only under certain conditions → reference

Change Preventers

• Divergent Change — A single class modified for many unrelated reasons → reference

• Parallel Inheritance Hierarchies — Creating one subclass forces creating another → reference

• Shotgun Surgery — A single change demands edits across many classes → reference

Dispensables

• Comments — Excessive comments that mask unclear code → reference

• Duplicate Code — Identical or nearly identical code in multiple locations → reference

• Data Class — Classes consisting of nothing but fields and getters/setters → reference

• Dead Code — Unreachable or unused code → reference

• Lazy Class — Classes that contribute too little to justify their existence → reference

• Speculative Generality — Unused abstractions built "just in case" → reference

Couplers

• Feature Envy — Methods that rely more on another class's data than their own → reference

• Inappropriate Intimacy — Classes that reach into each other's internals → reference

• Incomplete Library Class — Library classes that fall short of providing needed features → reference

• Message Chains — Long chains of method calls (a.b().c().d()) → reference

• Middle Man — Classes that do nothing but delegate to another class → reference

Best Practices

• Refactor in small, verified steps — execute tests after every change

• Follow the Boy Scout Rule: leave code in better shape than you found it

• Reach for IDE refactoring tools when available for safe, automated transformations

• Never refactor and alter behavior simultaneously — keep them separate

• Prioritize refactoring that lowers coupling and raises cohesion

• Tackle code smells nearest to your current work first