Master PHP Accessors & Mutators: Boost Data Handling with Real Code Examples

In PHP development, accessors (getters) and mutators (setters) are powerful tools for handling class properties, allowing you to add custom logic when retrieving or modifying data.

1. Accessors

An accessor is a custom method that runs when a property value is read, enabling actions like formatting, conversion, or validation. The typical naming convention is getXXX , where XXX is the property name.

<code>class User {
    private $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        // Convert name to uppercase when retrieving
        return strtoupper($this->name);
    }
}

$user = new User();
$user->setName("John Doe");
echo $user->getName(); // Outputs: JOHN DOE
</code>

In this example, the getName() method returns the name in uppercase, illustrating how additional logic can be applied during property access.

2. Mutators

A mutator is a custom method that runs when a property value is set, allowing you to perform actions such as formatting, conversion, or validation. The naming convention follows setXXX .

<code>class Product {
    private $price;

    public function setPrice($price) {
        // Limit price between 0 and 100
        if ($price < 0) {
            $price = 0;
        } elseif ($price > 100) {
            $price = 100;
        }
        $this->price = $price;
    }

    public function getPrice() {
        return $this->price;
    }
}

$product = new Product();
$product->setPrice(150);
echo $product->getPrice(); // Outputs: 100
</code>

This mutator ensures the $price property stays within a valid range, demonstrating how setters can enforce data integrity.

3. Advanced Uses of Accessors and Mutators

Beyond simple transformations, getters and setters can act as a middle layer for more complex logic such as automatic caching, lazy loading, and dependency management.

<code>class Cache {
    private $data = [];

    public function getData($key) {
        // Return cached data if it exists
        if (isset($this->data[$key])) {
            return $this->data[$key];
        }
        // Otherwise fetch from database and cache it
        $data = $this->fetchDataFromDatabase($key);
        $this->data[$key] = $data;
        return $data;
    }

    public function setData($key, $value) {
        // Update cache and database
        $this->data[$key] = $value;
        $this->saveDataToDatabase($key, $value);
    }

    private function fetchDataFromDatabase($key) {
        // Simulate fetching data from DB
    }

    private function saveDataToDatabase($key, $value) {
        // Simulate saving data to DB
    }
}

class User {
    private $cache;

    public function __construct() {
        $this->cache = new Cache();
    }

    public function getName() {
        // Retrieve name via cache
        return $this->cache->getData('user_name');
    }

    public function setName($name) {
        // Set name and update cache
        $this->cache->setData('user_name', $name);
    }
}

$user = new User();
$user->setName("John Doe");
echo $user->getName(); // Outputs: John Doe
</code>

Here, the Cache class provides getData and setData methods that are used inside the User class’s accessor and mutator to cache the user name, reducing database calls and improving performance.

Conclusion

Accessors and mutators are essential PHP features that enable sophisticated data processing such as transformation, validation, and caching, while keeping code readable and maintainable. Proper use of these methods leads to clearer logic, stronger functionality, and more efficient data handling in backend development.