Mutators is a method to modify data before setting model attributes, with the naming format set{AttributeName}Attribute; Accessors is a method to modify the return data when obtaining attributes, with the naming format get{AttributeName}Attribute. For example, setNameAttribute can convert the user name to lowercase and then store it; getCreatedAtAttribute can format date output. Common uses include cleaning input, encrypting sensitive fields, formatting time amount and other display content. When using it, you should pay attention to the case sensitivity of field names to avoid recursive calls causing dead loops. You should operate the $this->attributes array instead of directly accessing attributes. You can also create field alias through read-only Accessor and combine $casts to achieve more powerful type conversion functions. Mastering them reduces duplicate code and makes the model layer cleaner and more efficient.

In Laravel's Eloquent model, Mutators and Accessors are very practical tools. They allow you to format or process the data when fetching or setting model properties without having to write a lot of extra duplicate code.

What are Mutators and Accessors?

Simply put:

• Mutators are methods that run automatically before you set the model attribute value and are used to modify incoming data.
• Accessors is a method that automatically runs when you get the value of the model attribute, which is used to modify the returned data.

For example, you can use them to automatically convert the name entered by the user to lowercase when storing the user, or format the output when reading the date field.

How to use Mutators

The naming rules of Mutator are: set{AttributeName}Attribute , where {AttributeName} is the field name in the model, with the initial letter capitalization.

For example, suppose you have a User model with a field called name , and you want to convert the name to lowercase before saving:

 public function setNameAttribute($value)
{
    $this->attributes['name'] = strtolower($value);
}

This way, when you execute:

 $user = new User();
$user->name = 'John Doe';
$user->save();

The final database is johndoe .

Common uses:

• Clean input data (such as trim, strtolower)
• Automatically encrypt sensitive fields (such as passwords)
• Format the upload file path

How to use Accessors

The naming rule of Accessor is: get{AttributeName}Attribute , also based on the field name.

For example, you have a created_at field that wants to return a formatted string when fetched:

 public function getCreatedAtAttribute($value)
{
    return date('Ym-d', strtotime($value));
}

Now calling $user->created_at will return a format similar to 2025-04-05 .

If you also use a library like Carbon, you can write it more elegantly:

 use Illuminate\Support\Carbon;

public function getCreatedAtAttribute($value)
{
    return Carbon::parse($value)->format('F j, Y');
}

This returns something like April 5, 2025 .

Common uses:

• Format time, amount, status and other display content
• Spliced field combination (such as full name)
• Convert boolean to human-readable formats like "yes/no"

Tips and precautions for use

1. Field names are case sensitive

   • If your database field is underlined (such as first_name ), then the method name should be written as getFirstNameAttribute or setFirstNameAttribute .

2. Avoid a dead cycle

   • Do not call $this->字段名directly in Mutator or Accessor, otherwise it may cause recursive calls to cause an error. $this->attributes['字段名'] should be operated.

3. Use attribute alias

   • Sometimes you don't want to expose the original field name, you can create an alias by defining a read-only Accessor. For example:

      public function getFormattedNameAttribute()
     {
         return ucfirst($this->name);
     }

     Then you can use $user->formatted_name to get the formatted name.

   • Combined with Casts is more powerful

     • Laravel also supports the $casts attribute for type conversion, such as automatically converting JSON strings into arrays. It works with Mutators/Accessors.

   ---

   Basically that's it. Once you have mastered Mutators and Accessors, you will find that they can help you reduce a lot of repetitive logic, making the model layer cleaner and more centralized processing of data transformations.

   The above is the detailed content of Using Mutators and Accessors in Laravel Eloquent Models. For more information, please follow other related articles on the PHP Chinese website!