Best practice: qual è il modo migliore per costruire intestazioni e piè di pagina?

Question

Qual è il modo migliore per costruire intestazioni e piè di pagina? Dovresti chiamare tutto dal controller o includere dal file di visualizzazione? Sto usando CodeIgniter e voglio sapere qual è la migliore pratica per questo. Caricare tutti i file di visualizzazione inclusi dal controller, in questo modo?

class Page extends Controller {

   function index()
   {
      $data['page_title'] = 'Your title';
      $this->load->view('header');
      $this->load->view('menu');
      $this->load->view('content', $data);
      $this->load->view('footer');
   }

}

o chiamando il file di visualizzazione singola e chiamando da lì le visualizzazioni di intestazione e piè di pagina:

//controller file    
class Page extends Controller {

   function index()
   {
      $data['page_title'] = 'Your title';
      $this->load->view('content', $data);

   }

}

//view file

<?php $this->load->view('header'); ?>

<p>The data from the controller</p>

<?php $this->load->view('footer'); ?>

L'ho visto fare in entrambi i modi, ma voglio scegliere adesso prima di andare troppo avanti su un sentiero.

Answer 1

Puoi anche provarlo in questo modo: definisci un modello di visualizzazione predefinito, che quindi estrae il contenuto in base a una variabile ("contenuto" nel mio esempio) passata dal controller.

Nel controller:

$data['content'] = 'your_controller/index';

// more code...

$this->load->vars($data);
$this->load->view('layouts/default');

Quindi definire un layout predefinito per tutte le pagine, ad es. views / layout / default.php

// doctype, header html etc.

<div id="content">
    <?= $this->load->view($content) ?>
</div>

// footer html etc.

Quindi le tue visualizzazioni possono contenere solo il contenuto puro, ad es. views / your_controller / index.php potrebbe contenere solo le variabili passate dal controller / array di dati

<?= $archives_table ?>
<?= $pagination ?>
// etc.

Maggiori dettagli sul wiki CI / FAQ - (Q. Come posso incorporare le viste all'interno delle viste ? Modelli nidificati? ...)

Answer 2

In realtà, dopo aver studiato questo un po 'da solo, sono giunto alla conclusione che la migliore pratica per includere intestazioni e piè di pagina in MVC è una terza opzione: estendere un controller di base. Questo ti darà un po 'più di flessibilità rispetto ai suggerimenti di htxt, in particolare se stai costruendo un layout molto modulare (non solo intestazione e piè di pagina, anche pannelli della barra laterale, menu non statici, ecc.)

Innanzitutto, definisci una classe Base_controller, in cui crei metodi che aggiungono gli elementi della tua pagina (intestazione, piè di pagina, ecc.) a una stringa di output:

class Base_controller extends Controller
{
    var 
 In realtà, dopo aver studiato questo un po 'da solo, sono giunto alla conclusione che la migliore pratica per includere intestazioni e piè di pagina in MVC è una terza opzione: estendere un controller di base. Questo ti darà un po 'più di flessibilità rispetto ai suggerimenti di htxt, in particolare se stai costruendo un layout molto modulare (non solo intestazione e piè di pagina, anche pannelli della barra laterale, menu non statici, ecc.) 

 Innanzitutto, definisci una classe Base_controller, in cui crei metodi che aggiungono gli elementi della tua pagina (intestazione, piè di pagina, ecc.) a una stringa di output: 

class Page_controller extends Base_controller
{
    function index()
    {
        $data = ...; // Set content data here
        $this->_standard_page($data);
    }

    function admin()
    {
        $data = ...; // Set content and header data here
        $this->_page_with_admin_header($data);
    }
}


 Quindi, nei controller di pagina, estendi semplicemente la classe base e chiama le tue funzioni per creare la pagina. 

<*>

 Utilizzando un controller di base, è possibile ottenere un codice molto pulito nei singoli controller di pagina E avere viste separate per gli elementi della pagina (consentendo il riutilizzo del codice in entrambe le viste e i controller). Tutto quello che devi fare è definire la tua pagina comune "sezioni" (ciò che potresti essere tentato di chiamare "frammenti") come funzioni nel tuo controller di base. 

 E se il controller di base dovesse iniziare a crescere in modo incontrollato (cosa che può accadere su siti di grandi dimensioni), puoi riorganizzare alcune delle sue funzioni meno generali inserendole in sottoclassi e lasciare che i controller di pagina corrispondenti estendano quelli invece dell'originale controller di base. 

 Enjoy! 

 / Jens Roland 
output = '';

    function _standard_header($data=null)
    {
        if (empty($data))
            $data = ...; // set default data for standard header here

        $this->_output .= $this->load->view('header', $data, true);
    }

    function _admin_header($data=null)
    {
        if (empty($data))
            $data = ...; // set default data for expanded header here

        $this->_output .= $this->load->view('admin_header', $data, true);
    }

    function _standard_page($data)
    {
        $this->_standard_header();
        $this->_output .=
            $this->load->view('standard_content', $data, true);
        echo $this->_output; // note: place the echo statement in a
                             // separate function for added flexibility
    }

    function _page_with_admin_header($data)
    {
        $this->_admin_header($data);
        $this->_output .=
            $this->load->view('standard_content', $data, true);
        echo $this->_output;
    }
}

Quindi, nei controller di pagina, estendi semplicemente la classe base e chiama le tue funzioni per creare la pagina.

<*>

Utilizzando un controller di base, è possibile ottenere un codice molto pulito nei singoli controller di pagina E avere viste separate per gli elementi della pagina (consentendo il riutilizzo del codice in entrambe le viste e i controller). Tutto quello che devi fare è definire la tua pagina comune "sezioni" (ciò che potresti essere tentato di chiamare "frammenti") come funzioni nel tuo controller di base.

E se il controller di base dovesse iniziare a crescere in modo incontrollato (cosa che può accadere su siti di grandi dimensioni), puoi riorganizzare alcune delle sue funzioni meno generali inserendole in sottoclassi e lasciare che i controller di pagina corrispondenti estendano quelli invece dell'originale controller di base.

Enjoy!

/ Jens Roland

Answer 3

Penso che il primo modo in cui lo fai sia più pulito. Semplicemente dal punto di vista del sapere che verrà reso. Invece di dover inserire il file di visualizzazione per trovare il resto.

Answer 4

È una cattiva pratica chiamare viste all'interno di altre viste. Questa potrebbe essere una forma di missaggio della vista del controller. La funzione di visualizzazione in CI consente di passare un terzo parametro che gli fa restituire l'output di viste come stringa. Puoi usarlo per creare una vista composta.

Ad esempio:

class Page extends Controller {
   function index() {
      $data['page_title'] = 'Your title';

      $this->load->view('default_layout', array(
         'header'  => $this->load->view('header' , array(), true), 
         'menu'    => $this->load->view('menu'   , array(), true), 
         'content' => $this->load->view('content', $data  , true), 
         'footer'  => $this->load->view('footer' , array(), true), 
      ));
   }
}

default_layout.php

<? echo $header, $menu, $content, $footer; ?>

Potresti voler combinare intestazione e piè di pagina per creare un modello come questo.

class Page extends Controller {
   function index() {
      $data['page_title'] = 'Your title';

      $this->load->view('default_template', array(
         'menu'    => $this->load->view('menu'   , array(), true), 
         'content' => $this->load->view('content', $data  , true), 
      ));
   }
}

default_template.php

<html><head></head><body><span>Some Header HTML</span> // this is your header html
<? echo $menu, $content; ?>
<span>some footer HTML</span></body></html>  // this is your footer html