Laravel per Principianti: La Guida Completa per Iniziare a Sviluppare Web App

Principiante
PHP Laravel

Scopri Laravel, il framework PHP più popolare, con questa guida completa per principianti. Impara a configurare l'ambiente, installare Laravel e costruire la tua prima applicazione web in modo strutturato e professionale.

Pubblicato
Tag
PHP Web Development laravel framework tutorial principianti mvc Eloquent crud blade routing

Introduzione a Laravel: Il Framework PHP per Sviluppatori Moderni

Benvenuti nel mondo della programmazione web! Se siete qui, è probabile che abbiate già familiarità con PHP o che siate curiosi di scoprire come costruire applicazioni web robuste e scalabili in modo efficiente. Oggi parleremo di Laravel, uno dei framework PHP più amati e utilizzati dalla comunità di sviluppatori.

Cos'è un Framework e Perché Usarne Uno?

Prima di addentrarci in Laravel, è fondamentale capire cosa sia un "framework" e perché sia così prezioso. Immaginate di dover costruire una casa: potreste iniziare da zero, creando ogni mattone, ogni trave, ogni finestra. Oppure, potreste usare un kit di costruzione prefabbricato che vi fornisce le fondamenta, le pareti portanti e una serie di strumenti già pronti. Un framework è proprio questo: un kit di costruzione per le applicazioni software.

Offre una struttura predefinita, componenti riutilizzabili e una serie di strumenti che automatizzano compiti comuni, come la gestione delle richieste HTTP, l'interazione con il database, la sicurezza e la gestione delle sessioni. Utilizzare un framework come Laravel significa:

  • Velocità di Sviluppo: Non reinventare la ruota per ogni funzionalità.
  • Migliore Organizzazione del Codice: Seguire pattern di design consolidati (come MVC).
  • Manutenzione Semplificata: Codice più leggibile e facile da modificare.
  • Sicurezza Migliorata: Funzionalità di sicurezza integrate per proteggere l'applicazione.
  • Scalabilità: Strutture che facilitano la crescita dell'applicazione.
  • Comunità e Risorse: Accesso a una vasta comunità, documentazione e pacchetti aggiuntivi.

Perché Scegliere Laravel?

Laravel, creato da Taylor Otwell, è diventato rapidamente il framework PHP più popolare per una serie di motivi:

  • Eleganza e Leggibilità: Il codice Laravel è noto per essere espressivo e facile da leggere, rendendo lo sviluppo più piacevole e la manutenzione meno onerosa.
  • Potente ORM (Eloquent): Interagire con il database non è mai stato così semplice grazie a Eloquent, un Object-Relational Mapper che permette di trattare le tabelle del database come classi PHP.
  • Sistema di Template Blade: Un motore di template semplice ma potente che permette di creare interfacce utente dinamiche con una sintassi pulita.
  • Routing Intuitivo: Definire le rotte della vostra applicazione è incredibilmente semplice e flessibile.
  • Strumenti Integrati: Include funzionalità per l'autenticazione, la gestione delle code, la pianificazione dei task, l'invio di email e molto altro, riducendo la dipendenza da librerie esterne.
  • Ecosistema Ricco: Una vasta gamma di pacchetti ufficiali e della comunità (come Laravel Nova, Forge, Vapor, Dusk, Echo) estende ulteriormente le sue capacità.
  • Comunità Attiva: Una delle comunità più grandi e attive nel mondo PHP, con forum, eventi e risorse online a disposizione.

Questo tutorial è pensato per i principianti che vogliono muovere i primi passi con Laravel. Vi guiderò attraverso l'installazione, la configurazione e la creazione di una semplice applicazione, spiegando i concetti fondamentali lungo il percorso.

Preparazione dell'Ambiente di Sviluppo

Prima di poter installare Laravel, è necessario assicurarsi che il vostro ambiente di sviluppo sia correttamente configurato. Laravel richiede PHP e Composer, oltre a un server web (come Apache o Nginx) e un database (come MySQL o PostgreSQL). Per i principianti, il modo più semplice per iniziare è utilizzare un pacchetto "all-in-one".

Requisiti Minimi di Sistema

Per eseguire Laravel, avrete bisogno di:

  • PHP: Versione 8.1 o superiore.
  • Composer: Un gestore di dipendenze per PHP.
  • Estensioni PHP: Ctype, cURL, DOM, Fileinfo, Filter, Mbstring, OpenSSL, PCRE, PDO, Session, Tokenizer, XML.

Opzioni per l'Ambiente di Sviluppo Locale

  1. XAMPP (Windows, macOS, Linux), MAMP (macOS) o Laragon (Windows): Questi pacchetti includono Apache (o Nginx), MySQL, PHP e PhpMyAdmin, fornendo un ambiente di sviluppo completo con pochi clic. Laragon è particolarmente raccomandato per gli utenti Windows grazie alla sua leggerezza e alle funzionalità aggiuntive come la creazione di URL pulite (.test).

    • Installazione XAMPP/MAMP/Laragon: Scaricate e installate il pacchetto appropriato per il vostro sistema operativo dal sito ufficiale. Una volta installato, avviate Apache/Nginx e MySQL.

  2. Laravel Sail (Docker): Per gli sviluppatori più esperti o per chi vuole un ambiente di sviluppo coerente con la produzione, Laravel Sail è un'ottima opzione. Utilizza Docker per creare un ambiente virtualizzato che include tutti i servizi necessari (PHP, MySQL, Redis, ecc.). Questo tutorial si concentrerà sull'approccio più semplice con XAMPP/MAMP/Laragon per i principianti, ma sappiate che Sail è un'alternativa potente.

  3. PHP Integrato (PHP Built-in Server): Laravel può essere servito anche dal server web integrato di PHP, ma questo è consigliato solo per test rapidi e non per lo sviluppo serio o la produzione.

Installazione di Composer

Composer è uno strumento indispensabile per qualsiasi progetto PHP moderno. Vi permette di dichiarare le librerie da cui il vostro progetto dipende e le gestisce per voi (installazione, aggiornamenti, ecc.).

  • Windows: Scaricate e eseguite il Composer-Setup.exe dal sito ufficiale di Composer. Seguite le istruzioni, assicurandovi che il percorso di PHP sia correttamente configurato.

  • macOS / Linux: Aprite il terminale ed eseguite i seguenti comandi:

    php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php --checksum-file=composer-setup.php --checksum=e21205b207c378199dfdd9027a2fd09d557ebedc3fcd93835f23dfb98a7a00ab865c235fa1a0dc9ddf04ee6390c47d60
php composer-setup.php
php -r "unlink('composer-setup.php');"
sudo mv composer.phar /usr/local/bin/composer

    Verificate l'installazione digitando composer nel terminale. Dovreste vedere l'output di Composer.

Installazione di Node.js e npm (opzionale ma consigliato)

Molte applicazioni Laravel moderne utilizzano asset front-end come CSS e JavaScript compilati tramite Node.js e npm (Node Package Manager). Sebbene non sia strettamente necessario per il core di Laravel, è altamente consigliato installarli per gestire le dipendenze front-end.

  • Installazione Node.js: Scaricate e installate la versione LTS (Long Term Support) dal sito ufficiale di Node.js. npm viene installato automaticamente con Node.js.

Verificate l'installazione digitando node -v e npm -v nel terminale.

Installazione di Laravel

Una volta che il vostro ambiente è pronto, potete installare Laravel. Ci sono due modi principali per farlo:

  1. Tramite Composer (metodo preferito per nuovi progetti): Questo è il modo più semplice e veloce per iniziare un nuovo progetto Laravel. Aprite il terminale, navigate nella directory dove volete creare il vostro progetto (ad esempio, la cartella htdocs di XAMPP o www di Laragon) e digitate:

    composer create-project laravel/laravel nome-del-progetto

    Sostituite nome-del-progetto con il nome desiderato per la vostra applicazione (es. my-blog, task-manager). Composer scaricherà Laravel e tutte le sue dipendenze, creando una nuova directory con il nome specificato.

  2. Tramite l'Installer Laravel (globale): Potete installare l'installer Laravel globalmente usando Composer. Questo vi permette di creare nuovi progetti con un comando più breve.

    composer global require laravel/installer

    Assicuratevi che la directory ~/.composer/vendor/bin (o %APPDATA%\\Composer\\vendor\\bin su Windows) sia nel vostro PATH di sistema. Una volta fatto, potete creare un nuovo progetto con:

    laravel new nome-del-progetto

Dopo aver installato il progetto, navigate nella sua directory:

cd nome-del-progetto

Per avviare il server di sviluppo integrato di PHP (utile per test rapidi, ma se usate XAMPP/Laragon potete accedere tramite URL del server web):

php artisan serve

Questo avvierà un server di sviluppo su http://127.0.0.1:8000. Aprite il vostro browser e navigate a quell'indirizzo per vedere la pagina di benvenuto di Laravel.

Struttura di un Progetto Laravel

Comprendere la struttura di un progetto Laravel è fondamentale per sapere dove mettere il vostro codice e come funziona l'applicazione. Dopo l'installazione, la directory principale del vostro progetto conterrà diverse cartelle e file:

  • app/: Contiene il codice sorgente della vostra applicazione. Qui troverete i vostri Models, Controllers, Providers e altre classi di logica di business. È il cuore della vostra applicazione.
    • app/Http/Controllers: Qui risiedono i vostri controller, che gestiscono le richieste HTTP in ingresso.
    • app/Models: Qui definite i vostri modelli Eloquent per interagire con il database.
    • app/Providers: Contiene i service providers, che sono il luogo centrale per configurare il binding dei servizi e i listener di eventi.
  • bootstrap/: Contiene il file app.php che avvia il framework e la cartella cache per i file di cache generati automaticamente.
  • config/: Contiene tutti i file di configurazione dell'applicazione (database, mail, servizi, ecc.). Ogni file rappresenta un'area specifica della configurazione.
  • database/: Contiene le migrazioni del database, i seeders (per popolare il database con dati di test) e le factory per generare modelli falsi.
    • database/migrations: Contiene i file per creare e modificare la struttura del database.
    • database/seeders: Contiene classi per popolare il database con dati iniziali o di test.
  • public/: La "root" pubblica della vostra applicazione. Contiene il file index.php (il punto di ingresso per tutte le richieste), e le vostre risorse statiche come CSS, JavaScript e immagini. È l'unica cartella accessibile direttamente dal browser.
  • resources/: Contiene le view (i file .blade.php), i file di lingua e le risorse front-end non compilate (come SCSS, LESS, JavaScript non minificato).
    • resources/views: Le vostre view Blade, che definiscono l'interfaccia utente.
  • routes/: Contiene tutti i file di definizione delle rotte della vostra applicazione.
    • web.php: Rotte per l'interfaccia web (con stato, sessioni, cookie).
    • api.php: Rotte per le API stateless (spesso con token di autenticazione).
    • console.php: Rotte per i comandi Artisan.
    • channels.php: Rotte per i canali di broadcasting.
  • storage/: Contiene i log, i file di sessione, la cache dei file, i file caricati dagli utenti e altri dati temporanei generati dall'applicazione.
  • tests/: Contiene i test automatizzati per la vostra applicazione (unit test e feature test).
  • vendor/: Contiene tutte le dipendenze di Composer installate. Questa cartella non deve essere modificata manualmente e non deve essere caricata su sistemi di controllo versione come Git.
  • .env: Il file delle variabili d'ambiente. Contiene le configurazioni specifiche per l'ambiente corrente (es. credenziali del database, chiavi API). È cruciale per la sicurezza e la flessibilità dell'applicazione.
  • artisan: Lo script da riga di comando di Laravel. Permette di eseguire comandi utili come migrazioni, creazione di controller, pulizia della cache, ecc.

Concetti Fondamentali di Laravel

Laravel si basa su diversi concetti chiave che rendono lo sviluppo web efficiente e strutturato. Vediamoli in dettaglio.

1. Routing: Il Cuore delle Richieste

Il routing è il meccanismo che collega un URL (una richiesta HTTP) a una specifica azione all'interno della vostra applicazione. In Laravel, le rotte sono definite nei file all'interno della cartella routes/. Il file routes/web.php è quello che useremo di più per le applicazioni web tradizionali.

Una rotta base è definita così:

// routes/web.php

use Illuminate\\Support\\Facades\\Route;

Route::get('/', function () {
    return view('welcome');
});

Route::get('/saluto', function () {
    return 'Ciao a tutti!';
});

Route::get('/utente/{id}', function ($id) {
    return 'Utente numero: ' . $id;
});
  • Route::get(): Definisce una rotta che risponde a richieste HTTP GET. Esistono anche post(), put(), patch(), delete().
  • /: L'URL a cui la rotta risponde. In questo caso, la homepage.
  • function () { ... }: La closure (funzione anonima) che viene eseguita quando la rotta viene visitata. Può restituire una stringa, un array, o una view.
  • view('welcome'): Restituisce una view Blade chiamata welcome.blade.php (che si trova in resources/views/).
  • /utente/{id}: Una rotta con un parametro dinamico {id}. Il valore di id viene passato alla closure.

Rotte che Puntano a Controller

Per applicazioni più complesse, è buona pratica separare la logica dalla definizione della rotta utilizzando i Controller. Questo segue il pattern MVC (Model-View-Controller).

// routes/web.php

use App\\Http\\Controllers\\TaskController;

Route::get('/tasks', [TaskController::class, 'index']);
Route::get('/tasks/{id}', [TaskController::class, 'show']);

Qui, quando si accede a /tasks, viene chiamato il metodo index della classe TaskController. Vedremo i controller a breve.

2. Controller: La Logica di Business

I controller sono classi che raggruppano la logica di gestione delle richieste HTTP. Agiscono come intermediari tra il modello (dati) e la vista (interfaccia utente). Sono definiti nella cartella app/Http/Controllers.

Per creare un controller, usate il comando Artisan:

php artisan make:controller TaskController

Questo creerà un file TaskController.php in app/Http/Controllers.

// app/Http/Controllers/TaskController.php

namespace App\\Http\\Controllers;

use Illuminate\\Http\\Request;

class TaskController extends Controller
{
    public function index()
    {
        $tasks = ['Imparare Laravel', 'Costruire un'app CRUD', 'Riposare'];
        return view('tasks.index', ['tasks' => $tasks]);
    }

    public function show($id)
    {
        $task = 'Task ' . $id;
        return view('tasks.show', ['task' => $task]);
    }
}
  • index(): Questo metodo è tipicamente usato per mostrare una lista di risorse (es. tutti i task).
  • show($id): Questo metodo è usato per mostrare una singola risorsa identificata da un ID.
  • return view('tasks.index', ['tasks' => $tasks]): Restituisce una view Blade e le passa un array di dati. La view si aspetterà una variabile $tasks.

3. View (Blade): Il Motore di Template

Le view sono i file che contengono il markup HTML della vostra applicazione e sono responsabili di visualizzare i dati all'utente. Laravel utilizza Blade, un motore di template semplice ma potente. I file Blade hanno l'estensione .blade.php e si trovano in resources/views.

Blade offre una sintassi pulita per scrivere il markup, estendere layout, includere altre view, e mostrare dati. Ecco un esempio di tasks/index.blade.php:

{{-- resources/views/tasks/index.blade.php --}}

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Lista Task</title>
</head>
<body>
    <h1>Le mie Task</h1>
    <ul>
        @foreach ($tasks as $task)
            <li>{{ $task }}</li>
        @endforeach
    </ul>
</body>
</html>
  • {{ $variabile }}: Utilizzato per stampare il valore di una variabile. Blade si occupa automaticamente di eseguire l'escape dei dati per prevenire attacchi XSS.
  • @foreach (...) @endforeach: Direttive Blade per cicli. Blade include direttive per if, else, while, for, @extends, @section, @yield, @include e molte altre.
  • {{-- Commento --}}: Commenti Blade che non vengono renderizzati nell'HTML finale.

4. Modelli (Eloquent ORM): Interazione con il Database

Eloquent ORM (Object-Relational Mapper) è una delle funzionalità più potenti di Laravel. Permette di interagire con il database in modo orientato agli oggetti, trattando ogni tabella del database come una classe PHP (un "Modello").

Migrazioni

Le migrazioni sono come il controllo versione per il vostro database. Permettono di definire lo schema del database in file PHP, rendendo facile creare, modificare e condividere la struttura del database tra i membri del team.

Per creare una migrazione per una tabella tasks:

php artisan make:migration create_tasks_table

Questo creerà un file nella cartella database/migrations con due metodi: up() (per creare la tabella) e down() (per annullare la creazione).

// database/migrations/YYYY_MM_DD_HHMMSS_create_tasks_table.php

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('tasks', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description')->nullable();
            $table->boolean('completed')->default(false);
            $table->timestamps(); // created_at e updated_at
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('tasks');
    }
};

Per eseguire le migrazioni e creare la tabella nel database:

php artisan migrate

Creazione del Modello Eloquent

Per creare un modello per la tabella tasks:

php artisan make:model Task

Questo creerà un file Task.php in app/Models.

// app/Models/Task.php

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Database\\Eloquent\\Model;

class Task extends Model
{
    use HasFactory;

    // Definisce quali attributi possono essere assegnati in massa (mass assignable)
    protected $fillable = ['title', 'description', 'completed'];
}

Ora potete interagire con il database tramite il modello Task:

// In un controller o in una closure di rotta

// Recupera tutti i task
$tasks = Task::all();

// Crea un nuovo task
$task = Task::create([
    'title' => 'Imparare Eloquent',
    'description' => 'Capire come funziona l'ORM di Laravel.',
    'completed' => false
]);

// Trova un task per ID
$task = Task::find(1);

// Aggiorna un task
$task->completed = true;
$task->save();

// Cancella un task
$task->delete();

5. Database: Configurazione e Interazione

Laravel supporta diversi database come MySQL, PostgreSQL, SQLite e SQL Server. La configurazione del database avviene tramite il file .env e config/database.php.

Nel file .env, troverete le variabili per la connessione al database:

# .env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_tutorial
DB_USERNAME=root
DB_PASSWORD=

Assicuratevi di creare il database laravel_tutorial (o il nome che preferite) nel vostro sistema di gestione database (es. PhpMyAdmin per MySQL). Una volta configurato, potete eseguire php artisan migrate per creare le tabelle.

6. Middleware: Filtrare le Richieste HTTP

I middleware sono un meccanismo per filtrare le richieste HTTP in entrata nella vostra applicazione. Possono essere usati per autenticare gli utenti, registrare le richieste, aggiungere header, ecc. Laravel include middleware predefiniti (es. per l'autenticazione, la protezione CSRF) e potete crearne di vostri.

Ad esempio, il middleware web (applicato a tutte le rotte in routes/web.php) gestisce le sessioni e la protezione CSRF. Potete applicare middleware a rotte specifiche o a gruppi di rotte.

Esempio Pratico: Creare una Semplice Applicazione CRUD (Gestione Task)

Ora mettiamo insieme tutti i pezzi per costruire una semplice applicazione CRUD (Create, Read, Update, Delete) per gestire una lista di task.

Passaggio 1: Configurazione del Database e Migrazioni

  1. Crea il database: Se non l'hai già fatto, crea un database chiamato laravel_tutorial (o un nome a tua scelta) nel tuo sistema di gestione database (es. PhpMyAdmin per MySQL).

  2. Configura .env: Assicurati che il file .env abbia le credenziali corrette per il tuo database.

    DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_tutorial
DB_USERNAME=root
DB_PASSWORD=

  3. Crea il modello e la migrazione: Useremo un singolo comando Artisan che crea sia il modello Task che la migrazione create_tasks_table.

    php artisan make:model Task -m

    Questo creerà app/Models/Task.php e database/migrations/YYYY_MM_DD_HHMMSS_create_tasks_table.php.

  4. Modifica la migrazione: Apri il file di migrazione (database/migrations/..._create_tasks_table.php) e definisci le colonne per la tabella tasks.

    // database/migrations/YYYY_MM_DD_HHMMSS_create_tasks_table.php

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('tasks', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description')->nullable();
            $table->boolean('completed')->default(false);
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('tasks');
    }
};

  5. Esegui le migrazioni: Applica le modifiche al database.

    php artisan migrate

  6. Modifica il modello Task: Apri app/Models/Task.php e aggiungi fillable per permettere l'assegnazione di massa.

    // app/Models/Task.php

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Database\\Eloquent\\Model;

class Task extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description', 'completed'];
}

Passaggio 2: Creazione del Controller

Crea un TaskController per gestire la logica CRUD.

php artisan make:controller TaskController --resource

L'opzione --resource creerà automaticamente i metodi index, create, store, show, edit, update, destroy, che sono standard per un controller RESTful.

// app/Http/Controllers/TaskController.php

namespace App\\Http\\Controllers;

use App\\Models\\Task;
use Illuminate\\Http\\Request;

class TaskController extends Controller
{
    /**
     * Mostra una lista di tutte le tasks.
     */
    public function index()
    {
        $tasks = Task::all();
        return view('tasks.index', compact('tasks'));
    }

    /**
     * Mostra il form per creare una nuova task.
     */
    public function create()
    {
        return view('tasks.create');
    }

    /**
     * Salva una nuova task nel database.
     */
    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required|max:255',
            'description' => 'nullable'
        ]);

        Task::create($request->all());

        return redirect()->route('tasks.index')
                         ->with('success', 'Task creata con successo!');
    }

    /**
     * Mostra una singola task.
     */
    public function show(Task $task)
    {
        return view('tasks.show', compact('task'));
    }

    /**
     * Mostra il form per modificare una task esistente.
     */
    public function edit(Task $task)
    {
        return view('tasks.edit', compact('task'));
    }

    /**
     * Aggiorna una task nel database.
     */
    public function update(Request $request, Task $task)
    {
        $request->validate([
            'title' => 'required|max:255',
            'description' => 'nullable'
        ]);

        $task->update($request->all());

        return redirect()->route('tasks.index')
                         ->with('success', 'Task aggiornata con successo!');
    }

    /**
     * Cancella una task dal database.
     */
    public function destroy(Task $task)
    {
        $task->delete();

        return redirect()->route('tasks.index')
                         ->with('success', 'Task eliminata con successo!');
    }
}
  • Iniezione di Dipendenza: Notate Task $task nei metodi show, edit, update, destroy. Laravel inietta automaticamente l'istanza del modello Task basandosi sull'ID nella rotta. Questo è chiamato Route Model Binding ed è estremamente comodo.
  • Validazione: $request->validate() è un modo semplice per validare i dati in ingresso. Se la validazione fallisce, Laravel reindirizza automaticamente l'utente alla pagina precedente con gli errori di validazione.
  • Redirect con Messaggio: redirect()->route('tasks.index')->with('success', ...) reindirizza l'utente a una rotta specifica e aggiunge un messaggio "flash" alla sessione, che può essere visualizzato una sola volta nella view successiva.

Passaggio 3: Definizione delle Rotte Resource

Invece di definire manualmente ogni rotta CRUD, Laravel offre le rotte "resource" che generano automaticamente le rotte standard per un controller.

// routes/web.php

use App\\Http\\Controllers\\TaskController;
use Illuminate\\Support\\Facades\\Route;

Route::get('/', function () {
    return redirect()->route('tasks.index');
});

Route::resource('tasks', TaskController::class);

Il comando Route::resource('tasks', TaskController::class); genererà le seguenti rotte:

Metodo HTTP URI Nome Rotta Azione Controller
GET /tasks tasks.index TaskController@index
GET /tasks/create tasks.create TaskController@create
POST /tasks tasks.store TaskController@store
GET /tasks/{task} tasks.show TaskController@show
GET /tasks/{task}/edit tasks.edit TaskController@edit
PUT/PATCH /tasks/{task} tasks.update TaskController@update
DELETE /tasks/{task} tasks.destroy TaskController@destroy

Potete vedere tutte le rotte registrate con:

php artisan route:list

Passaggio 4: Creazione delle View Blade

Creeremo tre view: index.blade.php (lista task), create.blade.php (form creazione), edit.blade.php (form modifica), e un layout base app.blade.php.

  1. Layout Base (resources/views/layouts/app.blade.php):

    {{-- resources/views/layouts/app.blade.php --}}

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Gestione Task - @yield('title')</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container mt-4">
        @if (session('success'))
            <div class="alert alert-success">
                {{ session('success') }}
            </div>
        @endif

        @yield('content')
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>
    • @yield('title'): Un segnaposto per il titolo specifico della pagina.
    • @yield('content'): Il segnaposto principale dove verrà iniettato il contenuto specifico di ogni view.
    • @if (session('success')): Mostra un messaggio di successo se presente nella sessione (grazie al ->with('success', ...) del controller).

  2. Lista Task (resources/views/tasks/index.blade.php):

    {{-- resources/views/tasks/index.blade.php --}}

@extends('layouts.app')

@section('title', 'Lista Task')

@section('content')
    <h1>Lista Task</h1>
    <a href="{{ route('tasks.create') }}" class="btn btn-primary mb-3">Crea Nuova Task</a>

    <ul class="list-group">
        @forelse ($tasks as $task)
            <li class="list-group-item d-flex justify-content-between align-items-center">
                <div>
                    <a href="{{ route('tasks.show', $task->id) }}" class="{{ $task->completed ? 'text-decoration-line-through' : '' }}">
                        {{ $task->title }}
                    </a>
                    <small class="ms-2 text-muted">Creato il: {{ $task->created_at->format('d/m/Y') }}</small>
                </div>
                <div>
                    <a href="{{ route('tasks.edit', $task->id) }}" class="btn btn-warning btn-sm me-2">Modifica</a>
                    <form action="{{ route('tasks.destroy', $task->id) }}" method="POST" class="d-inline">
                        @csrf
                        @method('DELETE')
                        <button type="submit" class="btn btn-danger btn-sm" confirm('Sei sicuro di voler eliminare questa task?')">Elimina</button>
                    </form>
                </div>
            </li>
        @empty
            <li class="list-group-item">Nessuna task trovata.</li>
        @endforelse
    </ul>
@endsection
    • @extends('layouts.app'): Indica che questa view estende il layout app.blade.php.
    • @section('title', '...') e @section('content') ... @endsection: Riempiono i segnaposto definiti nel layout.
    • route('tasks.create'): Genera l'URL per la rotta tasks.create.
    • @csrf: Direttiva Blade che genera un token CSRF (Cross-Site Request Forgery) nascosto. Essenziale per la sicurezza nei form POST/PUT/PATCH/DELETE.
    • @method('DELETE'): Laravel non supporta i metodi PUT/PATCH/DELETE direttamente nei form HTML. Questa direttiva crea un campo nascosto che Laravel interpreterà come una richiesta DELETE.

  3. Dettaglio Task (resources/views/tasks/show.blade.php):

    {{-- resources/views/tasks/show.blade.php --}}

@extends('layouts.app')

@section('title', 'Dettaglio Task')

@section('content')
    <h1>Dettaglio Task: {{ $task->title }}</h1>

    <div class="card">
        <div class="card-body">
            <h5 class="card-title">{{ $task->title }}</h5>
            <p class="card-text">{{ $task->description ?? 'Nessuna descrizione.' }}</p>
            <p class="card-text">Stato: {{ $task->completed ? 'Completata' : 'In Sospeso' }}</p>
            <p class="card-text"><small class="text-muted">Creata il: {{ $task->created_at->format('d/m/Y H:i') }}</small></p>
            <p class="card-text"><small class="text-muted">Ultimo aggiornamento: {{ $task->updated_at->format('d/m/Y H:i') }}</small></p>
        </div>
    </div>

    <a href="{{ route('tasks.index') }}" class="btn btn-secondary mt-3">Torna alla lista</a>
    <a href="{{ route('tasks.edit', $task->id) }}" class="btn btn-warning mt-3">Modifica Task</a>
@endsection

  4. Form Creazione Task (resources/views/tasks/create.blade.php):

    {{-- resources/views/tasks/create.blade.php --}}

@extends('layouts.app')

@section('title', 'Crea Nuova Task')

@section('content')
    <h1>Crea Nuova Task</h1>

    <form action="{{ route('tasks.store') }}" method="POST">
        @csrf
        <div class="mb-3">
            <label for="title" class="form-label">Titolo</label>
            <input type="text" class="form-control @error('title') is-invalid @enderror" id="title" name="title" value="{{ old('title') }}" required>
            @error('title')
                <div class="invalid-feedback">{{ $message }}</div>
            @enderror
        </div>
        <div class="mb-3">
            <label for="description" class="form-label">Descrizione</label>
            <textarea class="form-control @error('description') is-invalid @enderror" id="description" name="description" rows="3">{{ old('description') }}</textarea>
            @error('description')
                <div class="invalid-feedback">{{ $message }}</div>
            @enderror
        </div>
        <div class="form-check mb-3">
            <input type="checkbox" class="form-check-input" id="completed" name="completed" value="1" {{ old('completed') ? 'checked' : '' }}>
            <label class="form-check-label" for="completed">Completata</label>
        </div>
        <button type="submit" class="btn btn-success">Salva Task</button>
        <a href="{{ route('tasks.index') }}" class="btn btn-secondary">Annulla</a>
    </form>
@endsection
    • old('title'): Recupera il valore precedentemente inserito nel campo title in caso di errore di validazione, così l'utente non deve riscrivere tutto.
    • @error('title') ... @enderror: Direttiva Blade per mostrare i messaggi di errore di validazione specifici per un campo.

  5. Form Modifica Task (resources/views/tasks/edit.blade.php):

    {{-- resources/views/tasks/edit.blade.php --}}

@extends('layouts.app')

@section('title', 'Modifica Task')

@section('content')
    <h1>Modifica Task</h1>

    <form action="{{ route('tasks.update', $task->id) }}" method="POST">
        @csrf
        @method('PUT') {{-- O PATCH --}}
        <div class="mb-3">
            <label for="title" class="form-label">Titolo</label>
            <input type="text" class="form-control @error('title') is-invalid @enderror" id="title" name="title" value="{{ old('title', $task->title) }}" required>
            @error('title')
                <div class="invalid-feedback">{{ $message }}</div>
            @enderror
        </div>
        <div class="mb-3">
            <label for="description" class="form-label">Descrizione</label>
            <textarea class="form-control @error('description') is-invalid @enderror" id="description" name="description" rows="3">{{ old('description', $task->description) }}</textarea>
            @error('description')
                <div class="invalid-feedback">{{ $message }}</div>
            @enderror
        </div>
        <div class="form-check mb-3">
            <input type="checkbox" class="form-check-input" id="completed" name="completed" value="1" {{ old('completed', $task->completed) ? 'checked' : '' }}>
            <label class="form-check-label" for="completed">Completata</label>
        </div>
        <button type="submit" class="btn btn-success">Aggiorna Task</button>
        <a href="{{ route('tasks.index') }}" class="btn btn-secondary">Annulla</a>
    </form>
@endsection
    • old('title', $task->title): Qui, old() prende un secondo parametro che è il valore di default se non ci sono dati old. In questo modo, il campo è pre-popolato con il valore corrente della task.

Passaggio 5: Testare l'Applicazione

  1. Avvia il server di sviluppo (se non usi XAMPP/Laragon):

    php artisan serve

  2. Apri il browser e vai su http://127.0.0.1:8000/tasks (o l'URL configurato nel tuo ambiente).

  3. Dovresti vedere la lista vuota delle task. Prova a creare nuove task, modificarle, visualizzarle e eliminarle.

Complimenti! Avete appena costruito la vostra prima applicazione CRUD completa con Laravel!

Errori Comuni e Suggerimenti per i Principianti

Incontrare errori fa parte del processo di apprendimento. Ecco alcuni dei problemi più comuni che i principianti incontrano con Laravel e come risolverli:

  1. "No application encryption key has been specified.": Questo errore significa che la chiave di cifratura della vostra applicazione non è stata generata. Eseguite:

    php artisan key:generate

    Questo aggiornerà il file .env con una chiave univoca.

  2. Errori di connessione al database: Controllate attentamente le credenziali nel file .env (DB_DATABASE, DB_USERNAME, DB_PASSWORD). Assicuratevi che il database esista e che le credenziali siano corrette. Controllate anche che il server del database sia in esecuzione (es. MySQL in XAMPP).

  3. Errori 404 (Not Found) per le rotte: Se state usando Apache o Nginx e non il server php artisan serve, assicuratevi che il vostro server web sia configurato correttamente per puntare alla cartella public di Laravel e che il mod_rewrite di Apache sia abilitato (o configurazione equivalente per Nginx).

  4. Permessi dei file/cartelle: Laravel ha bisogno di permessi di scrittura per le cartelle storage e bootstrap/cache. Su sistemi Linux/macOS, potreste dover eseguire:

    sudo chmod -R 775 storage bootstrap/cache
sudo chown -R www-data:www-data storage bootstrap/cache # (o il vostro utente web server)

    Su Windows, di solito non è un problema, ma assicuratevi che l'utente che esegue il server web abbia i permessi corretti.

  5. Modifiche al .env non applicate: Dopo aver modificato il file .env, spesso è necessario pulire la cache di configurazione di Laravel:

    php artisan config:clear

  6. Class not found / Target class does not exist: Questo accade spesso quando si crea un nuovo controller, modello o un'altra classe e non si esegue composer dump-autoload (anche se Composer lo fa automaticamente con make:model o make:controller). Se il problema persiste, provate:

    composer dump-autoload

  7. @csrf o @method mancanti nei form: Se ricevete errori come 419 Page Expired o MethodNotAllowedHttpException, è molto probabile che abbiate dimenticato le direttive @csrf e @method('PUT'/'DELETE') nei vostri form HTML.

Prossimi Passi e Risorse Utili

Congratulazioni per aver completato questo tutorial! Avete fatto un passo importante nel vostro percorso con Laravel. Ma questo è solo l'inizio. Ecco alcuni suggerimenti per i vostri prossimi passi:

  1. Approfondire la Documentazione Ufficiale: La documentazione di Laravel è eccellente, chiara e aggiornata. È la vostra risorsa numero uno per qualsiasi dubbio o per approfondire argomenti specifici.
  2. Autenticazione e Autorizzazione: Laravel offre un sistema di autenticazione robusto e facile da usare con pacchetti come Laravel Breeze o Jetstream. Imparare a gestire utenti, login, registrazione e ruoli è fondamentale per la maggior parte delle applicazioni.
  3. Validazione Avanzata: Esplorate tutte le regole di validazione disponibili e imparate a creare regole di validazione personalizzate.
  4. Relazioni Eloquent: Scoprite come definire relazioni tra modelli (uno-a-uno, uno-a-molti, molti-a-molti) per gestire dati complessi in modo efficiente.
  5. Testing: Laravel rende il testing delle applicazioni un piacere. Imparate a scrivere test unitari e di funzionalità per garantire la qualità del vostro codice.
  6. API RESTful: Imparate a costruire API RESTful con Laravel, utilizzando le rotte api.php e i controller API.
  7. Queue, Broadcasting, Mail: Esplorate le funzionalità avanzate di Laravel per la gestione delle code, la comunicazione in tempo reale e l'invio di email.
  8. Pacchetti della Comunità: Scoprite i numerosi pacchetti sviluppati dalla comunità Laravel che possono estendere le funzionalità della vostra applicazione (es. Spatie per permessi, Media Library, ecc.).
  9. Deployment: Imparate come portare la vostra applicazione Laravel dal vostro ambiente di sviluppo locale a un server di produzione.
  10. Comunità Laravel: Unitevi a forum, gruppi Facebook, Discord o Stack Overflow per porre domande, condividere conoscenze e rimanere aggiornati sulle ultime novità di Laravel.

Ricordate, la pratica rende perfetti. Continuate a costruire, sperimentare e non abbiate paura degli errori. Ogni errore è un'opportunità per imparare e migliorare. Buon divertimento con Laravel!

Continua a leggere