Share
Le viste sono un ingrediente chiave in qualsiasi applicazione MVC e le applicazioni CodeIgniter non sono diverse. Oggi scopriremo cos'è una vista e scopriremo come possono essere utilizzati per creare una soluzione di template per i tuoi progetti CodeIgniter.
La prima parte di questo tutorial istruirà i principianti completi su CodeIgniter su cosa sia una vista e su come usarli in un'applicazione tipica. La seconda metà discuterà le motivazioni per trovare una soluzione per i modelli e guiderà il lettore attraverso i passaggi necessari per creare una libreria di template semplice ma efficace.
Se vuoi fare di più con CodeIgniter, controlla la gamma di plugin CodeIgniter e script di codice sul mercato Envato.
Plugin CodeIgniter e script di codice sul mercato Envato Le viste sono file speciali utilizzati in CodeIgniter per archiviare la marcatura emessa dall'applicazione, in genere costituita da tag HTML e semplici PHP.
"Una vista è semplicemente una pagina web, o un frammento di pagina, come un'intestazione, un piè di pagina, una barra laterale, ecc. In effetti, le viste possono essere integrate in modo flessibile all'interno di altre visualizzazioni (all'interno di altre viste, ecc. Ecc.) Se ti serve tipo di gerarchia. "
Le viste vengono caricate dai metodi del controller, con il contenuto all'interno della visualizzazione successivamente visualizzato nel browser.
Per caricare (e visualizzare) una vista in CodeIgniter, usiamo la libreria Loader integrata.
Accentsconagua
$ this-> load-> view ('hello_world', $ data, true / false); Questa singola riga di codice dirà a CodeIgniter di cercare hello_world.php nel applicativi / viste cartella e visualizza i contenuti del file nel browser.
Nota CodeIgniter ti consente di escludere il suffisso .php, salvando alcune sequenze di tasti durante la digitazione del nome file della vista che desideri caricare.
Il secondo parametro, $ data, è opzionale e prende un array o un oggetto associativo. Questo array / oggetto viene utilizzato per passare i dati al file di visualizzazione, quindi può essere utilizzato o referenziato all'interno della vista.
Il finale opzionale parametro determina se il contenuto della vista viene visualizzato nella finestra del browser o restituito come stringa. Questo parametro è impostato su false, visualizzando il contenuto nel browser. Vedremo più avanti nel tutorial come questo parametro può essere usato quando si crea una soluzione di template.
Per impostare la nostra prima vista, crea un nuovo file chiamato hello_world.php nel applicativi / viste e scrivi il seguente semplice codice HTML all'interno:
Ciao mondo! Ciao mondo!
Ora per visualizzare questa vista nel browser deve essere caricata all'interno di un metodo Controller, utilizzando il metodo sopra menzionato.
Creiamo quindi un nuovo file Controller chiamato hello_world.php nel application / controller e inserire il seguente codice all'interno. Da questo controller, caricheremo la vista appena creata.
load-> view ( 'hello_world');
Puntando il tuo browser a http://your-ci-install.com/index.php/ ora comporterà l'HTML in application / views / hello_world.php in uscita nel browser. Hai caricato correttamente una vista!
La suddivisione di una vista in più file rende il tuo sito Web più semplice da mantenere e riduce il rischio di duplicare il codice.
Visualizzare una singola vista va benissimo, ma potresti voler dividere l'output in diversi file distinti, come ad esempio intestazione, contenuto e piè di pagina visualizzazioni.
Il caricamento di più viste si ottiene semplicemente chiamando il $ This-> load-> view () metodo più volte. CodeIgniter quindi concatena il contenuto delle viste insieme prima di essere visualizzato nel browser.
Crea un nuovo file chiamato header.php nel applicativi / viste e taglia e incolla le prime righe del nostro originale hello_world.php file in.
Ciao mondo!
Allo stesso modo, crea un altro file chiamato footer.php nel applicativi / viste e sposta le ultime due righe di hello_world.php nel.
Questo lascia il hello_world.php guarda il file che contiene solo il nostro contenuto della pagina.
Ciao mondo!
Ora per visualizzare nuovamente la pagina, dobbiamo caricare tutte e tre le viste (header.php, hello_world.php, footer.php), nell'ordine, all'interno del nostro controller.
Riaprire application / controller / hello_world.php e aggiungi il nuovo $ This-> load-> view () chiama sopra e sotto quello esistente.
load-> view ( 'intestazione'); $ This-> load-> view ( 'hello_world'); $ This-> load-> view ( 'piè di pagina');
Perché le viste di intestazione e piè di pagina sono ora separate dal Ciao mondo vista, significa che possono essere utilizzati in combinazione con qualsiasi altra vista nel sito web. Ciò significa che il codice all'interno dei file di intestazione e piè di pagina non deve essere copiato in altre viste nel progetto che richiedono questo codice.
Ovviamente questo è un vantaggio enorme in quanto qualsiasi modifica all'HTML o al contenuto delle viste, ad esempio l'aggiunta di un nuovo foglio di stile nell'intestazione, può essere apportata a un solo file e non a tutti i file!
Ora, esamineremo i dati trasmessi dai controller, in modo che possano essere utilizzati o emessi all'interno della vista.
Per raggiungere questo obiettivo, passeremo un array associativo, $ data come secondo parametro nel $ This-> load-> view () chiamata.
Il valori di questo array sarà accessibile all'interno della vista caricata come variabili, nominate dai rispettivi chiavi.
$ data = array ('title' => 'Hello World!', 'content' => 'Questo è il contenuto', 'posts' => array ('Post 1', 'Post 2', 'Post 3') ); $ this-> load-> view ('hello_world', $ data); Il codice sopra fornirà la variabile $ titolo il valore 'Ciao mondo!' dentro il Ciao mondo vista.
Una volta passati i nostri dati ai file di visualizzazione, le variabili possono essere utilizzate nel solito modo.
In genere, il file di visualizzazione utilizzerà i dati passati per:
Correrò attraverso brevi esempi su come fare ciascuno.
Per visualizzare il contenuto di una variabile usa l'istruzione echo semplice e familiare:
Il looping attraverso un array, o oggetto, è un'attività comune nei file di visualizzazione e può essere ottenuto con un ciclo foreach:
È possibile utilizzare semplici istruzioni condizionali nei file di visualizzazione per modificare leggermente l'output, in base ai dati trasmessi.
In generale, si desidera mantenere l'utilizzo delle istruzioni condizionali nelle viste al minimo, in quanto un uso eccessivo può portare a file di visualizzazione complessi, contenenti "logica aziendale". La divisione della vista in file diversi e la decisione su quale deve essere visualizzata nel controller, è molto più preferibile.
Accedete, per favore
L'esempio sopra mostrerà un messaggio di "Benvenuto" o una richiesta per l'accesso dell'utente, in base al valore di $ logged_in (vero falso).
Abbiamo visto come dividere le viste in file separati e più piccoli può aiutare a organizzare e ridurre il numero di file nei progetti CodeIgniter, ma ora è necessario effettuare più chiamate di visualizzazione del caricamento per ciascuna istanza in cui viene visualizzata una pagina.
Supponiamo che tu abbia viste di intestazione e piè di pagina separate, utilizzate per formare un modello. Ogni istanza nel progetto in cui si desidera caricare e visualizzare una pagina utilizzando questo modello, è necessario chiamare tre carichi di vista. Non solo questo può ingombrare i controller, ma si traduce in un sacco di codice ripetuto - esattamente la cosa di cui volevamo sbarazzarci suddividendo i file.
Se vuoi aggiungere ulteriori markup a questo modello ora, ad esempio un menu della barra laterale. Potrebbe andare nella visualizzazione dell'intestazione, ma è più adatto per essere nella sua vista separata. Aggiungere questa nuova vista al modello esistente significa passare attraverso ogni istanza della vista carica e aggiungerne un'altra. Questo può diventare fastidioso velocemente.
Abbiamo bisogno di un modo per essere in grado di incorporare i file di visualizzazione che visualizzano il contenuto di una singola pagina, all'interno di un modello, senza ripetere il codice e uno che consente di apportare modifiche al modello facilmente e in modo efficiente.
I seguenti passaggi ti guideranno attraverso la creazione di una semplice libreria CodeIgniter che soddisfi queste esigenze, oltre a:
Una volta che la libreria è stata scritta e nella nostra cintura degli strumenti CodeIgniter, saremo in grado di visualizzare una pagina basata su un modello in questo modo:
$ this-> template-> load ('template_name', 'body_view'); Molto più bello!
La nostra soluzione di template utilizzerà i file di visualizzazione che contengono il markup completo di un modello, con un segnaposto per un altro file di visualizzazione (con il contenuto della pagina) da incorporare all'interno.
Il segnaposto sarà in realtà solo una variabile chiamata $ corpo. Quando si carica una vista basata su modelli con la nostra libreria, il contenuto del file di visualizzazione del corpo appropriato verrà assegnato a questo $ corpo, incorporare la vista all'interno del modello.
Vogliamo imporre un sistema di directory ragionevole e prevedibile per i nostri file di visualizzazione che devono essere ospitati, in modo che le nostre opinioni siano:
Il nostro sistema di directory consentirà inoltre alla libreria di determinare in modo intelligente dove cercare i file di visualizzazione, riducendo la quantità di codice necessaria per caricare una vista basata su modelli.
Crea una nuova cartella all'interno del applicativi / viste directory e chiamarlo modelli. Questa cartella manterrà le diverse viste del modello.
Le librerie in CodeIgniter sono solo classi PHP e vengono caricate in controller molto simili alle visualizzazioni.
$ This-> load-> library ( 'class_name');
Le librerie personalizzate utilizzate nei progetti CodeIgniter sono archiviate nel applicazioni / librerie cartella. Per iniziare a scrivere la nostra libreria di template, crea un nuovo file in questa cartella chiamata template.php, e inserire il seguente codice in:
ci = e get_instance ();
Il codice precedente definisce una nuova classe, o libreria, chiamata Modello e il __costruire() metodo all'interno.
Questo metodo assegna il super oggetto CodeIgniter al $ ci variabile di classe, che consente di utilizzare tutte le risorse di CodeIgniter sostituendo $ questo con $ This-> ci nel solito metodo chiama.
Quando la libreria è caricata nel framework CodeIgniter, il __costruire() il metodo viene automaticamente chiamato.
Ora scriveremo il metodo per caricare effettivamente una vista modello. Vogliamo passare fino a tre parametri per questa funzione:
Il risultato della chiamata di questo metodo sarà la vista modello visualizzata nel browser, con la vista del corpo incorporata all'interno, se ne viene fornita una.
Sotto il __costruire() metodo, inserire il seguente codice:
funzione load ($ tpl_view, $ body_view = null, $ data = null) if (! is_null ($ body_view)) if (file_exists (APPPATH.'views /'.$ tpl_view. '/'. $ body_view)) $ body_view_path = $ tpl_view. '/'. $ body_view; else if (file_exists (APPPATH.'views /'.$ tpl_view. '/'. $ body_view. '. php')) $ body_view_path = $ tpl_view. '/'. $ body_view. '. php'; else if (file_exists (APPPATH.'views /'.. body_view)) $ body_view_path = $ body_view; else if (file_exists (APPPATH.'views /'.. body_view. '. php')) $ body_view_path = $ body_view. '. php'; else show_error ('Impossibile caricare il file richiesto:'. $ tpl_name. '/'. $ view_name. '. php'); $ body = $ this-> ci-> load-> view ($ body_view_path, $ data, TRUE); if (is_null ($ data)) $ data = array ('body' => $ body); else if (is_array ($ data)) $ data ['body'] = $ body; else if (is_object ($ data)) $ data-> body = $ body; $ this-> ci-> load-> view ('templates /'.$ tpl_view, $ data); Il codice precedente inizia controllando se il $ body_view parametro è stato fornito al metodo. Questa variabile manterrà il nome della vista da utilizzare come corpo nella vista modello.
se (! is_null ($ body_view))
Se il parametro viene fornito, vengono eseguiti una serie di controlli file_exists per provare e individuare il file di visualizzazione all'interno del nostro sistema di directory.
if (file_exists (APPPATH.'views /'.$ tpl_view. '/'. $ body_view)) $ body_view_path = $ tpl_view. '/'. $ body_view; else if (file_exists (APPPATH.'views /'.$ tpl_view. '/'. $ body_view. '. php')) $ body_view_path = $ tpl_view. '/'. $ body_view. '. php';
Il codice tenta innanzitutto di individuare il file di visualizzazione all'interno di una cartella con lo stesso nome del modello nel applicativi / viste cartella.
Questo è utile se sezioni del tuo progetto sono drasticamente diverse dalle altre e usano modelli differenti. In queste circostanze, ha senso raggruppare insieme questi file di visualizzazione.
Ad esempio, molti siti Web mostrano un modello diverso per sezioni distinte, come i blog. Nel nostro sistema, i file di visualizzazione del blog possono essere inseriti all'interno del application / views / blog cartella, separandoli dalle viste del sito principale.
Se il file di visualizzazione non può essere localizzato in questa cartella, .php viene aggiunto alla fine del nome file e il controllo viene eseguito nuovamente. Questo è semplicemente così .php può essere escluso come il nativo $ This-> load-> view () chiamata.
Se il file non può ancora essere localizzato, vengono fatti ulteriori controlli per la sua posizione.
else if (file_exists (APPPATH.'views /'.. body_view)) $ body_view_path = $ body_view; else if (file_exists (APPPATH.'views /'.. body_view. '. php')) $ body_view_path = $ body_view. '. php'; else show_error ('Impossibile caricare il file richiesto:'. $ tpl_name. '/'. $ view_name. '. php'); Questa volta, il codice controlla se il file di visualizzazione si trova all'interno di applicativi / viste cartella, e ancora una volta, se non può essere trovato, aggiunge .php e controlla ancora una volta.
Se il file si trova in una di queste posizioni, il percorso è assegnato a $ body_view_path, in caso contrario viene generato un messaggio di errore utilizzando il show_error () funzione integrata in CodeIgniter e lo script è terminato.
Se il file di visualizzazione del corpo è stato localizzato correttamente, il contenuto è assegnato a $ corpo variabile.
$ body = $ this-> ci-> load-> view ($ body_view_path, $ data, TRUE);
Noi passiamo il $ data parametro (null se non fornito) alla chiamata di caricamento della vista e impostare il terzo parametro su vero per restituire l'output della vista come una stringa.
Ora aggiungiamo questo $ corpo variabile alla lista di dati in $ data in modo che possa essere incorporato nella vista modello quando viene caricato.
if (is_null ($ data)) $ data = array ('body' => $ body); else if (is_array ($ data)) $ data ['body'] = $ body; else if (is_object ($ data)) $ data-> body = $ body; Se $ data non è stato fornito al caricare() chiamata, $ data è assegnato a un array che contiene $ corpo sotto chiave corpo. Se il parametro è stato fornito, $ corpo viene aggiunto all'elenco assegnandolo a una chiave di array o a una proprietà dell'oggetto, entrambi denominati corpo.
Il $ corpo la variabile può ora essere utilizzata nei file di visualizzazione del modello come segnaposto per visualizzazioni incorporate.
L'ultima riga del nostro metodo carica il file di visualizzazione del modello da applicazione / Vista / templates cartella e passa il $ data variabile nel secondo parametro.
$ this-> ci-> load-> view ('templates /'.$ tpl_name, $ data); E questo è tutto! La biblioteca può ora essere utilizzata.
Per iniziare a utilizzare la nostra libreria, creiamo una vista modello, denominata default.php nel applicazione / Vista / templates, e posizionare il seguente codice HTML / PHP all'interno:
<?php echo $title; ?> Modello predefinito
In questo modello, facciamo riferimento a due variabili, $ titolo e $ corpo.
Ricordalo nei nostri file modello, $ corpo funge da segnaposto per una vista incorporata.
Ora faremo un'altra vista per essere incorporati all'interno di questo modello. Crea un nuovo file chiamato content.php nel application / views / e metti questo semplice HTML dentro:
Ciao mondo!
Ora siamo pronti per caricare la visualizzazione della pagina basata su modello da un controller.
All'interno di qualsiasi metodo di controller, inserire il seguente codice per visualizzare il soddisfare vista, all'interno del predefinito modello.
$ data = array ('title' => 'Il titolo va qui',); $ This-> load-> library ( 'template'); $ this-> template-> load ('default', 'content', $ data); Nota: la libreria deve essere caricata prima di poter chiamare il caricare metodo. Per salvare te stesso caricando la libreria ogni volta che è necessario visualizzare una vista modello,
caricare automaticamente la classe aggiungendola alla serie di librerie in application / config / autoload.php.
Se invece di un file di visualizzazione, vuoi che una stringa sia incorporata nel modello, assegna semplicemente la stringa al file $ data array usando la chiave corpo, e passare nullo come secondo parametro nella chiamata di caricamento.
$ data = array ('title' => 'Title goes here', 'body' => 'La stringa da incorporare qui!'); $ this-> template-> load ('default', null, $ data); Ho scoperto che il raggruppamento dei file di visualizzazione nelle cartelle dal controller e persino il metodo a cui appartengono contribuisce davvero a mantenere le mie visualizzazioni organizzate e facili da individuare.
Organizzare le tue visualizzazioni in questo modo porta alla struttura delle directory seguendo da vicino lo schema URL di controllore / metodo.
Ad esempio, supponi che il tuo progetto abbia un controller chiamato Utenti, contenente il metodo elenco.
Una posizione appropriata per il elenco visualizzare il file sarebbe in applicazione / views / membri, o application / views / soci / lista, se questo metodo carica più viste.
Questa vista potrebbe quindi essere incorporata in un modello utilizzando la nostra libreria con il seguente codice:
$ this-> template-> load ('template_name', 'members / list'); La soluzione di template discussa in questo tutorial è solo uno dei tanti modi per ottenere i template in CodeIgniter.
Speriamo che ora sappiate quali sono le opinioni e come usarle efficacemente ed efficientemente nei vostri progetti CodeIgniter.
La soluzione per i modelli discussa in questo tutorial è solo uno dei tanti modi per ottenere i template in CodeIgniter. Esistono diversi approcci diversi e incoraggio te, lettore, a ricercare gli altri metodi e determinare quale sia la soluzione migliore per i tuoi progetti.
Se hai commenti o domande sul tutorial o su approfondimenti su diverse soluzioni di template, per favore lascia un commento qui sotto! Grazie per aver letto.
