Accessors and mutators in Laravel allow you to format or modify model data when retrieving or saving it. 1. Accessors, defined as get{Attribute}Attribute, alter how data is retrieved—e.g., capitalizing names or formatting dates. 2. Mutators, defined as set{Attribute}Attribute, transform data before saving—e.g., hashing passwords or cleaning phone numbers. 3. You can also create virtual attributes like full name by combining fields. 4. Be mindful of naming conventions, visibility settings, and interactions with mass assignment and attribute casting to avoid issues.

When you need to format or modify model data before using it in your Laravel application, accessors and mutators are the tools you want to reach for. They let you manipulate how Eloquent handles specific attribute values when retrieving or setting them—without cluttering your controllers or views with formatting logic.

What Are Accessors and Mutators?

In simple terms:

• Accessors change how data is displayed or retrieved from the database.
• Mutators control how data is stored or transformed before being saved.

This means you can keep things like date formatting, string casing, or value transformations neatly tucked inside your model, where they belong.

For example, if you store a user's first name in lowercase but always want it capitalized when used in your app, an accessor does that automatically. Likewise, if you accept a plain text password from a form, a mutator can hash it before saving.

How to Use Accessors

You define an accessor by creating a method in your model named like get{Attribute}Attribute. Let’s say you have a first_name column, and you want it returned with the first letter capitalized:

public function getFirstNameAttribute($value)
{
    return ucfirst($value);
}

Now whenever you call $user->first_name, it will automatically be passed through this method.

Another common use case: dates. If you're storing a published_at timestamp and want it formatted consistently:

public function getPublishedAtAttribute($value)
{
    return date('F j, Y', strtotime($value));
}

This way, every time you pull that field, it comes back in a ready-to-use format.

Pro tip: You don’t have to stick to existing columns. You can also create “virtual” attributes that combine or compute values on the fly:

public function getFullNameAttribute()
{
    return $this->first_name . ' ' . $this->last_name;
}

Using Mutators to Modify Data Before Saving

Mutators work similarly but run before data is written to the database. Define them with a method like set{Attribute}Attribute.

Let’s say users enter phone numbers in various formats. You want to store just the digits:

public function setPhoneAttribute($value)
{
    $this->attributes['phone'] = preg_replace('/[^0-9]/', '', $value);
}

Or maybe you want to hash a password before saving:

public function setPasswordAttribute($value)
{
    $this->attributes['password'] = bcrypt($value);
}

These help ensure your data stays clean and consistent without having to handle it manually every time.

Just remember:

• The method receives the raw input value
• You must assign the result to the internal $this->attributes array

Things to Watch Out For

There are a few gotchas when working with accessors and mutators:

• Naming matters: Make sure your method names exactly match the attribute naming convention (get{Attribute}Attribute, set{Attribute}Attribute)
• Hidden fields: If you’re using $hidden or $visible in your model, make sure computed attributes (like full_name) aren't accidentally excluded
• Mass assignment: Mutators still run when you mass assign values, so you don’t have to worry about skipping them accidentally
• Casting vs. Accessors: If you're only changing data type (like converting a JSON string to an array), consider using Eloquent attribute casting instead—it's simpler and more readable

Also, keep in mind that once you define an accessor, Laravel treats that attribute as "mutated" and won’t try to cast it automatically. So if you were relying on automatic casting for something like dates or booleans, test thoroughly after adding an accessor.

That’s the core of using accessors and mutators effectively in Laravel. They’re straightforward but powerful tools for keeping your data handling clean and consistent.

The above is the detailed content of Manipulating model attributes with Laravel Accessors and Mutators. For more information, please follow other related articles on the PHP Chinese website!