Routes: credo che il modo più semplice di imparare come funziona il framework MVC Laravel sia quello di partire con le rotte. Rotte proprio come le linee ideali seguite da una nave.

Almeno questa è la mia esperienza.

Cosa sono le rotte (routes)?

Cosa sono le rotte? In inglese routes, sono gli URI (Uniform Resource Identifier), i link che vengono generati dall’applicazione, quelli che compaiono sulla barra degli indirizzi del browser:

Il principale URI generato dall’applicazione è la home page, nel mio esempio:

http://www.complex.local/

È un’applicazione di esempio locale per la quale ho configurato un virtual host Apache.

Per vedere come viene servita questa rotta (che in sostanza è risorsa di più alto livello, la radice e si indica con /) bisogna fare riferimento al file <APP>/routes/web.php.

Attenzione: sto usando la versione 8.73.1 di Laravel e, rispetto al passato, l’organizzazione delle cartelle è leggermente cambiata. Con <APP> intendo la cartella radice dell’applicazione (nel mio caso il nome della cartella è /complex. Al suo interno c’è tutta l’organizzazione delle cartelle di Laravel, tra cui una che si chiama /app (che non è <APP>, bensì la prima sottocartella di questa, in ordine alfabetico).
Nella cartella /app c’è la maggior parte del materiale che utilizzeremo (i model e i controller per esempio).
Un’altra cartella importante è la cartella /database dove troveremo tutte le migrazioni.
Infine , nella cartella /resources/views ci sono le viste e, nella separata cartella /routes, le rotte.

Ebbene, ecco il contenuto del file <APP>/routes/web.php:

<?php

use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/

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

Questo programma utilizza la classe di Laravel Route e in particolare il suo metodo get(), che è definito con una closure che non è altro che una funzione definita sul posto, detta più propriamente funzione anonima perché è senza nome. Questa closure ritorna la funzione view() a cui passo l’argomento 'welcome'.

Nota: view() è una funzione, non un metodo. Infatti non è definita all’interno di una classe ma all’interno di un file, helpers.php, situato sotto <APP>/vendor/laravel/framework/src/Illuminate/Foundation.

Il primo importante parametro del metodo get() è proprio la rotta da servire. In questo caso la ‘/’, la home page.

Il secondo parametro altrettanto importante è cosa deve fare Laravel quando dal browser arriva la richiesta di servire la rotta indicata. In questo caso ciò che deve fare Laravel è scritto dentro alla closure, e deve ritornare la view di nome ‘welcome’.

Cos’è questa view 'welcome'? È un file PHP scritto in Blade che si trova sotto <APP>/resources/views/welcome.blade.php. Quindi ogni volta che di decide il nome di una nuova view deve essere necessariamente associata ad un nuovo file all’interno della cartella <APP>/resources/views/.

Per esempio, se dobbiamo servire una rotta return view('edit'); ci dovrà essere un form HTML scritto dentro al file <APP>/resources/views/edit.blade.php.

Quindi in generale:

Route::get([URL], function () {
    return view([view file name]);
});

Ora, la view di home generata automaticamente da Laravel è piuttosto complessa:

Facciamone una più semplice:

$ cd resources/views/
$ cp welcome.blade.php welcome.blade.ORIG.php

e modifichiamo a piacere l’orginale (welcome.blade.php):

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">

        <title>Laravel</title>

        <!-- Fonts -->
        <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@400;600;700&display=swap" rel="stylesheet">

        <!-- Styles -->
        <style>
            /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{line-height:1.15;...}
        </style>

        <style>
            body {
                font-family: 'Nunito', sans-serif;
            }
        </style>
    </head>
    <body class="antialiased">
        <div class="relative flex items-top justify-center min-h-screen bg-gray-100 dark:bg-gray-900 sm:items-center py-4 sm:pt-0">
            <h1>Buongiorno Laravel!</h1>
            <p>Questa è la home page</p>
        </div>
    </body>
</html>

Ho lasciato un po’ di “codice” html/css per fare vedere lo scheletro della pagina, come vengono caricati gli stili, come si usa il linguaggio di templating Blade (es. str_replace()) – per vedere come si possano iniettare piccoli frammenti di codice per automatizzare la pagina – e Bootstrap con la definizione delle classi.

Ma proprio il minimo indispensabile.

Il cuore della view è:

<h1>Buongiorno Laravel!</h1>
<p>Questa è la home page</p>

Il risultato è un po’ deludente ma siamo risuciti a servire la nostra prima rotta

Routes: il metodo statico Route::get()

Ho glissato su un aspetto tecnico piuttosto importante, il frammento di programma che chiama la view è scritto così:

<?php
Route::get($path, <closure>)

la scrittura Route::get() è l’invocazione statica di un metodo di una classe. Qui spiego meglio cosa vuol dire.

Se non definisco una rotta, non la posso chiamare dal browser. Per esempio se provo ad invocare

http://www.complex.local/esempio

il risultato è un errore 404

Se però definisco la rotta:

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

la vista che appare è la seguente

Possiamo anche passare parametri nell’URL e intercettarli all’interno dei nostri programmi per farne ciò che vogliamo. Ad esempio se definiamo questa rotta nel file /routes/web.php:

Route::get('/company/{id}', function ($id) {
    return 'Company '.$id;
});

Otteniamo

Posso passare anche più parametri nel modo seguente (attenzione all’ordine in cui li scrivo e li nomino!):

Route::get('/company/{id}/{type_id}', function ($id, $type_id) {
    return 'Company '.$id. ' is of type '.$type_id;
});

Il risultato è il seguente

Questo esempio che segue illustra la possibilità di dare un nome, una etichetta, ad una rotta.

Route::get('/user/example', array('as' => 'user.home', function() {
    $uri = route('user.home');
    print 'The URI is '.$uri;
}));

Il risultato è questo che per ora ci dice poco:

Tutte le rotte che definiamo le possiamo tenere sotto controllo con artisan:

L’ultima lista dell’elenco è quella a cui abbiamo anche attriibuto un nome. In pratica lo potremo usare così:

<a href="route('user.home')">User home</a>

e laravel ci porterà a http://www.complex.local/user/example.

Ricordatevi di fare in modo che apache possa scrivere il file <APP>/storage/logs/laravel.log:

 $ sudo chmod 777 storage/logs/laravel.log 
[sudo] password di marcob: 
$

o risulterà un errore.

Ulteriori modi di utilizzare le rotte è chiamando i metodi di un controller invece di una funzione anonima. Ma lo vediamo la prossima puntata.

Riferimenti

• Edwin Diaz
• Laravel
• Puntata precedente (MVC)
• Puntata seguente (i Controller)
• Betaingegneria: Invocazione statica del metodo di una classe

Da tempo immemorabile so,o credevo di sapere, il affto di geometria secondo il quale “il cerchio è un poligono con infiniti lati” ma ho sempre avuto paura, o non ho mai avuto abbastanza voglia, di dimostrarlo.

Una pulsione irresistibile mi ha preso e ho fatto sto benedetto calcolo. Sì, si può calcolare la lunghezza ella circonferenza e l’area del cerchio con un’operazione di passagio al limite.

L’articoletto è in allegato. Molto divertimento, come sempre.