Laravel's Mutators and Accessors allow processing of data when setting or getting model properties. 1. Mutators process data before setting properties, such as lowercase or encryption, the method name is set{AttributeName}Attribute; 2. Accessors process data after obtaining properties, such as formatting date or combining fields, the method name is get{AttributeName}Attribute; 3. Common uses include date formatting, sensitive field encryption, combined field display; 4. Pay attention to naming specifications, logic testing and JSON output support when using them. Rational use can improve the cleanliness and logical maintenance of the model.

sure. Laravel's Eloquent ORM provides a very convenient mechanism to handle model properties, where Mutators and Accessors are key tools used to format or convert data when obtaining or setting model properties.

What are Mutators and Accessors?

Simply put:

• Mutators are the method to process the model property values ??before you set them.
• Accessors is the way to process attribute values ??after you get them from the model.

They are ideal for common scenarios such as uniform processing of dates, string formats, encrypted fields, etc.

How to define a Mutator

If you want to do some processing before saving data, such as converting the username to lowercase, you can use Mutator.

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

This way when you execute the following code:

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

The database stores john doe .

Note: The format of the method name is set{AttributeName}Attribute , where {AttributeName} is the attribute name and follows the camel naming rules.

How to define an Accessor

If you want to automatically format a field when reading it, such as returning a full name instead of a separate last name and name, you can use Accessor.

 // public function getFullNameAttribute() in the User model
{
    return $this->first_name . ' ' . $this->last_name;
}

How to use:

 $user = User::find(1);
echo $user->full_name; // Output John Doe

Similarly, the method name format is get{AttributeName}Attribute and is then accessed via $model->attribute_name .

Usage scenarios and suggestions

Here are some common usage scenarios and suggestions:

• Date format processing : For example, format created_at into the format you want.

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

• Encryption sensitive fields : For example, hashing before saving the password.

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

• Combination field display : such as the full name mentioned above, or address splicing, etc.

• Avoid duplicate logic : put the formatted logic in the model, and the controller or view layer does not need to be processed.

Tips and precautions

• If you define Accessor, it will overwrite the original property value of the model (for example, $user->name returns the processed value).

• You can combine Laravel's appends attribute to allow custom Accessors to appear in JSON output:

   protected $appends = ['full_name'];

• Mutator and Accessor do not affect the original values ??in the database, but only affect the read and write behavior at the model level.

• The naming must be standardized, otherwise it is easy to find the problem.

• Remember to check whether the expected processing logic is triggered during testing.

---

Basically that's it. Using Mutators and Accessors rationally can make your model cleaner and your business logic easier to maintain.

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