PHP: Template Engine e l’eleganza del sorgente pulito

19 Apr 2019 | M.A.D.R.

Cosa sono i Templete Engine (es: Smarty,Blade, twig) per PHP?

Iniziamo subito dicendo che non esiste il modo giusto di scrivere delle pagine elaborate dal server, ogni strategia potrebbe essere giusta, ma spesso l’errore più comune della stesura della pagina è l’intrusione di linguaggi differenti; questo comportamento seppur ignorato dai browser, dal server e dai linguaggi ha spesso degli inconvenienti che andremo ad analizzare un pò più da vicino.

Nel riepilogo possiamo identificare le voci che daranno noia alla nostra applicazione:

  • Difficile lettura
  • Difficile gestione
  • Logiche business solitamente spostate sulle viste
  • Creazione di una quantitativo di sorgenti veramente stratosferico

Non esiste il modo giusto per scrivere del codice.

Questa affermazione seppur in parte vera, riscontra un vero e proprio bug nella gestione dei progetti di medie/grandi dimensioni, facendoci perdere tanto tempo per identificare possibili errori.

Quindi diciamo che l’ausilio di un Template Engine sicuramente ci permetterà di effettuare operazioni migliori rendendo i nostri codici molto più puliti, quindi tornando a noi dovremo iniziare a spostare le varie logiche nelle sezioni giuste (diciamo una sorta di MVC e/o MVVC in js).


MVC cos’è?

  • Model, modello dati
  • View, vista dei dati
  • Controller, controllore che passerà alla nostra “view" i dati necessari per la stampa

Visto che non siamo qui per parlare del modello MVC, oggi ereditiamo solo la “V" la view che permetterà di facilitare il nostro flusso di visualizzazione.

Facciamo subito chiarezza

Stile classico

php_code

Stile con Tempalte

smarty_code

Apparentemente le soluzioni sono equipollenti, con qualche piccola nota di differenza e di prestazione.

  • La soluzione uno (la classica) visualizzerà all’interno della pagina che si sta renderizzando un loop in php che sicuramente forzerà il programmatore a dover scrivere tonnellate di “echo" e/o “print" per avere il risultato sperato, senza parlare della necessità di scrivere ogni volta la struttura della pagina.
  • La soluzione due (posta alla destra) è vero che visualizzerà la stessa tabella, ma consentirà all’utente di spezzare le varie view in piccoli file per poi andarli ad unire alla fine e posizionarli dove meglio crede. In questo caso potremo scrivere due paginette per il layout e la nostra vista non farà altro che estendere il layout. La pulizia del codice è notevole, non inseriamo/mischiamo html/js/php.

Fermi, non voglio convincere nessuno, ma la pratica migliore sarebbe esattamente questa.

Nel dettaglio, ipotizziamo di dover scrivere un mini siti con 3 paginette:

  • Home
  • Chi Sono
  • Contatti

Vero che attraverso php potrete fare “include_once(…..)", ma l’idea di includere una pagina che effettua un rendering di una vista mi sembra sprecata…

Dovremo scrivere moolto di più, scrivere all’interno di pagine scomode con " e ‘ che spesso sono fonte di errori etc…

Proporrei nel caso questa soluzione: Installazione di un template engine (preferisco smarty,twig,blade), scrittura del nostro controllore che sistemerà i dati e basta tutto qui….

Vediamo come potremmo implementare la soluzione lato view:

  • Creazione di un layout generale
    • head
    • header
    • body
      • sezioni che serviranno all’applicazione
    • footer
  • Creazione di pagine che servono ad estendere (per semplicità il body, in questo caso 3 porzioni di html)

Quindi con questa soluzione avremo 3 sezioni in html dove dovremo passare dei dati che saranno elaborati, ed una pagina che richiama le varie sezioni, nel dettaglio:

Creiamo la nostra pagina d’ingresso “index.php" e strutturiamo il progetto così:

  • root
    • classi
      • Home
    • viste
      • layout
        • head
        • header
        • body
        • footer
      • pagine
        • home
        • chi-sono
        • contatti
  • index.php

A questo punto, la classe Home risolve tutti i dati con la BL della nostra applicazione, il nostro layout è scritto in view/layout, mentre le nostre paginette sono scritte all’interno della directory “pagine".

Ipotizziamo di aver costruito tutte le logiche d’accesso della nostra applicazione e che la classe Home riesca a fornire i dati alle pagine, una possibile soluzione per la sola pagina index.php che riuscirà a recuperare tutti i contenuti della nostra applicazione potrebbe essere la seguente (utilizzando smarty come template engine):

$pagine_da_visualizzare=new Home();
$dati=$pagine_da_visualizzare->init_();
//costruisco l'oggetto Smarty con le varie opzioni
$tempalte_engine=new Smarty($option);
	//iniziamo a visualizzare i nostri blocchi
	//head
	$tempalte_engine->display('head.tpl');
	//header
	$tempalte_engine->display('header.tpl');
	//body
	$tempalte_engine->display('body.tpl');
		//assegno alla variabile del template date tutto il contenuto
		//dell'elaborazione della nostra classe ottenuto come ritorno
		//dalla funzione init_
		$tempalte_engine->assign('data',$dati);
		//trovo dinamicamamente la pagina che dovrò visualizzare
		$tempalte_engine->display($dati['pagina'].'.tpl');

	//finisco di stampare l'output della nostra applicazioncina
	$tempalte_engine->display('footer.tpl');

La nostra Classe Home sarà di questo genere:

class Home {
	private $view='';
	private $dati=[];
	public function __construct() {
		if(!isset($_GET['q']))$this->view='home';
		else $this->view=$_GET['q'];
	}
	public function init_(){
		call_user_func([$this,strtolower($this->view)],[]);
		return $this->dati;
	}
	private function home(){
		$this->dati=['pagina'=>'home','bread'=>'home','contenuto'=>['uno','due','tre']];
	}
	private function chi_sono(){
		$this->dati=['pagina'=>'chi sono','bread'=>'home/chi sono','contenuto'=>['uno','due','tre']];
	}
	private function contatti(){
		$this->dati=['pagina'=>'contatti','bread'=>'home/contatti','contenuto'=>['uno','due','tre']];
	}
}

Soluzioni complete per ogni esigenza