Writing Clean Code in PHP: SOLID Principles Explained

Writing clean, maintainable code is essential in software development. Your application's scalability and troubleshooting will be a nightmare if your PHP code base is unclean and challenging. This is where sound principles are useful. Robert C. You may create software that is more robust and adaptable by following the five guidelines that Martin (Uncle Bob) presented. We shall dissect each sound principle in this post using real-world PHP examples.

What Are SOLID Principles?

The abbreviation SOLID stands for the five fundamental concepts of object-oriented programming (OOP):

• Single Responsibility Principle (SRP)
• Open/Closed Principle (OCP)
• Liskov Substitution Principle (LSP)
• Interface Segregation Principle (ISP)
• Dependency Inversion Principle (DIP)

You may improve the testability, scalability, and maintainability of your PHP applications by adhering to these guidelines.

1. Single Responsibility Principle (SRP)

“A class should have only one reason to change.”

There should only be one duty assigned to each person. If a class has several responsibilities, altering one of them might also affect the others, creating a tricky situation.

Example:

❌ Bad Practice: A class that handles both user authentication and email notifications:

class UserManager {
    public function login($username, $password) {
        // Authentication logic
    }

    public function sendWelcomeEmail($email) {
        // Email sending logic
    }
}

✅ Good Practice: Separate concerns into different classes:

class Authenticator {
    public function login($username, $password) {
        // Authentication logic
    }
}

class EmailNotifier {
    public function sendWelcomeEmail($email) {
        // Email sending logic
    }
}

2. Open/Closed Principle (OCP)

“Software entities should be open for extension but closed for modification.”

It also means that it should be possible to increase a class's functionality without changing the code that already exists in it.

Example:

❌ Bad Practice: Modifying the class every time a new payment method is added:

class PaymentProcessor {
    public function pay($method) {
        if ($method == 'paypal') {
            // PayPal payment logic
        } elseif ($method == 'credit_card') {
            // Credit Card payment logic
        }
    }
}

✅ Good Practice: Use polymorphism to allow new payment methods without modifying the existing class:

interface PaymentMethod {
    public function pay();
}

class PayPalPayment implements PaymentMethod {
    public function pay() {
        // PayPal payment logic
    }
}

class CreditCardPayment implements PaymentMethod {
    public function pay() {
        // Credit Card payment logic
    }
}

class PaymentProcessor {
    public function processPayment(PaymentMethod $paymentMethod) {
        $paymentMethod->pay();
    }
}

3. Liskov Substitution Principle (LSP)

“Objects of a superclass should be replaceable with objects of a subclass without affecting correctness.”

Example:

❌ Bad Practice: A subclass that violates expected behavior:

class Rectangle {
    protected $width;
    protected $height;

    public function setWidth($width) {
        $this->width = $width;
    }
    public function setHeight($height) {
        $this->height = $height;
    }
}

class Square extends Rectangle {
    public function setWidth($width) {
        $this->width = $width;
        $this->height = $width; // Square must have equal sides
    }
}

✅ Good Practice: Instead of inheriting, separate the behavior:

interface Shape {
    public function area();
}

class Rectangle implements Shape {
    private $width;
    private $height;

    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function area() {
        return $this->width * $this->height;
    }
}

class Square implements Shape {
    private $side;

    public function __construct($side) {
        $this->side = $side;
    }

    public function area() {
        return $this->side * $this->side;
    }
}

PHP & Its Trending Frameworks: The Ultimate Toolkit for Modern Web Development!

4. Interface Segregation Principle (ISP)

“A class should not be forced to implement interfaces it does not use.”

Example:

❌ Bad Practice: Forcing a class to implement unnecessary methods:

interface Worker {
    public function work();
    public function eat();
}

class Robot implements Worker {
    public function work() {
        // Robot working
    }

    public function eat() {
        // Robots don’t eat!
    }
}

✅ Good Practice: Split the interfaces:

interface Workable {
    public function work();
}

interface Eatable {
    public function eat();
}

class Human implements Workable, Eatable {
    public function work() {
        // Human working
    }

    public function eat() {
        // Human eating
    }
}

class Robot implements Workable {
    public function work() {
        // Robot working
    }
}

Make the right choice between Python and PHP to build powerful, efficient, and future-ready applications!

5. Dependency Inversion Principle (DIP)

“Depend on abstractions, not on concrete classes.”

Example:

❌ Bad Practice: Hardcoding dependencies:

class MySQLDatabase {
    public function connect() {
        // MySQL connection
    }
}

class UserRepository {
    private $database;

    public function __construct() {
        $this->database = new MySQLDatabase();
    }
}

✅ Good Practice: Depend on abstractions (interfaces):

interface Database {
    public function connect();
}

class MySQLDatabase implements Database {
    public function connect() {
        // MySQL connection
    }
}

class UserRepository {
    private $database;

    public function __construct(Database $database) {
        $this->database = $database;
    }
}

Conclusion

You may make your codebase more scalable, adaptable, and manageable by utilizing PHP's SOLID principles.

You can use those ideas to develop cleaner and more environmentally friendly code, regardless of how big or small your project is.

Today, begin refactoring and see the difference!

Do you have a favorite first-class coding technique? Post your opinions in the comments section below!