Articoli

Cos’è Laravel Eloquent, come si usa, tutorial con esempi

Il framework PHP Laravel include Eloquent.

Eloquent è un O.R.M., cioè Object Relational Mapper.

Eloquent fornisce un modo estremamente semplice per comunicare con un database. 

Laravel e Eloquent aiutano a velocizzare lo sviluppo di applicazioni e piattaforme, fornendo una soluzione adeguata alla maggior parte dei problemi di gestione di dati strutturati. I requisiti vengono affrontati con uno sviluppo più rapido, oltre a un codice ben organizzato, riutilizzabile, gestibile e scalabile. 

Tempo di lettura stimato: 9 minuti

Come funziona Eloquent

Lavorare con Eloquent vuol dire gestire informazioni, presenti anche in più database, in modo efficiente utilizzando un’implementazione ActiveMethod. È un modello architettonico in cui il modello creato nella struttura Model-View-Controller (MVC), corrisponde a una tabella nel database. Il vantaggio è che i modelli eseguono operazioni di database comuni senza codificare lunghe query SQL. 

I modelli consentono di eseguire query sui dati nelle tabelle e di inserire nuovi record nelle tabelle. Il processo di sincronizzazione di più database in esecuzione su sistemi diversi è semplificato. Non è necessario scrivere query SQL. Tutto quello che devi fare è definire le tabelle del database e le relazioni tra di loro, e Eloquent farà il resto del lavoro.

Preparazione di Laravel

I passaggi da fare per poter iniziale a lavorare su Eloquent sono:

  1. Installa Laravel da getcomposer.org, per far questo segui le istruzioni leggendo qui
  2. Creare migration utilizzando la console Artisan
  3. Creare modelli eloquent
  4. eseguire i seed del database

Artisan Console è il nome dell’interfaccia Command Line inclusa in Laravel. Fornisce una serie di comandi utili da utilizzare durante lo sviluppo di una applicazione.

Per visualizzare un elenco di tutti i comandi Artisan disponibili, puoi utilizzare il comando list:

php artisan list

O semplicemente php artisan, ricevendo un risultato di questo tipo:

php artisan list
Laravel Framework 9.52.4

Usage:
  command [options] [arguments]

Options:
  -h, --help            Display help for the given command. When no command is given display help for the list command
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
  -n, --no-interaction  Do not ask any interactive question
      --env[=ENV]       The environment the command should run under
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:
  about                                Display basic information about your application
  clear-compiled                       Remove the compiled class file
  completion                           Dump the shell completion script
  db                                   Start a new database CLI session
  docs                                 Access the Laravel documentation
  down                                 Put the application into maintenance / demo mode
  env                                  Display the current framework environment
  help                                 Display help for a command
  inspire                              Display an inspiring quote
  list                                 List commands
  migrate                              Run the database migrations
  optimize                             Cache the framework bootstrap files
  serve                                Serve the application on the PHP development server
  test                                 Run the application tests
  tinker                               Interact with your application
  ui                                   Swap the front-end scaffolding for the application
  up                                   Bring the application out of maintenance mode
 auth
  auth:clear-resets                    Flush expired password reset tokens
 cache
  cache:clear                          Flush the application cache
  cache:forget                         Remove an item from the cache
  cache:table                          Create a migration for the cache database table
 config
  config:cache                         Create a cache file for faster configuration loading
  config:clear                         Remove the configuration cache file
 db
  db:monitor                           Monitor the number of connections on the specified database
  db:seed                              Seed the database with records
  db:show                              Display information about the given database
  db:table                             Display information about the given database table
  db:wipe                              Drop all tables, views, and types
 env
  env:decrypt                          Decrypt an environment file
  env:encrypt                          Encrypt an environment file
 event
  event:cache                          Discover and cache the application's events and listeners
  event:clear                          Clear all cached events and listeners
  event:generate                       Generate the missing events and listeners based on registration
  event:list                           List the application's events and listeners
 key
  key:generate                         Set the application key
 make
  make:cast                            Create a new custom Eloquent cast class
  make:channel                         Create a new channel class
  make:command                         Create a new Artisan command
  make:component                       Create a new view component class
  make:controller                      Create a new controller class
  make:event                           Create a new event class
  make:exception                       Create a new custom exception class
  make:factory                         Create a new model factory
  make:job                             Create a new job class
  make:listener                        Create a new event listener class
  make:mail                            Create a new email class
  make:middleware                      Create a new middleware class
  make:migration                       Create a new migration file
  make:model                           Create a new Eloquent model class
  make:notification                    Create a new notification class
  make:observer                        Create a new observer class
  make:policy                          Create a new policy class
  make:provider                        Create a new service provider class
  make:request                         Create a new form request class
  make:resource                        Create a new resource
  make:rule                            Create a new validation rule
  make:scope                           Create a new scope class
  make:seeder                          Create a new seeder class
  make:test                            Create a new test class
 migrate
  migrate:fresh                        Drop all tables and re-run all migrations
  migrate:install                      Create the migration repository
  migrate:refresh                      Reset and re-run all migrations
  migrate:reset                        Rollback all database migrations
  migrate:rollback                     Rollback the last database migration
  migrate:status                       Show the status of each migration
 model
  model:prune                          Prune models that are no longer needed
  model:show                           Show information about an Eloquent model
 notifications
  notifications:table                  Create a migration for the notifications table
 optimize
  optimize:clear                       Remove the cached bootstrap files
 package
  package:discover                     Rebuild the cached package manifest
 permission
  permission:cache-reset               Reset the permission cache
  permission:create-permission         Create a permission
  permission:create-permission-routes  Create a permission routes.
  permission:create-role               Create a role
  permission:setup-teams               Setup the teams feature by generating the associated migration.
  permission:show                      Show a table of roles and permissions per guard
 queue
  queue:batches-table                  Create a migration for the batches database table
  queue:clear                          Delete all of the jobs from the specified queue
  queue:failed                         List all of the failed queue jobs
  queue:failed-table                   Create a migration for the failed queue jobs database table
  queue:flush                          Flush all of the failed queue jobs
  queue:forget                         Delete a failed queue job
  queue:listen                         Listen to a given queue
  queue:monitor                        Monitor the size of the specified queues
  queue:prune-batches                  Prune stale entries from the batches database
  queue:prune-failed                   Prune stale entries from the failed jobs table
  queue:restart                        Restart queue worker daemons after their current job
  queue:retry                          Retry a failed queue job
  queue:retry-batch                    Retry the failed jobs for a batch
  queue:table                          Create a migration for the queue jobs database table
  queue:work                           Start processing jobs on the queue as a daemon
 route
  route:cache                          Create a route cache file for faster route registration
  route:clear                          Remove the route cache file
  route:list                           List all registered routes
 sail
  sail:add                             Add a service to an existing Sail installation
  sail:install                         Install Laravel Sail's default Docker Compose file
  sail:publish                         Publish the Laravel Sail Docker files
 sanctum
  sanctum:prune-expired                Prune tokens expired for more than specified number of hours.
 schedule
  schedule:clear-cache                 Delete the cached mutex files created by scheduler
  schedule:list                        List all scheduled tasks
  schedule:run                         Run the scheduled commands
  schedule:test                        Run a scheduled command
  schedule:work                        Start the schedule worker
 schema
  schema:dump                          Dump the given database schema
 session
  session:table                        Create a migration for the session database table
 storage
  storage:link                         Create the symbolic links configured for the application
 stub
  stub:publish                         Publish all stubs that are available for customization
 ui
  ui:auth                              Scaffold basic login and registration views and routes
  ui:controllers                       Scaffold the authentication controllers
 vendor
  vendor:publish                       Publish any publishable assets from vendor packages
 view
  view:cache                           Compile all of the application's Blade templates
  view:clear                           Clear all compiled view files

Tutti i comandi vengono forniti con una breve descrizione dei suoi argomenti e opzioni. Questo è mostrato in una schermata di “aiuto”. Per visualizzare una schermata di aiuto, è sufficiente far precedere il nome del comando da “help” come mostrato:

php artisan help migrate
Description:
  Run the database migrations

Usage:
  migrate [options]

Options:
      --database[=DATABASE]        The database connection to use
      --force                      Force the operation to run when in production
      --path[=PATH]                The path(s) to the migrations files to be executed (multiple values allowed)
      --realpath                   Indicate any provided migration file paths are pre-resolved absolute paths
      --schema-path[=SCHEMA-PATH]  The path to a schema dump file
      --pretend                    Dump the SQL queries that would be run
      --seed                       Indicates if the seed task should be re-run
      --seeder[=SEEDER]            The class name of the root seeder
      --step                       Force the migrations to be run so they can be rolled back individually
      --isolated[=ISOLATED]        Do not run the command if another instance of the command is already running [default: false]
  -h, --help                       Display help for the given command. When no command is given display help for the list command
  -q, --quiet                      Do not output any message
  -V, --version                    Display this application version
      --ansi|--no-ansi             Force (or disable --no-ansi) ANSI output
  -n, --no-interaction             Do not ask any interactive question
      --env[=ENV]                  The environment the command should run under
  -v|vv|vvv, --verbose             Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Migration

La migration è un processo di gestione del database scrivendo PHP anziché SQL. Fornisce un modo per aggiungere il controllo della versione al database. 

Per creare una migrazione, basta eseguire il seguente comando:

php artisan make:migration create_student_records

Questo crea il file di migrazione. Nel tuo editor di testo, apri il file appena creato nella cartella database\migrations:

<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;

class CreateStudentRecordsTable extends Migration
{
    /**
    * Run the migrations.
    *
    * @return void
    */
    public function up()
    {
        Schema::create('student__records', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
        });
    }

    /**
    * Reverse the migrations.
    *
    * @return void
    */
    public function down()
    {
        Schema::dropIfExists('student__records');
    }
}

Il codice è una classe con lo stesso nome ‘create student records‘, e ha due metodi: up e down. Il metodo up dovrebbe apportare modifiche al database; quindi ogni volta che esegui la migrazione del tuo database, verrà eseguito qualsiasi codice presente nel metodo up. D’altra parte, il metodo down dovrebbe ripristinare tali modifiche al database; quindi ogni volta che esegui il rollback della migration, il metodo down dovrebbe annullare ciò che ha fatto il metodo up. All’interno del metodo up c’è lo schema builder utilizzato per creare e manipolare le tabelle. Cosa succede se annulli alcune delle tue migrazioni? Tutto quello che devi fare è implementare il seguente comando:

php artisan migrate:rollback

E ritirerà l’ultima migration che è stata implementata. Inoltre, puoi ripristinare completamente il database eseguendo:

php artisan migrate:reset

Questo annullerà tutte le tue migrazioni.

Definizione di modelli di Eloquent

Al termine della migrazione del database, il processo successivo è il seedingEloquent entra in gioco poiché il seeding è l’inserimento di record nel nostro database. Quindi dovrai creare i modelli prima di popolare il database. Ogni tabella di database ha un modello corrispondente che viene utilizzato per interagire con tale tabella. I modelli ti consentono di interrogare i dati nelle tue tabelle, nonché di inserire nuovi record nella tabella. Il modo più semplice per creare un’istanza del modello è utilizzare il seguente comando:

php artisan make:model Student

Di seguito è mostrato un esempio di modello Student, che può essere utilizzato per recuperare e archiviare informazioni dalla tabella del database del nostro studente:

<?php
namespace App;
use IlluminateDatabaseEloquentModel;

class Student extends Model
{
    //
}

Quando si genera un modello e allo stesso tempo si desidera generare una migrazione del database, è possibile utilizzare l’opzione –migration o -m:

php artisan make:model Student --migration

php artisan make:model Student -m

Fillable e Guarded

In Laravel, sia $fillable che $guarded vengono utilizzati per controllare l’assegnazione di massa degli attributi nei tuoi modelli. Analizziamo le differenze:

$fillable:
  • Funziona come una “lista bianca” di attributi che possono essere assegnati in massa.
  • Si specifica esplicitamente quali attributi sono consentiti per l’assegnazione di massa.
  • Solo gli attributi elencati in $fillable possono essere impostati utilizzando fill() con un array di valori.

Esempio:

class User extends Eloquent {
    protected $fillable = ['name', 'email'];
}

In questo esempio solo le colonne nome ed email possono essere assegnate in massa.

$guarded:
  • Funziona come una “lista nera” di attributi che non dovrebbero essere assegnati in massa.
  • Si specifica esplicitamente quali attributi devono essere protetti dall’assegnazione di massa.
  • Gli attributi elencati in $guarded non verranno impostati utilizzando fill().

Esempio:

class User extends Eloquent {
    protected $guarded = ['name', 'email'];
}

In questo caso, le colonne nome ed email non saranno assegnabili in massa.

Combinando entrambi:

Puoi utilizzare sia $fillable che $guarded insieme.

Se vuoi rendere tutti i campi assegnabili in massa tranne alcuni, usa un array $guarded vuoto:

protected $guarded = [];

Se vuoi impedire che tutti i campi vengano assegnati in massa, usa:

protected $guarded = ['*'];

Se vuoi proteggere campi specifici, usa $fillable per i campi da compilare in massa e $guarded per il resto.

Seeders

I seeder complessivi sono un insieme speciale di classi che ci consentono di popolare il nostro database più e più volte con gli stessi dati esatti. Implementiamo il seguente comando:

php artisan make:seeder StudentsRecordSeeder

Nell’editor di testo, sotto la cartella seeds, apri il file appena creato con nome file: StudentsRecordSeeder.php. Come puoi vedere, questa è solo una classe molto semplice con un singolo metodo chiamato run().

<?php
use IlluminateDatabaseSeeder;

class StudentsRecordSeeder extends Seeder
{
    /**
    * Run the database seeds
    * @return void
    */

    public function run()
    {
        //
    }
}

Il codice è solo un involucro attorno a una classe di comandi della console, creata appositamente per aiutare con l’attività di seeding. Modifica il codice e poi salvalo.

Newsletter sull’Innovazione
Non perderti le notizie più importanti sull'Innovazione. Iscriviti per riceverle via e-mail.
public function run()
{
    echo 'Seeding!';
}

E passando al terminale avviare il comando artisan per eseguire il metodo run della classe appena creata:

php artisan db:seed --class=StudentsRecordSeeder

Se vuoi provare a implementare un esempio di classe seeder, puoi procedere leggendo il nostro post.

Ora possiamo continuare a implementare tutte le operazioni su DB con Eloquent.

CRUD con Laravel Eloquent

Le operazioni CRUD con Laravel Eloquent object-relational mapper (ORM) rendono più facile per gli sviluppatori di Laravel lavorare con più database. Esegue operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD), nonché mappa i modelli di oggetti alle tabelle del database. Gestisce tutte le interazioni del database richieste per le operazioni CRUD.

Creazione di record

È possibile utilizzare il metodo ::create per inserire un nuovo record nel database.

student_record::create(array(
    'first_name' => 'John',
    'last_name'  => 'Doe',
    'student_rank' => 1
));

Oltre al semplice metodo di creazione mostrato sopra, puoi anche creare un nuovo oggetto e assegnargli attributi diversi. Quindi, puoi chiamare la funzione save() ed eseguire il codice. Metodi come firstOrCreate() o firstOrNew() sono altre opzioni per la creazione di record. Questi consentiranno di trovare uno studente con determinati attributi; se quello studente non viene trovato, lo creerai nel database o creerai un’istanza di una nuova istanza.

firstOrCreate()

Cerca un record utilizzando le coppie chiave valore specificate. Se il modello non viene trovato nel database, crea un nuovo record con gli attributi specificati. La coppia chiave valore deve essere fornita come chiave associativa.

Esempio: supponiamo di avere un model User e di voler trovare o creare un utente in base al suo indirizzo email:

$user = User::firstOrCreate(['email' => 'user@example.com']);

Se esiste un utente con l’indirizzo email “user@example.com”, la firstOrCreate restituirà quell’utente. Se non viene trovata alcuna corrispondenza, verrà creato un nuovo utente con l’indirizzo email specificato.

Esempio con attributi specifici: se desideri verificare l’esistenza solo di un campo specifico (ad esempio, email), ma scriverne anche altri, allora puoi fornire un array a elemento singolo con il campo desiderato.

$user = User::firstOrCreate(['email' => 'user@example.com'], ['name' => 'John Doe']);

Se esiste un utente con l’e-mail “user@example.com”, firstOrCreate restituisce quell’utente. In caso contrario, creerà un nuovo utente con l’e-mail e il nome “John Doe”.

firstOrNew()

Il metodo firstOrNew viene utilizzato per trovare il primo modello che soddisfa determinate condizioni. Se non viene trovato alcun modello corrispondente, crea una nuova istanza del modello ma non la salva nel database.

$user = User::firstOrNew(['email' => 'user@example.com']);

Se esiste un utente con l’indirizzo email “user@example.com”, restituirà quell’utente. In caso contrario, creerà una nuova istanza user con l’e-mail specificata. Puoi anche passare attributi aggiuntivi da impostare durante la creazione della nuova istanza:

$user = User::firstOrNew(['email' => 'user@example.com'], ['name' => 'John Doe']);

Se non viene trovato alcun utente esistente, verrà creato un nuovo utente con l’e-mail e il nome “John Doe”.

I due metodi firstOrCreate e firstOrNew sono simili. Il metodo firstOrCreate tenta di trovare un modello che corrisponda agli attributi specificati. Se non trovato, crea e salva automaticamente un nuovo modello, mentre firstOrNew se non trova, crea l’istanza ma non la salva. Non salvando si dovrà successivamente scrivere eventuali attributi e poi salvare.

Lettura record

Utilizzando Eloquent ORM, è possibile trovare record nel database. Le query sono costruite in modo semplice e offrono un flusso regolare. Per creare istruzioni ::where, utilizzerai i metodi get() e first(). 

Il metodo first() restituirà solo un record, mentre il metodo get() restituirà un array di record su cui è possibile eseguire il loop per leggere tutti i risultati. Inoltre, il metodo find() può essere utilizzato con un array di chiavi primarie, che restituirà una raccolta di record corrispondenti. 

Ecco alcuni esempi:

$student = Students::all();

Questo codice ottiene tutti gli studenti. Mentre il codice seguente trova uno studente specifico per ID:

$studente = Studenti::find(1);

Inoltre, come mostrato di seguito, il codice descrive la ricerca di uno studente in base a un attributo specifico.

$JohnDoe = Students::where('name', '=', 'John Doe')->first();

Per il metodo get(), questo codice mostra come trovare uno studente con un livello superiore a 5.

$rankStudents = Student::where('student_rank', '>', 5)->get();
Aggiornamento record

L’aggiornamento dei record utilizzando Eloquent è altrettanto semplice. Per aggiornare un record, basta trovare il record che si desidera aggiornare, modificare gli attributi e salvare. Ad esempio, per modificare il livello di grado dello studente di John Doe a 5, prima trova lo studente e poi esegui il metodo di salvataggio.

$JohnDoe = Bear::where('name', '=', 'John Doe')->first();
$JohnDoe->danger_level = 5;
$JohnDoe->save();

Il metodo save può essere utilizzato anche per aggiornare i modelli già esistenti nel database.

Eliminare i record

Eloquent vanta il suo facile processo di aggiornamento dei record, ma ha la stessa storia con l’eliminazione. Ci sono due opzioni: record pull-out ed esegui il metodo delete, o semplicemente usa il metodo destroy. Per trovare ed eliminare un record, esegui semplicemente i seguenti comandi:

$student = Students::find(1);
$student->delete();

Per eliminare un record e più record, vengono eseguiti i comandi:

Students::destroy(1);
Students::destroy(1, 2, 3);

Si noti che i parametri di destroy sono solo chiavi primarie a differenza del metodo delete che può accettare qualsiasi colonna del database.

Per trovare ed eliminare tutti gli studenti con livello superiore a 10.

Students::where('student_rank', '>', 10)->delete();

Letture Correlate

Ercole Palmeri

Newsletter sull’Innovazione
Non perderti le notizie più importanti sull'Innovazione. Iscriviti per riceverle via e-mail.