Share
Smarty è un motore / framework di template basato su PHP. Ti consente di separare ulteriormente la logica aziendale dalla sua visualizzazione, rimuovendo il più possibile il codice PHP dalle tue visualizzazioni. Alcuni sviluppatori e framework preferiscono non utilizzare un motore di template, altri preferiscono l'utilizzo di PHP nelle viste. Entrambi i punti di vista possono essere discussi e, alla fine, è principalmente una questione di gusti. Ad ogni modo, non è mai una cattiva idea provarlo prima di decidere di non usarlo, e questo è ciò di cui tratta questo tutorial: provare lo Smarty Templating Framework.
Alla fine di questo tutorial, avrai un'idea di base su come funziona Smarty. Sarai in grado di caricare i file modello, passare le variabili a loro, utilizzare un "layout" in cui sono inserite le altre visualizzazioni e scrivere i tuoi modificatori. Tutto ciò verrà realizzato utilizzando una classe wrapper aggiuntiva, che è possibile integrare facilmente nei progetti esistenti.
Il progetto per questo tutorial avrà una configurazione molto semplice, dal momento che non stiamo sviluppando un'applicazione reale. Basta creare una cartella di progetto (la mia si chiama "smarty_example") con dentro un file index.php e una directory chiamata "lib" al suo interno. Inoltre, crea un file chiamato smtemplate.php nella cartella "lib". Quindi, crea una cartella "views" all'interno di "smarty_example". Questa cartella conterrà i nostri file modello smarty.
Prima di poter usare qualcosa, devi installarlo. Per fortuna, l'installazione di Smarty è estremamente semplice e non richiede quasi nessuna configurazione. Prima di tutto, scarica Smarty ed estrai l'archivio. Puoi controllare tutto all'interno dell'archivio, ma ci servirà solo la cartella "libs" per la nostra applicazione. Rinominalo in "smarty" e incollalo nella cartella "lib" della nostra applicazione. Smarty utilizza alcune cartelle aggiuntive, quindi crea le cartelle "templates_c", "cache" e "configs" all'interno della nostra cartella "lib / smarty". Se non stai usando Windows, dovrai assegnare 775 permessi su queste cartelle al tuo webserver. L'albero delle directory dovrebbe ora apparire come questo:
Ogni programmatore ha la sua idea sull'API ideale. Per adeguare leggermente le API di Smarty e consentirci di aggiungere alcune funzionalità aggiuntive, creeremo una classe wrapper chiamata SMTemplate, che si prenderà cura dei dettagli di smarty per noi. Questo approccio ha un altro vantaggio: se, in un momento, dovresti scegliere di utilizzare un altro motore di template, puoi creare un wrapper per quel motore, mantenendo l'interfaccia SMTemplate, e quindi senza rompere il codice che usa la nostra classe SMTemplate.
Prima di codificare la funzionalità della classe SMTemplate, avremo bisogno di un posto dove archiviare alcuni dettagli di configurazione. Puoi farlo in diversi modi, ovvero definendo le opzioni di configurazione come costanti di classe, definendole come costanti nel file smtemplate.php o conservandole in un file di configurazione separato. Preferisco l'ultima opzione, quindi creerò un file smtemplate_config.php. Smarty ha bisogno di configurazione per il modello, le cartelle compilate template, cache e config. In seguito, potremmo anche aggiungere le opzioni specifiche di SMTemplate al nostro file di configurazione, ma per ora, ciò avverrà:
Accentsconagua
/ ** * @file * File di configurazione per la classe SMTemplate * / $ smtemplate_config = array ('template_dir' => 'views /', 'compile_dir' => 'lib / smarty / templates_c /', 'cache_dir' => ' lib / smarty / cache / ',' configs_dir '=>' lib / smarty / configs / ',); La classe SMTemplate caricherà questo file di configurazione e passerà le opzioni a Smarty. Prima di poter passare le opzioni, avremo bisogno di un oggetto di classe Smarty. La nostra classe SMTemplate potrebbe estendere la classe Smarty, ma preferisco usare una variabile di istanza privata per contenere l'oggetto Smarty. Finora, abbiamo il seguente per la nostra classe SMTemplate:
/ ** * @file * Wrapper per Smarty Template Engine * / require_once ('smarty / Smarty.class.php'); require_once ( 'smtemplate_config.php'); class SMTemplate private $ _smarty; function __construct () $ this -> _ smarty = new Smarty (); global $ smtemplate_config; $ this -> _ smarty-> template_dir = $ smtemplate_config ['template_dir']; $ this -> _ smarty-> compile_dir = $ smtemplate_config ['compile_dir']; $ this -> _ smarty-> cache_dir = $ smtemplate_config ['cache_dir']; $ this -> _ smarty-> configs_dir = $ smtemplate_config ['configs_dir']; Come puoi vedere, la nostra classe è ancora piuttosto patetica, in quanto non può rendere nulla. Risolveremo questo problema aggiungendo una funzione di rendering, che carica un modello e lo visualizza.
function render ($ template) $ this -> _ smarty-> display ($ template. '.tpl');
Per eseguire il rendering di qualsiasi cosa, dobbiamo creare un file modello e quindi chiamare la funzione di rendering dal nostro file index.php. Il file modello sarà piuttosto semplice, contenente una semplice pagina html. Chiamalo "home.tpl" e posizionalo nella nostra directory "views".
Casa Ciao mondo!
Ora, tutto ciò che rimane è creare un oggetto SMTemplate e renderizzare "home". Apri index.php, aggiungi le seguenti linee di codice e naviga nel tuo browser.
require_once ( 'lib / smtemplate.php'); $ tpl = new SMTemplate (); $ Tpl-> render ( 'casa');
Se non potessimo rendere nulla dinamicamente, Smarty sarebbe piuttosto inutile. Fortunatamente, possiamo assegnare variabili alla nostra classe smarty e mostrarle nel nostro modello. Possiamo anche usare alcune funzioni di Smarty (beh, in realtà i modificatori) per formattarle nel modo giusto.
Sebbene Smarty supporti l'assegnazione di variabili, la nostra SMTemplate non lo fa (ancora). Forniremo lo stile di assegnazione CodeIgniter, in cui si passa una matrice alla funzione di rendering. È possibile adattare SMTemplate anche per supportare altri metodi; ad esempio, assegnarli all'oggetto e quindi usare __set per memorizzarli in un array è anche un modo pulito. Per questo tutorial, però, passerà un array. Prima di assegnare le variabili, modificheremo il nostro modello con qualcosa di un po 'più dinamico. Dire ciao al mondo è consuetudine per i programmatori, ma non molto utile, quindi usiamo una variabile per determinare chi stiamo salutando. In secondo luogo, aggiungeremo la data di oggi al messaggio. Le variabili possono essere visualizzate avvolgendole tra parentesi graffe.
Ciao, $ destinatario! Oggi è $ date!
Se aggiorni la pagina, vedrai che le variabili non sono state compilate, poiché non le abbiamo impostate. L'impostazione delle variabili può essere eseguita usando smarty-> assign, quindi assegniamoli. La funzione di rendering ora prenderà un array di dati opzionale come secondo argomento.
funzione render ($ template, $ data = array ()) foreach ($ data as $ key => $ valore) $ this -> _ smarty-> assign ($ key, $ value); $ this -> _ smarty-> display ($ template. '.tpl');
Ancora non funzionerà, perché non passiamo in un array quando chiamiamo la nostra funzione di rendering. Possiamo farlo facilmente, modificando alcune righe nel nostro file index.php.
$ data = array ('receiver' => 'JR', 'date' => time (),); $ tpl = new SMTemplate (); $ tpl-> render ('home', $ data); Se aggiorni ora, la pagina dirà qualcosa come "Ciao, JR! Oggi è 1282810169!". Certo, questa data non è proprio quello che avevamo in mente. Deve essere formattato, il che ci porta alla prossima sezione.
Smarty non è solo un motore di template che cerca e sostituisce le variabili. È anche un potente framework che ti consente di risparmiare tempo usando cose come modificatori, funzioni e blocchi. Se desideriamo formattare la nostra data, ad esempio, possiamo usare il modificatore date_format. Per applicare un modificatore a una variabile, è sufficiente posizionare un carattere pipe e il nome del modificatore dietro di esso, seguito dagli argomenti opzionali che sono separati da due punti. Il modificatore date_format accetta un argomento stringa, che rappresenta il formato che la data richiederà e una data predefinita facoltativa, di cui non avremo bisogno. Il seguente codice visualizzerà la data come "giorno (in decimale) Mese".
Ciao, $ destinatario! È $ date | date_format: "% d% B" oggi!
Questo dovrebbe ora dare qualcosa del formato "Ciao, JR! Oggi è il 26 agosto!" Ora, forse vogliamo assicurarci che il nostro ricevitore sia maiuscolo. Possiamo ottenere ciò usando il modificatore superiore.
Ciao, $ ricevitore | superiore! È $ date | date_format: "% d% B" oggi!
Ora, se altero index.php per passare 'jr' invece di 'JR', il template mostrerà ancora 'JR'. Facile, non è vero? Successivamente, includeremo i nostri modelli in un "layout" predefinito.
Prima di modificare la nostra classe SMTemplate per abilitare i layout, creeremo prima un layout. Crea una nuova directory chiamata "layout" nella nostra cartella "smarty_example" e sposta home.tpl lì. Rinominalo in "page.tpl". Rimuoviamo il nostro precedente contenuto "ciao mondo" e inseriamo due righe orizzontali. Il nostro contenuto verrà inserito tra queste righe.
Casa
Ovviamente, questo non lo taglierà, dal momento che Smarty non saprà dove inserire il nostro contenuto. C'è più di un modo per ottenere contenuti da un altro modello all'interno del nostro layout, e userò la funzione di recupero di Smarty. Questa funzione restituisce il nostro modello come testo, invece di visualizzarlo. Ciò significa che possiamo recuperare il modello e quindi assegnarlo a una variabile da utilizzare all'interno del nostro modello! Il nome di questa variabile è tuo da scegliere. Prefisso le mie variabili speciali con __, per distinguerle dalle altre variabili che uso. Chiamerò questo "contenuto", dato che assegneremo il nostro contenuto della pagina ad esso.
Content __ $
Questo conclude il nostro layout, quindi creiamo alcuni modelli da utilizzare come contenuto. Creerò un modello "ciao", che conterrà una linea standard "ciao mondo" e un modello "lipsum", che contiene un testo di Lorem Ipsum. Non dimenticare di dare a questi modelli un'estensione .tpl.
Ciao mondo!
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Alieno di Aenean dignissim diam at vulputate. Aenean nec ligula ac dolor fringilla pharetra. Cras in agosto ac tellus dictum pellentesque. Integer elementum tempus lectus, non rutrum sem viverra a. Sed tincidunt sollicitudin dolor, ut blandit magna auctor non. Mecenate sed nibh felis. Donec dictum porta ante a faucibus. Morbi massa tellus, pulvino id porta id, imperdiet vel nibh. Donec lectus nulla, porttitor un tempor id, cursus vitae leo. Nulla eget nunc eu lorem posuere hendrerit ut ac urna. Aenean sodales lobortis egestas. Integer faucibus hendrerit tempor.
Anche l'adattamento della nostra classe SMTemplate all'utilizzo di un layout è estremamente semplice. Per prima cosa configureremo un'opzione di configurazione per la directory dei layout, come abbiamo fatto per le nostre visualizzazioni.
/ ** * @file * File di configurazione per la classe SMTemplate * / $ smtemplate_config = array ('layouts_dir' => 'layouts /', 'template_dir' => 'views /', 'compile_dir' => 'lib / smarty / templates_c / ',' cache_dir '=>' lib / smarty / cache / ',' configs_dir '=>' lib / smarty / configs / ',); Successivamente, cambieremo la nostra funzione di rendering. Forniremo il layout come terzo parametro opzionale e lo lasceremo come predefinito alla "pagina". Quindi, recupereremo il modello richiesto, lo assegneremo alla variabile del contenuto $ __ e mostreremo il nostro layout.
funzione render ($ template, $ data = array (), $ layout = 'page') foreach ($ data as $ key => $ valore) $ this -> _ smarty-> assign ($ key, $ value); $ content = $ this -> _ smarty-> fetch ($ template. '.tpl'); $ this -> _ smarty-> assegna ('__ content', $ content); $ this -> _ smarty-> display ($ layout. '.tpl'); Ci sono un paio di cose da considerare riguardo questo codice. Prima di tutto, non abbiamo ancora detto a Smarty dove trovare i nostri layout. Possiamo farlo aggiungendo una directory modello, ma questo approccio significa che non possiamo dare ai nostri layout lo stesso nome dei nostri modelli - Smarty non saprebbe quale scegliere. Potremmo risolvere questo problema dando ai nostri layout un'estensione diversa, oppure impostando e reimpostando la nostra directory di template all'interno della nostra funzione di rendering, o usando più funzioni Smarty avanzate. Per ora, ci accontenteremo solo del vincolo che layout e viste non possono avere lo stesso nome. Possiamo aggiungere la nostra directory di layout usando la funzione addTemplateDir ().
function __construct () $ this -> _ smarty = new Smarty (); global $ smtemplate_config; $ this -> _ smarty-> template_dir = $ smtemplate_config ['template_dir']; $ This -> _ smarty-> addTemplateDir ($ smtemplate_config [ 'layouts_dir']); // <- new line $this->_smarty-> compile_dir = $ smtemplate_config ['compile_dir']; $ this -> _ smarty-> cache_dir = $ smtemplate_config ['cache_dir']; $ this -> _ smarty-> configs_dir = $ smtemplate_config ['configs_dir'];
Diamo un'occhiata cambiando di nuovo il nostro file index.php.
require_once ( 'lib / smtemplate.php'); $ tpl = new SMTemplate (); $ Tpl-> render ( 'ciao');
Funziona!
E se lo cambiamo per rendere 'lipsum', funziona altrettanto bene:
Come parte finale di questo tutorial, introdurrò una delle funzionalità più avanzate di Smarty, che lo rendono più di un semplice motore di template. Smarty contiene una serie di funzioni e modificatori standard, ma è anche estremamente facile crearne di propri. Diamo un'occhiata al modificatore che abbiamo usato per formattare la nostra data:
$ date | date_format: "% d% B"
Se vuoi un modificatore personalizzato, tutto ciò che devi fare è scrivere una funzione PHP.
In pratica, ciò comporterà una chiamata alla funzione smarty_modifier_date_format (), con $ date e la nostra stringa di formato come argomenti. Questa funzione restituirà una stringa e questa stringa verrà visualizzata. Quindi se vuoi un modificatore personalizzato, tutto ciò che devi fare è scrivere una funzione PHP. Ad esempio, scriveremo un modificatore chiamato "weirdcase", che metterà in maiuscolo tutte le consonanti e tutte le vocali minuscole, ad esempio "Lorem Ipsum" diventa "LoReM IPSuM". Per fare ciò, crea un file chiamato "modifier.weirdcase.php" nella cartella "lib / smarty / plugins". Il nostro modificatore richiederà un solo argomento, la stringa che deve essere modificata.
/ ** * Modificatore di plugin Smarty weirdcase * * Tipo: modificatore * Nome: weirdcase * Scopo: trasformare le consonanti in maiuscolo e le vocali in minuscolo * @param string * @return string * / function smarty_modifier_weirdcase ($ string)
Possiamo ottenere i nostri risultati definendo una serie di "vocali", trasformando la nostra stringa in una matrice e poi attraversandola, e controllando se ciascun carattere si trova nella nostra matrice di vocali. Se lo è, lo mettiamo in minuscolo, altrimenti lo mettiamo in ordine maiuscolo. I caratteri modificati vengono quindi aggiunti a una variabile di risultato.
function smarty_modifier_weirdcase ($ string) $ str_array = str_split ($ stringa); $ result = "; $ vowels = array ('a', 'e', 'i', 'o', 'u'); foreach ($ str_array as $ char) if (in_array ($ vocali, $ char) ) $ result. = strtolower ($ char); altrimenti $ result. = strtoupper ($ char); return $ result; Questo dovrebbe fare il trucco, quindi diamo un'occhiata. Modifica il modello "lipsum.tpl" e aggiungi un h1 contenente il nostro strano "Lorem Ipsum".
'Lorem Ipsum' | weirdcase
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Alieno di Aenean dignissim diam at vulputate. Aenean nec ligula ac dolor fringilla pharetra. Cras in agosto ac tellus dictum pellentesque. Integer elementum tempus lectus, non rutrum sem viverra a. Sed tincidunt sollicitudin dolor, ut blandit magna auctor non. Mecenate sed nibh felis. Donec dictum porta ante a faucibus. Morbi massa tellus, pulvino id porta id, imperdiet vel nibh. Donec lectus nulla, porttitor un tempor id, cursus vitae leo. Nulla eget nunc eu lorem posuere hendrerit ut ac urna. Aenean sodales lobortis egestas. Integer faucibus hendrerit tempor.
Sebbene ci sia molto più a Smarty di quanto potrei inserire in questo tutorial, spero che questo ti fornisca una conoscenza di base su come lavorarci. In sostanza, sai già tutto te bisogno sapere. Dovresti anche essere in grado di determinare se ti piace l'idea di usare questa struttura dei modelli o no adesso. Gli argomenti più avanzati, come filtri e blocchi, sono utili, tuttavia continuerai a farli senza di loro. È possibile trovare la documentazione sulle funzioni più avanzate sul sito Web Smarty. Grazie per aver letto!
