Table of Contents
Managing and transforming data efficiently is key to creating robust websites. One of the features offered by Laravel for this purpose is the use of accessors and mutators. These methods of Laravel Eloquent ORM allow you to format and modify data seamlessly while retrieving and saving.
To help you with the same, we’ll understand both of those methods and their use cases. We’ll also dive into the best practices that Laravel developers follow to build robust websites. So, with that, let’s begin by learning what accessors are in Laravel.
What are Laravel Accessors?
In Laravel, accessors are methods used to format or modify an Eloquent model’s attribute when you retrieve it. Accessors allow you to manipulate data after it has been fetched from the database, making it easier to present or use.
To define an accessor in Laravel, you create a method in your Eloquent model with the following naming convention: get{AttributeName}Attribute. For instance, if you have a User model with a date_of_birth attribute, you can create an accessor to format this date whenever it is accessed:
use Illuminate\Database\Eloquent\Casts\Attribute;
class User extends Model
{
protected function dateOfBirth(): Attribute
{
return new Attribute(
get: fn ($value) => \Carbon\Carbon::parse($value)->format('m/d/Y')
);
}
}
In the above example, whenever the date_of_birth attribute is accessed, the date will be formatted as mm/dd/yyyy. Accessors are particularly useful when you need consistent formatting across your website without having to manually format attributes each time you use them.
What are Laravel Mutators?
In Laravel, Mutators are methods that allow you to alter an Eloquent model’s attribute value before it is saved to the database. Mutators are particularly useful for ensuring that data is stored in a consistent format across your website.
To create a mutator in Laravel, you define a method in your Eloquent model with the naming convention set{AttributeName}Attribute. This method will automatically be called when you assign a value to the corresponding attribute. For example, if you want to ensure that the name attribute of a User model is always stored in uppercase, you could define a mutator like this:
use Illuminate\Database\Eloquent\Casts\Attribute;
class User extends Model
{
protected function name(): Attribute
{
return new Attribute(
set: fn ($value) => strtoupper($value)
);
}
}
In the above example, whenever a name is assigned to the User model, the mutator will automatically convert it to uppercase before saving it to the database. That will ensure that any data across the site is stored consistently.
Streamline your Laravel site’s data handling
Difference Between Laravel Accessors and Mutators
Both accessors and mutators are methods to format and manipulate Eloquent attribute values when you retrieve or set them on model instances. The difference between the two is that an accessor is used when you want to retrieve the data in a specific format. On the other hand, mutators are used to save and modify the data in a specific format.
Here is a tabular comparison for more clarity:
| Aspect | Accessors | Mutators |
|---|---|---|
| Purpose | Format or manipulate attribute values when retrieving from the database | Modify attribute values before saving them to the database |
| Naming Convention | get{Attribute}Attribute | set{Attribute}Attribute |
| Use Case | Converting values to uppercase, formatting dates for display | Encrypting passwords, formatting input data |
| Example | php<br>public function getNameAttribute($value)<br>{<br> return strtoupper($value);<br>}<br> | php<br>public function setPasswordAttribute($value)<br>{<br> $this->attributes[‘password’] = bcrypt($value);<br>}<br> |
How to Use Accessors in Laravel?
Accessors in Laravel offer a versatile way to customize attribute behaviour and enhance code organization. Here are some common use cases:
Example 1: Formatting Dates
In this example, we’ll demonstrate how to use an accessor to format a date attribute for models in Laravel. This is particularly useful when you want to present dates in a specific format for display or user input. The code sample to format date is as follows:
public function getCreatedAtAttribute($value)
{
return Carbon::parse($value)->format('Y-m-d');
}
Here, the getCreatedAtAttribute accessor is defined to format the created_at attribute. The Carbon::parse($value)->format(‘Y-m-d’) expression parses the raw date value, creates a Carbon instance, and then formats it using the ‘Y-m-d’ format. This ensures that the date is always displayed in a consistent format, regardless of the database’s default date format.
Example 2: Calculating Total Price
This example will show how to calculate a derived attribute, the total price of an order, based on the associated products. This is a common use case for accessors when you need to compute values that aren’t directly stored in the database.
public function getTotalPriceAttribute()
{
return $this->products->sum('price');
}
The getTotalPriceAttribute accessor is defined to calculate the total price of an order. It uses the sum method on the product relationship to sum the price attribute of all associated products. This provides a simplified way to access the total price of an order without having to manually calculate it in your application logic.
Example 3: Password Hashing
If you need to encrypt or hash a value before storing it in the database, you can use a mutator to do so. Conversely, you can use an accessor to decrypt or decode it when retrieving the value. Here is an example that shows how to encrypt an attribute before saving it to the database and decrypt it when retrieving it:
protected function password(): Attribute
{
return new Attribute(
get: fn ($value) => decrypt($value),
set: fn ($value) => encrypt($value)
);
}
The password accessor and mutator work together to automatically handle encryption and decryption of the password attribute. When a password is set, it is encrypted before being stored, and when it is retrieved, it is decrypted. Using the combination ensures that sensitive data, like passwords, is securely stored while remaining accessible in its original form.
Example 4: Combining Attributes
If your model has first_name and last_name attributes, you might want to create a full_name attribute by combining these two fields. Here is the code to do that:
protected function fullName(): Attribute
{
return new Attribute(
get: fn () => "{$this->first_name} {$this->last_name}"
);
}
Here, the fullName accessor concatenates these two attributes and returns the combined result whenever full_name is accessed. That allows you to easily display a user’s full name without manually concatenating the fields each time you need to display it.
These were some of the common use cases of accessors in Laravel. They enable Laravel development experts to handle various data transformations and formatting tasks directly within the model layer. That results in cleaner and more maintainable code with better representation of data when retrieved by the users.
How to Use Mutators in Laravel?
Mutators in Laravel are highly useful for a variety of scenarios where you need to modify attribute values before saving them to the database. Here are some common use cases:
Example 1: Data Formatting
In this example, we’ll use a mutator to format email addresses before they are stored in the database. The goal is to ensure that all email addresses are saved in lowercase to maintain consistency and avoid potential issues with case sensitivity.
public function setEmailAttribute($value)
{
$this->attributes['email'] = strtolower($value);
}
The setEmailAttribute mutator method converts the email address to lowercase before saving it. That ensures no matter how the email address is provided, it will always be stored in a consistent format. The strtolower function is used to achieve this transformation.
Example 2: String Manipulation
Here, we’ll create a mutator to format phone numbers by removing non-digit characters. This ensures that the phone numbers are stored in a clean, consistent format, making them easier to work with and validate.
public function setPhoneNumberAttribute($value)
{
$this->attributes['phone_number'] = preg_replace('/\D/', '', $value);
}
The setPhoneNumberAttribute mutator method uses a regular expression to remove out any non-digit characters from the phone number. This cleans up the input and stores it in a standardized format, which can be useful for validation or display purposes.
Example 3: Data Encryption
In this example, we’ll use a mutator to encrypt user passwords before saving them to the database. Encrypting passwords helps protect sensitive user information and enhances security.
public function setPasswordAttribute($value)
{
$this->attributes['password'] = bcrypt($value);
}
The setPasswordAttribute mutator method encrypts the password using Laravel’s bcrypt function before saving it to the database. This ensures that passwords are securely stored and not saved in plain text.
Example 4: Setting Defaults
Here, we’ll show you how to use a mutator to set a default value for an attribute if none is provided. This ensures that the attribute always has a valid value.
public function setStatusAttribute($value)
public function setStatusAttribute($value)
{
$this->attributes['status'] = $value ?: 'pending';
}
The setStatusAttribute mutator method checks if a status value is provided. If not, it defaults to ‘pending’. This approach ensures that the status attribute always has a value to show.
These were some of the common use cases of Mutators in Laravel. This method lets professional Laravel development services ensure the data is stored in a consistent format. That ensures the security in Laravel site and proper handling of various types of data even if the value wasn’t provided.
Best Practices for Using Laravel Accessors and Mutators
Using accessors and mutators effectively in Laravel involves adhering to best practices to ensure clean and efficient code. Here are some best practices for using them:
For Accessors
- Keep Logic Simple: Accessors should only handle simple data formatting or transformations. Complex logic should be avoided to keep your codebase clean and maintainable.
- Use for Presentation: Utilize accessors to format data for presentation purposes, such as displaying dates in a user-friendly format or capitalizing names.
- Avoid Heavy Computation: Avoid placing heavy computational logic in accessors. Accessors are meant for lightweight data manipulation.
- Chain with Other Methods: If you need to perform multiple transformations, consider chaining accessors with other methods for readability.
- Consistency: Ensure that accessors provide consistent output formatting across your application to avoid confusion and bugs.
For Mutators
- Validate Input: Use mutators to validate or sanitize input data before saving it to the database. For example, remove unwanted characters or ensure that required fields are not empty.
- Encrypt Sensitive Data: Use mutators to handle encryption for sensitive data such as passwords. This ensures that data is stored securely in the database. You can also combine accessors with mutators to decrypt the password when retrieving it.
- Standardize Data: Utilize mutators to standardize data formats before saving, such as converting email addresses to lowercase or formatting phone numbers.
- Avoid Complex Operations: Keep mutator logic simple and avoid complex operations. If complex transformations are required, consider using service classes or other methods.
- Use Proper Naming: Follow the set{Attribute}Attribute naming convention for mutators to ensure Laravel can automatically detect and apply them.
- Test Thoroughly: Test mutators thoroughly to ensure they handle various input scenarios correctly and do not introduce unexpected bugs.
By following these practices whenever using the accessor and mutators makes your code maintainable and reliable. To build sites that handle data and ensure consistency and security, consider hiring Laravel developers.
FAQs About Laravel Accessors and Mutators
Conclusion
Accessors and mutators are methods that allow streamlined data handling in Laravel. It lets you format data, validate input, implement custom business logic, etc. By combining both of them, you can even create a password hashing mechanism. You can use a mutator to store the data in an encrypted format and then use an accessor to retrieve the decrypted version.
There are many other use cases of using accessors and mutators in Laravel. By knowing which one to use and when you can leverage them effectively. Here is a sneak peek at both of them in one line:
- Accessors: Modify data when retrieving from the database.
- Mutators: Modify data when saving to the database.
If you want to streamline data handling to reduce potential errors and risks, hire Laravel developers.
