In questo articolo, capiremo i mutators e gli accessors dell'ORM Eloquent del framework web Laravel. Dopo l'introduzione, vedremo degli esempi per capire questi concetti.

In Laravel, i mutators e gli accessors permettono di modificare i dati prima che vengano salvati e recuperati da un database. Per essere precisi, il mutatore consente di modificare i dati prima che vengano salvati in un database. D'altra parte, la funzione di accesso consente di modificare i dati dopo che sono stati recuperati da un database.

Infatti, il modello Laravel è il luogo centrale dove è possibile creare metodi mutator e accessor. E naturalmente, è bello avere tutte le modifiche in un unico luogo, piuttosto che sparsi in posti diversi.

Creare Accessors e Mutators in una Model Class

Ora che hai familiarità con il concetto di base delle funzioni di accessor e mutator, andremo avanti e sviluppare un esempio reale per dimostrarlo.

Presumo che conosciate già il modello Eloquent in Laravel, e useremo il modello Post come punto di partenza del nostro esempio. Se non ancora creato il modello Post, usiamo il comando artisan per crearlo.

php artisan make:model Post --migration

Questo dovrebbe creare un file di modello in app/Post.php come illustrato di seguito.

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    //
}

Sostituiamo il contenuto di tale file con il seguente.

<?php
namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * The attributes that should be mutated to dates.
     *
     * @var array
     */
    protected $dates = [
        'created_at',
        'updated_at',
        'published_at'
    ];

    /**
     * Get the post title.
     *
     * @param  string  $value
     * @return string
     */
    public function getNameAttribute($value)
    {
        return ucfirst($value);
    }
    
    /**
     * Set the post title.
     *
     * @param  string  $value
     * @return string
     */
    public function setNameAttribute($value)
    {
        $this->attributes['name'] = strtolower($value);
    }
}

Poichè abbiamo usato l'opzione --migration, dovrebbe inoltre creare una migrazione di database. Nel caso in cui non lo sappiate, è possibile eseguire il seguente comando in modo da creare una tabella nel database.

php artisan migrate

Al fine di eseguire gli esempi in questo articolo, è necessario creare le colonne name e published_at nella tabella post. In ogni caso, non andremo nei dettagli dell'argomento della migrazione, che è fuori dall'ambito di questo articolo. Torniamo ai metodi che ci interessano.

In primo luogo, vediamo il metodo mutator.

/**
  * Set the post title.
  *
  * @param  string  $value
  * @return string
  */
public function setNameAttribute($value)
{
    $this->attributes['name'] = strtolower($value);
}

Come abbiamo detto in precedenza, i mutatori vengono utilizzati per modificare i dati prima che vengano salvati in un database. Come potete vedere, la sintassi del metodo mutatore è set{nome attributo}Attribute. Naturalmente, è necessario sostituire {nome attributo} con un nome di attributo effettivo.

Il metodo setNameAttribute viene chiamato prima che il valore dell'attributo name venga salvato nel database. Per mantenere le cose semplici, abbiamo solo utilizzato la funzione strtolower che converte il titolo del post in minuscolo prima che venga salvato nel database.

In questo modo, è possibile creare metodi di mutator su tutte le colonne della tabella. Ora vediamo il metodo della funzione accessor.

Se i mutatori vengono utilizzati per modificare i dati prima che vengano salvati in un database, il metodo accessor viene utilizzato per modificare i dati dopo che sono stati recuperati da un database. La sintassi del metodo della funzione di accesso è la stessa di quella di mutator tranne che comincia con la parola chiave get anziché la parola chiave set.

Vediamo il metodo getNameAttribute.

/**
  * Get the post title.
  *
  * @param  string  $value
  * @return string
  */
public function getNameAttribute($value)
{
    return ucfirst($value);
}

Il metodo getNameAttribute verrà chiamato dopo che il valore dell'attributo name viene recuperato dal database. Nel nostro caso, abbiamo utilizzato solo il metodo ucfirst per modificare il titolo del post.

E questo è il modo che si suppone vengano utilizzati gli accessors nei tuoi modelli. Finora, abbiamo appena creato metodi mutator e accessor, e li proveremo nella prossima sezione.

Mutators in azione

Creiamo un controller in app/Http/Controllers/MutatorController.php in modo da testare il metodo mutatore che abbiamo creato nella sezione precedente.

<?php
// app/Http/Controllers/MutatorController.php
namespace App\Http\Controllers;

use App\Post;
use App\Http\Controllers\Controller;

class MutatorController extends Controller
{
    public function index()
    {
        // create a new post object
        $post = new Post;
        $post->setAttribute('name', 'Post title');
        $post->save();
    }
}

Inoltre, è necessario creare una route associata nel file routes/web.php per accedervi.

Route::get('mutator/index', 'MutatorController@index');

Nel metodo index, stiamo creando un nuovo post, utilizzando il modello di Post. Deve impostare il valore della colonna nome al titolo del post allo stesso modo in cui abbiamo usato la funzione strtolower nel metodo mutatore setNameAttribute.

Mutatori di date

Oltre il mutatore che abbiamo visto in precedenza, il modello Eloquent fornisce un paio di speciali setter che consentono di modificare i dati. Ad esempio, il modello Eloquent in Laravel viene fornito con una proprietà speciale $dates che consente di convertire automaticamente le colonne desiderate in un'istanza di date di Carbon.

All'inizio di questo articolo, abbiamo creato il modello per i Post, e il codice riportato di seguito fa parte di quella classe.

...
...
/**
 * The attributes that should be mutated to dates.
 *
 * @var array
 */
protected $dates = [
    'created_at',
    'updated_at',
    'published_at'
];
...
...

Come probabilmente sapete, Laravel crea sempre due campi relativi alla data, created_at e updated_at, con ogni migrazione di database. E converte tali valori in un'istanza di date di Carbon.

Supponiamo che avete un paio di campi in una tabella che si desidera trattare come campi di data. In tal caso, è necessario solo aggiungere i nomi delle colonne nell'array $dates.

Come potete vedere nel codice precedente, abbiamo aggiunto la colonna published_at nell'array $dates, per far sì che il valore di tale colonna verrà convertito in un'istanza di data di Carbon.

Accessors in azione

Per visualizzare le funzioni dell' accessor in azione, andiamo avanti a creare un controller in app/Http/Controllers/AccessorController.php con il seguente contenuto.

<?php
namespace App\Http\Controllers;

use App\Post;
use App\Http\Controllers\Controller;

class AccessorController extends Controller
{
    public function index()
    {
        // load post
        $post = Post::find(1);
        
        // check the name property
        echo $post->name;
        
        // check the date property
        echo $post->published_at;
        
        // as we've mutated the published_at column as Carbon date, we can use following as well
        echo $post->published_at->getTimestamp();
        exit;
    }
}

Inoltre, creiamo una route associata nel file routes/web.php per accedervi.

Route::get('accessor/index', 'AccessorController@index');

Nel metodo index, usiamo il modello Post per caricare un post di esempio in primo luogo.

Successivamente, controlliamo il valore della colonna name, che dovrebbe iniziare con una lettera maiuscola, perchè abbiamo già definito il getNameAttribute di metodo della funzione di accesso per tale colonna.

Inoltre, abbiamo controlliamo il valore della colonna published_at, che dovrebbe essere trattate come una data. Grazie a questo, Laravel converte in un'istanza di Carbon in modo che sia possibile utilizzare tutti i metodi di utilità forniti da tale libreria. Nel nostro caso, usiamo il metodo getTimestamp per convertire la data in un timestamp.

E questo ci porta alla fine di questo articolo!

Conclusione

Oggi, abbiamo esplorato i concetti di mutator e accessor di ORM Eloquent in Laravel. Ciò fornisce un bel modo per modificare i dati prima di salvarli e recuperarli da un database.

Per quelli di voi che hanno da poco iniziato con Laravel o ne stanno approfondendo la conoscenza, con estensioni, abbiamo una varietà di cose che si possono studiare nel market di Envato.

Non esitate a condividere i vostri pensieri utilizzando il feed qui sotto!