frankx: Templateengine PHP MVC

Hellihello

gibt es einen "gängigen" Weg bezüglich der Verarbeitung von Templates bei der Realisierung von MVC fragte ich mich. Nach kurzem Googlen (http://www.phpforum.de/forum/showthread.php?t=205289, http://de.wikipedia.org/wiki/Template_Engine) finde ich aber u.a. bei Wikipedia den Satz: "Aufgrund eines Missverständnisses werden viele Template Engines von Programmierern eingesetzt, um im Kontext von Web-Applikationen Programm-Code (einer Programmiersprache) vom Design zu trennen."

U.g. Beispiel ist aber gerade aus dem Bedürfnis enstanden, HTML-Code herzustellen, ohne

<?php echo Document::$title?>

oder Domfunktionen wie

$simple_xml->$title="mein Titel";

oder gar

  
foreach ($data as $datum)  
{  
  echo "<td>$datum</td>\n";  
}  

zu bemühen. Ist u.g. zielführend, verbesserungsfähig und/oder Geschmacksache?

  
Verwendung von Templateengine in PHP  
<?php  
ob_start()  
?>  
 <td>{name}</td><td>{contact}</td><td>{since}</td>  
<?php  
$template = ob_get_clean();  
  
class Small_Template_Handler  
{  
 private static $template = "";  
 private static $used_placeholders = array();  
 private static $data = array();  
 private static $output = "";  
  
 private function find_used_placeholders ()  
 {  
  $pattern = '/\{(.*?)\}/';  
  $subject = self::$template;  
  preg_match_all($pattern, $subject, $matches);  
  self::$used_placeholders = array_unique($matches[1]);  
 }  
  
 private function replace_placeholders ()  
 {  
  foreach (self::$used_placeholders as $placeholder)  
  {  
   if (isset(self::$data[$placeholder]))  
   {  
    $search="{".$placeholder."}";  
    $replacement = self::$data[$placeholder];  
    $subject = self::$output;  
    self::$output = str_replace($search, $replacement, $subject);  
   }  
  }  
 }  
  
 public static function handle ($template, $data)  
 {  
  self::$output = self::$template = $template;  
  self::$data = $data;  
  self::find_used_placeholders();  
  self::replace_placeholders ();  
  return self::$output;  
 }  
}  
$data["name"] = "Müller";  
$data["contact"] = "Telefon";  
$data["since"] = "1.1.1800";  
$output = Small_Template_Handler::handle($template, $data);  
var_dump($output);  
?>  

Das ganze müsste ja im zweiten Schritt noch irgendwie rekursiv aufgerufen werden können mit einem Template a la:

<!-- /DBLOCK --><td>{name}</td><td>{contact}</td><td>{since}</td><!-- DBLOCK/ -->

um Übersichten für Lists of Hashes herzustellen. Der Framesworks hierzu scheint es ja einige zu geben, eine Art "Standard" (a la CSV für ein Tabellenformat) aber scheints nicht, oder?

Dank und Gruß,

frankx

--
tryin to multitain  - Globus = Planet != Welt
  1. Hallo Robert,

    Ist u.g. zielführend, verbesserungsfähig und/oder Geschmacksache?

    warum findet sich Deine Klasse mitten im restlichen PHP-Code wieder?
    Warum verwendest Du Output-Buffering? Was versprichst Du Dir davon?

    <?php
    ob_start()
    ?>
    <td>{name}</td><td>{contact}</td><td>{since}</td>
    <?php
    $template = ob_get_clean();

    class Small_Template_Handler

    [...]

    }
    $data["name"] = "Müller";
    $data["contact"] = "Telefon";
    $data["since"] = "1.1.1800";
    $output = Small_Template_Handler::handle($template, $data);
    var_dump($output);
    ?>

      
    Was hat Dein Beispielcode mit MVC zu tun?  
    Warum ist Dein Code nicht kommentiert?  
      
    Verbesserungsvorschläge, von den wichtigsten zu den unwichtigeren:  
      
     Kommentiere Deinen Code.  
     Kommentiere Deinen Code.  
     Kommentiere Deinen Code.  
      
     [... lange nichts besonders wichtiges ...]  
      
     Lagere Klassen in eigene Dateien aus.  
     Templates und Template-Snippets gehören in eigene Dateien.  
     Verwende kein Output-Buffering, wenn Du es nicht brauchst.  
      
      
    Freundliche Grüße  
      
    Vinzenz
    
    1. Hellihello Vinzenz,

      merci.

      warum findet sich Deine Klasse mitten im restlichen PHP-Code wieder?
      Warum verwendest Du Output-Buffering? Was versprichst Du Dir davon?

      Oh sorry, nur für den Einstieg. Jetzt schaut es so aus:

      File: "test_STE.php"

        
      <?php  
      include("Small_Template_Handler.php");  
      $template = file_get_contents("test.template.html");  
      $data["name"] = "Müller";  
      $data["contact"] = "Telefon";  
      $data["since"] = "1.1.1800";  
      $output = Small_Template_Handler::handle($template, $data);  
      var_dump($output);  
      ?>  
      
      

      File "test.template.html"

        
       <td>{name}</td><td>{contact}</td><td>{since}</td>  
      
      

      File "Small_Template_Handler.php"

        
        
      <?php  
      // expects template as string and data as array  
      // finds used placeholders machting pattern "{placeholder}"  
      // replaces all found placeholders with values, if key exists in data-hash  
      class Small_Template_Handler  
      {  
       private static $template = ""; // template string given as parameter  
       private static $used_placeholders = array(); //list of all found placeholders  
       private static $data = array();//data-hash (associative array where keys match placholders name)  
       private static $output = ""; //replaced template  
        
      // finds used placeholders machting "{placeholder}"  
      // and stores them as array in class-variable $used_placeholders;  
       private function find_used_placeholders ()  
       {  
        $pattern = '/\{(.*?)\}/'; // pattern machting "{placeholder}"  
        $subject = self::$template;  
        preg_match_all($pattern, $subject, $matches);  
        self::$used_placeholders = array_unique($matches[1]);  
       }  
        
        
       // loops class-variable $used_placeholders  
       // and replaces all found placeholders with values, if key exists in data-hash  
       private function replace_placeholders ()  
       {  
        foreach (self::$used_placeholders as $placeholder) //all found placeholders  
        {  
         if (isset(self::$data[$placeholder])) //if key exists in data-hash  replace placeholder by data-hash-value  
         {  
          $search="{".$placeholder."}";  
          $replacement = self::$data[$placeholder];  
          $subject = self::$output;  
          self::$output = str_replace($search, $replacement, $subject);  
         }  
        }  
       }  
        
       // callable function, sets class-vars to given parameters  
       // calls both necessary functions  
       // returns replaced template as string  
       public static function handle ($template, $data)  
       {  
        self::$output = self::$template = $template;  
        self::$data = $data;  
        self::find_used_placeholders();  
        self::replace_placeholders ();  
        return self::$output;  
       }  
      }  
        
      ?>  
        
      
      

      Was hat Dein Beispielcode mit MVC zu tun?

      Nun, eben, das ist ja die Frage. Offenbar ja doch nichts. In o.g. Link aus dem PHP-Forum gibt der Poster eigentlich das wieder, was ich jetzt auch erstmal gedacht hätte. Ob nun MVC oder nicht, ich such(t)e eine sinnvolle (die sinnvollste?) Trennung von HTML (=View) und PHP (=control).

      Warum ist Dein Code nicht kommentiert?

      Nun ist er. Ich hatte gehofft, er kommentiert sich durch die Wahl der Variablennamen und Funktionsnamen selbst (;-).

      Verbesserungsvorschläge, von den wichtigsten zu den unwichtigeren:

      Kommentiere Deinen Code.
      Kommentiere Deinen Code.
      Kommentiere Deinen Code.

      [... lange nichts besonders wichtiges ...]

      geschehen (s.o.).

      Lagere Klassen in eigene Dateien aus.

      geschehen (s.o.).

      Templates und Template-Snippets gehören in eigene Dateien.

      geschehen (s.o.).

      Verwende kein Output-Buffering, wenn Du es nicht brauchst.

      geschehen (s.o.).

      Dank und Gruß,

      frankx

      --
      tryin to multitain  - Globus = Planet != Welt
      1. Hallo Robert,

        Warum ist Dein Code nicht kommentiert?
        Nun ist er. Ich hatte gehofft, er kommentiert sich durch die Wahl der Variablennamen und Funktionsnamen selbst (;-).

        das tut Code nie, auch nicht der irgendwelcher Programmiergenies.
        Gerade wenn man eigenen Code anderen zumutet, sollte man dafür sorgen, dass Code vernünftig kommentiert ist. Da gab's letztlich einen schönen Link zu einem wunderbaren Weblogartikel - leider finde ich den gerade nicht :-(

        <?php
        include("Small_Template_Handler.php");

        // Warum include?
        // Warum nicht require, genauer gesagt require_once?

        $template = file_get_contents("test.template.html");
        $data["name"] = "Müller";
        $data["contact"] = "Telefon";
        $data["since"] = "1.1.1800";
        $output = Small_Template_Handler::handle($template, $data);

        // Was ist nun mit den statischen Eigenschaften Deiner Klasse?
        // Läßt Du den Kram dort einfach unordentlich liegen?

        var_dump($output);
        ?>

        <?php
        // expects template as string and data as array
        // finds used placeholders machting pattern "{placeholder}"
        // replaces all found placeholders with values, if key exists in data-hash
        class Small_Template_Handler
        {
        private static $template = ""; // template string given as parameter
        private static $used_placeholders = array(); //list of all found placeholders
        private static $data = array();//data-hash (associative array where keys match placholders name)
        private static $output = ""; //replaced template

          
        Anders gefragt:  
        Warum willst Du unbedingt darauf verzichten, eine Objektinstanz zu erzeugen?  
        Was bezweckst Du mit der Doppelung $template und $output?  
          
        Versprichst Du Dir eine Optimierung durch Dein Suchen, ob ein bestimmter Platzhalter vorhanden ist? Warum verwendest Du nicht einfach die Array-Variante von [str_replace()](http://www.php.net/manual/de/function.str-replace.php), die Du einfach mit allen Schlüssel-Wert-Paaren fütterst, d.h. dem Array der Schlüssel und dem Array der korrespondierenden Werte?  
          
          
        Freundliche Grüße  
          
        Vinzenz
        
        1. echo $begrüßung;

          Gerade wenn man eigenen Code anderen zumutet, sollte man dafür sorgen, dass Code vernünftig kommentiert ist. Da gab's letztlich einen schönen Link zu einem wunderbaren Weblogartikel - leider finde ich den gerade nicht :-(

          Ich kann mir gut vorstellen, dass du den da gemeint hast: http://shiflett.org/blog/2007/dec/php-advent-calendar-day-2

          echo "$verabschiedung $name";

          1. Hallo dedlfix,

            Gerade wenn man eigenen Code anderen zumutet, sollte man dafür sorgen, dass Code vernünftig kommentiert ist. Da gab's letztlich einen schönen Link zu einem wunderbaren Weblogartikel - leider finde ich den gerade nicht :-(

            Ich kann mir gut vorstellen, dass du den da gemeint hast: http://shiflett.org/blog/2007/dec/php-advent-calendar-day-2

            Danke für den Link, genau den Artikel hatte ich im Hinterkopf. Diesmal hab' ich
            auch nicht vergessen, ein Lesezeichen zu setzen :-)

            Freundliche Grüße

            Vinzenz

        2. Hellihello Vinzenz,

          merci!

          das tut Code nie, auch nicht der irgendwelcher Programmiergenies.
          Gerade wenn man eigenen Code anderen zumutet, sollte man dafür sorgen, dass Code vernünftig kommentiert ist. Da gab's letztlich einen schönen Link zu einem wunderbaren Weblogartikel - leider finde ich den gerade nicht :-(

          Und dort dann auch: http://phpdoc.org/, http://www.stack.nl/~dimitri/doxygen/.

          <?php
          include("Small_Template_Handler.php");

          // Warum include?
          // Warum nicht require, genauer gesagt require_once?

          besser so: ?
          [code lang=php]

          <?php
          // get the required Class
          require_once("Small_Template_Handler.php");

          // set somt Testdata to test with
          $test_data_array["name"] = "Müller";
          $test_data_array["contact"] = "Telefon";
          $test_data_array["since"] = "1.1.1800";

          //choose Template File
          $template_file_name = "test.template.html";
          //create instance
          $my_sth = new Small_Template_Handler($template_file_name, $test_data_array);
          //produce output (echo replaced template)
          $my_sth->putout();
          ?>

            
            
          
          >   
          > > $template = file\_get\_contents("test.template.html");  
          > > $data["name"] = "Müller";  
          > > $data["contact"] = "Telefon";  
          > > $data["since"] = "1.1.1800";  
          > > $output = Small\_Template\_Handler::handle($template, $data);  
          >   
          > // Was ist nun mit den statischen Eigenschaften Deiner Klasse?  
          > // Läßt Du den Kram dort einfach unordentlich liegen?  
            
          Mmh, dem kann ich nicht ganz folgen. Vielleicht ists ja schon unten repariert.  
          
          >   
          > > var\_dump($output);  
          > > ?>  
          >   
          > > <?php  
          > > // expects template as string and data as array  
          > > // finds used placeholders machting pattern "{placeholder}"  
          > > // replaces all found placeholders with values, if key exists in data-hash  
          > > class Small\_Template\_Handler  
          > > {  
          > >  private static $template = ""; // template string given as parameter  
          > >  private static $used\_placeholders = array(); //list of all found placeholders  
          > >  private static $data = array();//data-hash (associative array where keys match placholders name)  
          > >  private static $output = ""; //replaced template  
          >   
          > > [/code]  
          >   
          > Anders gefragt:  
          > Warum willst Du unbedingt darauf verzichten, eine Objektinstanz zu erzeugen?  
          > Was bezweckst Du mit der Doppelung $template und $output?  
            
          Die Doppelung von Template und Output hatte ich vergenommen, weil ich das als zwei unterschiedliche Dinge ansah. Habs jetzt mal abgeschafft. Unbeding verzichten auf eine Objektinstanz wollte ich nicht. Ich sehe den Unterschied irgendwie nie wirklich und frage mich immer wieder, ob es einen Grund für das eine oder andere gibt. Habs jetzt auch mal umgebaut:  
            
          ~~~php
            
          ?php  
          // expects template as string and data as array  
          // finds used placeholders machting pattern "{placeholder}"  
          // replaces all found placeholders with values, if key exists in data-hash  
          class Small_Template_Handler  
          {  
           private $used_placeholders = array(); //list of all found placeholders  
           private $data = array();//data-hash (associative array where keys match placeholders name)  
           private $output = ""; //replaced template  
            
            
           // sets class-vars corresponding to given parameters  
           // and calls both necessary functions  
            function __construct($template_file_path, $data)  
           {  
            //set output to content of template file  
            $this->output = file_get_contents($template_file_path);  
            $this->data = $data;  
            $this->find_used_placeholders();  
              $this->replace_placeholders ();  
           }  
            
           // finds used placeholders machting "{placeholder}"  
           // and stores them as array in class-variable $used_placeholders;  
           private function find_used_placeholders ()  
           {  
            $pattern = '/\{(.*?)\}/'; // pattern matching "{placeholder}"  
            $subject = $this->output; //  
            preg_match_all($pattern, $subject, $matches);  
            // get only one entry per used placeholder and store it in class variable  
            $this->used_placeholders = array_unique($matches[1]);  
           }  
            
           // loops class-variable $used_placeholders  
           // and replaces all found placeholders with values, if key exists in data-hash  
           private function replace_placeholders ()  
           {  
            foreach ($this->used_placeholders as $placeholder) //all found placeholders  
             {  
             if (isset($this->data[$placeholder])) //if key exists in data-hash  - replace {key==placeholder}  
             {  
              $search="{".$placeholder."}";  
              $replacement = $this->data[$placeholder];  
              $subject = $this->output;  
              $this->output = str_replace($search, $replacement, $subject);  
             }  
            }  
           }  
            
           public function putout()  
           {  
            var_dump($this->output);  
           }  
          }  
          ?>  
          
          

          Versprichst Du Dir eine Optimierung durch Dein Suchen, ob ein bestimmter Platzhalter vorhanden ist?

          Naja, ich dachte, es wird dann schnell ersichtlich, ob ein Platzhalter keine Entsprechung im Daten-Hash hat. Zudem enthält der Daten-Hash bzw. die List of Hashes unter Umständen eine Menge mehr Variablen (keys), als im Template benötigt werden.

          Warum verwendest Du nicht einfach die Array-Variante von str_replace(), die Du einfach mit allen Schlüssel-Wert-Paaren fütterst, d.h. dem Array der Schlüssel und dem Array der korrespondierenden Werte?

          Du meinst die o.g. Funktion ersetzen durch

            
            
           private function alternative_replace_placeholders ()  
           {  
            $search = array();  
            $replacement = array();  
            foreach ($this->used_placeholders as $placeholder) //all found placeholders  
             {  
             //if key exists in data-hash  - fill arrays seach and replacement  with "{placeholder}" and value  
             if (isset($this->data[$placeholder]))  
             {  
              $search[]="{".$placeholder."}";  
              $replacement[] = $this->data[$placeholder];  
             }  
             $subject = $this->output;  
             $this->output = str_replace($search, $replacement, $subject);  
            }  
           }  
          
          

          Ich will doch auch überprüfen, ob der Key existiert. Wenn nicht, ist ja was faul im Staate Dänemark. Oder?

          Dank und Gruß,

          Robert aka
          frankx

          --
          tryin to multitain  - Globus = Planet != Welt
  2. <!-- /DBLOCK --><td>{name}</td><td>{contact}</td><td>{since}</td><!-- DBLOCK/ -->

    Ähnliches macht die PEAR-Klasse HTML_Template_IT. Mit "echten" schleifen arbeitet in so einem Fall Smarty, was ich jetzt als Quasistandard sehen würde, da es als ein Projekt unter php.net (http://smarty.php.net) gehostet wird. Allerdings für kleine Anwendungen ziemlich überladen, kann aber abgespeckt werden.

    Ich denke, diese Projekte sollten dir zu deiner Frage recht gute Codebeispiele  liefern.

    1. Hellihello

      <!-- /DBLOCK --><td>{name}</td><td>{contact}</td><td>{since}</td><!-- DBLOCK/ -->

      Ähnliches macht die PEAR-Klasse HTML_Template_IT. Mit "echten" schleifen arbeitet in so einem Fall Smarty, was ich jetzt als Quasistandard sehen würde, da es als ein Projekt unter php.net (http://smarty.php.net) gehostet wird. Allerdings für kleine Anwendungen ziemlich überladen, kann aber abgespeckt werden.

      Ich denke, diese Projekte sollten dir zu deiner Frage recht gute Codebeispiele  liefern.

      Merci.

      Wikipedia (http://de.wikipedia.org/wiki/Smarty) meint dazu u.a.: "Es existieren für PHP zahlreiche Frameworks, die sich stärker an einem MVC-Pattern orientieren und ohne eigene Sprachsyntax auskommen [1]."

      und verweist auf eine Übersicht mit ca. 40 - 50 Einträgen http://www.phpwact.org/php/mvc_frameworks.

      Auch meint Wikipedia: "Das folgende Beispiel demonstriert ein Smarty-Template ohne Steuerungslogik. Die Standardbezeichner für Smarty sind { und }. Es hat sich jedoch in der Praxis als empfehlenswert herausgestellt, andere Bezeichner zu verwenden (siehe erstes PHP-Beispiel), da die geschweiften Klammern mit evtl. eingebettetem JavaScript kollidieren könnten."

      Das ist ja schonmal ein Hinweis, dass man die braces oder curly brackets "{}" vielleicht besser nicht verwenden sollte. Ein der Fragen, die ich u.a. zu haben scheine.

      Dank und Gruß,

      frankx

      --
      tryin to multitain  - Globus = Planet != Welt
  3. echo $begrüßung;

    gibt es einen "gängigen" Weg bezüglich der Verarbeitung von Templates bei der Realisierung von MVC fragte ich mich.

    Es gibt mehrere.

    Nach kurzem Googlen (http://www.phpforum.de/forum/showthread.php?t=205289, http://de.wikipedia.org/wiki/Template_Engine) finde ich aber u.a. bei Wikipedia den Satz: "Aufgrund eines Missverständnisses werden viele Template Engines von Programmierern eingesetzt, um im Kontext von Web-Applikationen Programm-Code (einer Programmiersprache) vom Design zu trennen."

    Das Prinzip PHP-Code von HTML-Code zu trennen ist so schön klar, einfach zu verstehen - und nicht unbedingt das allerbeste. Man landet dann schnell wieder bei Code, der nicht unbedingt dem EVA-Prinzip folgt, sondern Teile der Ausgabelogik mit Teilen der Geschäftslogik vermischt. Die Frage ist, wer die Entscheidungen auflösen soll, was am Ende dargestellt wird. Gibt es Datensätze aus einer Abfrage, oder gibt es keine? Soll bei einer leeren Menge eine entsprechende Meldung angezeigt werden, oder war etwa ein Fehler aufgetreten, über den berichtet werden soll?

    Ist u.g. zielführend, verbesserungsfähig und/oder Geschmacksache?
    [ein Template-Engine-Code]

    Das ist noch recht einfach von seinen Möglichkeiten. Du wirst schnell herausfinden, dass dir das nicht reichen wird.

    Das ganze müsste ja im zweiten Schritt noch irgendwie rekursiv aufgerufen werden können mit einem Template a la:
    <!-- /DBLOCK --><td>{name}</td><td>{contact}</td><td>{since}</td><!-- DBLOCK/ -->

    Da fängt es schon an, du rufst nach mehr Funktionalität. Bleibt trotzdem die Frage, wo du die Anzeigelogik unterbringen möchtest. Möchtest du eine eigene Syntax erstellen, die Steuerelemente (Bedingungen, Schleifen, Blöcke) enthält? Lohnt sich der Aufwand, einer solchen zusätzlichen Syntax? Bedenke, du hast bereits PHP, HTML, CSS und vielleicht Javascript. Bedenke weiterhin, dass PHP bereits selbst eine Template-Engine (TE) darstellt. Eine weitere TE einzusetzen und/oder zu entwerfen verbraucht Ressourcen bei der Ausführung und für deren Entwicklung. Letzteres kann man auf Lernaufwand für eine neue Syntax abkürzen, denn TEs jeder Geschmacksrichtung gibt es ausreichend.

    Vielleicht ist dein Wunsch nach einer TE entstanden, weil du zu viel unübersichtlichen Code gesehen oder gar selbst produziert hast. Dabei kann man auch mit reinen PHP-Mitteln recht übersichtlich bleiben. Es gibt die Alternative syntax for control structures, die durch endxxx; mehr Zusammengehörigkeit zum jeweils öffnenden xxx zeigen kann, als das mit } der Fall ist. Und man kann sich Mühe geben bei der Formatierung des (mit PHP-Code gespickten) HTML-Templates.

    Gerade für überschaubare 1-Mann-Projekte finde ich das nicht die schlechteste Herangehensweise. Wenn das Projekt eine Aufgabenteilung zwischen Designer ohne großartige Programmierkenntnisse und dem Anwendungslogik-Programmierer vorsieht, ist es vielleicht angebrachter, ein System zu verwenden, das auch der Designer versteht, um nicht seine Vorlagen noch selbst mit der Ausgabelogik versehen zu müssen. Das bindet eigene Ressourcen und schränkt die Änderbarkeit durch den Designer ein.

    um Übersichten für Lists of Hashes herzustellen. Der Framesworks hierzu scheint es ja einige zu geben, eine Art "Standard" (a la CSV für ein Tabellenformat) aber scheints nicht, oder?

    Zu vielfältig sind die Anforderungen, als dass man sie mit einem System oder einem Lösungsprinzip erschlagen könnte.

    Das von dir Eingangs erwähnte MVC-Muster trennt auch nicht strikt Programmcode von HTML-Code, sondern überlässt es dem V(iew)-Teil, die vom M(odel) abgefragten Daten darzustellen. So erreicht man, dass sowohl M als auch V austauschbar sind, ohne dabei den jeweils anderen Teil anpassen zu müssen. Dass die View sich ihrerseits weiterer Programmiermuster (wie Templates) bedienen kann, wird durch die Verwendung von MVC nicht ausgeschlossen.

    echo "$verabschiedung $name";

    1. Hellihello dedlfix,

      Es gibt mehrere.

      Fein (;-).

      Nach kurzem Googlen (http://www.phpforum.de/forum/showthread.php?t=205289, http://de.wikipedia.org/wiki/Template_Engine) finde ich aber u.a. bei Wikipedia den Satz: "Aufgrund eines Missverständnisses werden viele Template Engines von Programmierern eingesetzt, um im Kontext von Web-Applikationen Programm-Code (einer Programmiersprache) vom Design zu trennen."

      Das Prinzip PHP-Code von HTML-Code zu trennen ist so schön klar, einfach zu verstehen - und nicht unbedingt das allerbeste.

      Gnurf.

      Man landet dann schnell wieder bei Code, der nicht unbedingt dem EVA-Prinzip folgt, sondern Teile der Ausgabelogik mit Teilen der Geschäftslogik vermischt. Die Frage ist, wer die Entscheidungen auflösen soll, was am Ende dargestellt wird.

      Naja, die Überlegung ist ja, eine dieser drei Varianten

      <?php echo Document::$title?>

      oder Domfunktionen wie

      $simple_xml->$title="mein Titel";

      oder gar

        
      foreach ($data as $datum)  
      {  
         echo "<td>$datum</td>\n";  
       }  
      
      

      zu ersetzen eben durch die Ersetzung in einem Template. Dadurch ensteht _eine_ zusätzliche Form der Variablencodierung (quasi ein Alias für eine Variable). Die Logik aber bleibt doch, wo sie vorher war, denn auch bei <?php echo Document::$title?> muss ja vorher der Wert gesetzt sein. Ob ich das durch eine PHP-Funktion "echo" mache, oder von PHP ersetzen lasse, ändert ja im Grunde die Sache eher marginal.

      Gibt es Datensätze aus einer Abfrage, oder gibt es keine?

      Ja, die gibt es, eine oder mehrer Zeilen einer Tabelle.

      Soll bei einer leeren Menge eine entsprechende Meldung angezeigt werden, oder war etwa ein Fehler aufgetreten, über den berichtet werden soll?

      Da hätte ich jetzt gedacht, dass die Fehlerkontrolle a) sein muss und b) komplett unabhängig von der "Template-'engine'" wäre.

      Ist u.g. zielführend, verbesserungsfähig und/oder Geschmacksache?
      [ein Template-Engine-Code]

      Das ist noch recht einfach von seinen Möglichkeiten. Du wirst schnell herausfinden, dass dir das nicht reichen wird.

      Nun, die Darstellung mehrer Einträge durch einen dynamischen Block. Das wars dann aber auch.

      Das ganze müsste ja im zweiten Schritt noch irgendwie rekursiv aufgerufen werden können mit einem Template a la:
      <!-- /DBLOCK --><td>{name}</td><td>{contact}</td><td>{since}</td><!-- DBLOCK/ -->

      Da fängt es schon an, du rufst nach mehr Funktionalität. Bleibt trotzdem die Frage, wo du die Anzeigelogik unterbringen möchtest. Möchtest du eine eigene Syntax erstellen, die Steuerelemente (Bedingungen, Schleifen, Blöcke) enthält?

      Nein, nur die o.g. Markierung. Es braucht also vier Definitionen: öffnender und schließender Begrenzer für die Spalten/Variablennamen und selbiges für einen dynamischen Block.

      Lohnt sich der Aufwand, einer solchen zusätzlichen Syntax? Bedenke, du hast bereits PHP, HTML, CSS und vielleicht Javascript. Bedenke weiterhin, dass PHP bereits selbst eine Template-Engine (TE) darstellt. Eine weitere TE einzusetzen und/oder zu entwerfen verbraucht Ressourcen bei der Ausführung und für deren Entwicklung. Letzteres kann man auf Lernaufwand für eine neue Syntax abkürzen, denn TEs jeder Geschmacksrichtung gibt es ausreichend.

      Ja, und dann wieder die Crux, tu ich mir das an, die alle anzuschauen und durchzutesten oder mach ich o.g. "einfach" selber. Zumal historisch bedingt Vorlagen nach dem o.g. Format schon existieren. Meine Idee war eher, das zu optimieren und evtl. sowas wie ein grundsätzliches Fazit zu ziehen.

      Vielleicht ist dein Wunsch nach einer TE entstanden, weil du zu viel unübersichtlichen Code gesehen oder gar selbst produziert hast.

      Als er entsteht glaube ich, weil mir die Beimischung (s.o.) von HTML-Text im PHP-Code nicht gefällt. Da habe ich es mit Dom-Funktionen versucht. Das ist dann wenigstens eine saubere Sache und hat im Grunde auch noch den Vorteil, dass der PHP-Code einem (unobstrusive) JS-Code recht ähnlich ist. Aber irgendwie bläht sich das ganze dann doch ziemlich auf.

      Dabei kann man auch mit reinen PHP-Mitteln recht übersichtlich bleiben. Es gibt die Alternative syntax for control structures, die durch endxxx; mehr Zusammengehörigkeit zum jeweils öffnenden xxx zeigen kann, als das mit } der Fall ist. Und man kann sich Mühe geben bei der Formatierung des (mit PHP-Code gespickten) HTML-Templates.

      Ich hatte auch schon

        
      <?php  
      foreach ($data as $datum)  
      {  
      ?>  
       <td><?php echo $datum;?></td>  
      <?php  
       }  
      ?>  
      
      

      Gerade für überschaubare 1-Mann-Projekte finde ich das nicht die schlechteste Herangehensweise. Wenn das Projekt eine Aufgabenteilung zwischen Designer ohne großartige Programmierkenntnisse und dem Anwendungslogik-Programmierer vorsieht, ist es vielleicht angebrachter, ein System zu verwenden, das auch der Designer versteht, um nicht seine Vorlagen noch selbst mit der Ausgabelogik versehen zu müssen. Das bindet eigene Ressourcen und schränkt die Änderbarkeit durch den Designer ein.

      um Übersichten für Lists of Hashes herzustellen. Der Framesworks hierzu scheint es ja einige zu geben, eine Art "Standard" (a la CSV für ein Tabellenformat) aber scheints nicht, oder?

      Zu vielfältig sind die Anforderungen, als dass man sie mit einem System oder einem Lösungsprinzip erschlagen könnte.

      Naja, ich hatte gedacht, dass man sich vielleicht auf Begrenzer für Templates "geeinigt" hätte wie beim CSV auf das Komma, die doppelten Hochkommas und den einfachen Absatz. Aber so richtig durchgesetzt hat sich da ja auch nischt. Möglich ja auch was wie <span class="placeholder">name</span>.

      Das von dir Eingangs erwähnte MVC-Muster trennt auch nicht strikt Programmcode von HTML-Code, sondern überlässt es dem V(iew)-Teil, die vom M(odel) abgefragten Daten darzustellen. So erreicht man, dass sowohl M als auch V austauschbar sind, ohne dabei den jeweils anderen Teil anpassen zu müssen. Dass die View sich ihrerseits weiterer Programmiermuster (wie Templates) bedienen kann, wird durch die Verwendung von MVC nicht ausgeschlossen.

      Ja, das leuchtet ein. Dieses Templatehandling ist Sache der View und berührt deshalb das übergeordnete Model nicht.

      Dank und Gruß,

      frankx

      --
      tryin to multitain  - Globus = Planet != Welt
      1. echo $begrüßung;

        Naja, die Überlegung ist ja, eine dieser drei Varianten [...]
        zu ersetzen eben durch die Ersetzung in einem Template. Dadurch ensteht _eine_ zusätzliche Form der Variablencodierung (quasi ein Alias für eine Variable). Die Logik aber bleibt doch, wo sie vorher war, denn auch bei <?php echo Document::$title?> muss ja vorher der Wert gesetzt sein. Ob ich das durch eine PHP-Funktion "echo" mache, oder von PHP ersetzen lasse, ändert ja im Grunde die Sache eher marginal.

        Es gibt zwei Logik-Bereiche (die uns an der Stelle interessieren). Der eine beschäftigt sich mit der Besorgung oder Berechnung von Daten, der andere mit der Logik, die zur Ausgabe benötigt wird. Die Ausgabe der in Teil 1, der Geschäftslogik, bereitgestellten Datensätze in einer Schleife ist Ausgabelogik, ebenso die Entscheidung, ob Fehlermeldung, Trösttext oder gar nichts angezeigt werden soll, wenn keine Daten vorliegen.

        Gibt es Datensätze aus einer Abfrage, oder gibt es keine?
        Soll bei einer leeren Menge eine entsprechende Meldung angezeigt werden, oder war etwa ein Fehler aufgetreten, über den berichtet werden soll?

        Das waren Fragen, wie sie von der Ausgabelogik zu klären sind. Du solltest sie nicht beantworten. :-)

        Da hätte ich jetzt gedacht, dass die Fehlerkontrolle a) sein muss und b) komplett unabhängig von der "Template-'engine'" wäre.

        Das Abfangen der Fehler, die in der Geschäftslogik auftreten, ist deren Aufgabe. Doch gelegentlich entsteht der Wunsch, aufgetretene Fehler auch der Ausgabelogik zu übergeben, damit diese angezeigt werden können. Und dann hast du eine Entscheidung zu treffen, die mindestens "Anzeigen des Fehlermeldungsblocks oder nicht" lautet. Das ist keine Geschäftslogik mehr. In dem eine Ausgabemedium muss es benutzerfreundlich dargestellt werden, für bspw. eine WebService-Schnittstelle muss es automatisiert lesbar gestaltet werden.

        Es braucht also vier Definitionen: öffnender und schließender Begrenzer für die Spalten/Variablennamen und selbiges für einen dynamischen Block.

        Da brauchst du das Fahrrad nicht nochmal zu erfinden. Es gibt da aus PEAR die schon erwähnte HTML_Template_IT und eine erweiterte Variante HTML_Template_Sigma.

        Mit denen hatte ich auch mal angefangen, bevor ich mich vom Gedanken, PHP und HTML ungeachtet der logischen Verarbeitungsschritte strikt trennen zu wollen, verabschiedet hatte.

        Naja, ich hatte gedacht, dass man sich vielleicht auf Begrenzer für Templates "geeinigt" hätte wie beim CSV auf das Komma, die doppelten Hochkommas und den einfachen Absatz. Aber so richtig durchgesetzt hat sich da ja auch nischt. Möglich ja auch was wie <span class="placeholder">name</span>.

        Es gliedert sich wohl grob gesehen in zwei Gruppen. Die eine macht es XML/SGML/HTML-ähnlich, mit dem Vorteil eventuelle Editoren und deren Syntax-Unterstützung nutzen zu können, die andere kocht ein eigenes Süppchen.

        echo "$verabschiedung $name";

        1. Hellihello dedlfix,

          Es gibt zwei Logik-Bereiche (die uns an der Stelle interessieren). Der eine beschäftigt sich mit der Besorgung oder Berechnung von Daten,

          Das wäre das Model.

          der andere mit der Logik, die zur Ausgabe benötigt wird. Die Ausgabe der in Teil 1, der Geschäftslogik, bereitgestellten Datensätze in einer Schleife ist Ausgabelogik, ebenso die Entscheidung, ob Fehlermeldung, Trösttext oder gar nichts angezeigt werden soll, wenn keine Daten vorliegen.

          Die View.

          Gibt es Datensätze aus einer Abfrage, oder gibt es keine?
          Soll bei einer leeren Menge eine entsprechende Meldung angezeigt werden, oder war etwa ein Fehler aufgetreten, über den berichtet werden soll?

          Das waren Fragen, wie sie von der Ausgabelogik zu klären sind. Du solltest sie nicht beantworten. :-)

          Naja, wenn meine Ausgabe(logik) so schlau wäre, das von allein zu entscheiden (;-).

          Es braucht also vier Definitionen: öffnender und schließender Begrenzer für die Spalten/Variablennamen und selbiges für einen dynamischen Block.

          Da brauchst du das Fahrrad nicht nochmal zu erfinden. Es gibt da aus PEAR die schon erwähnte HTML_Template_IT und eine erweiterte Variante HTML_Template_Sigma.

          Merci. HTML_Template_IT macht es ja genau so, nur dass sie dem dynamischen Block noch einen individuellen Namen verpassen.

            
          <!-- BEGIN cell -->  
             <td>  
              {DATA}  
             </td>  
          <!-- END cell -->  
          
          

          Mit denen hatte ich auch mal angefangen, bevor ich mich vom Gedanken, PHP und HTML ungeachtet der logischen Verarbeitungsschritte strikt trennen zu wollen, verabschiedet hatte.

          Das würde mich jetzt interessieren, was das genau bedeutet, weil es ja sein könnte, dass ich dann den selben Prozess auch durchmache.
          Ich möchte beispielsweise - in einer aktuellen Test-/Entwicklungsphase -, dass die aufgerufene Methode einer Klasse nicht nur ein Ergebnis mit Datensätzen zurückgibt, sondern noch den Klassennamen, Methodennamen und einen individuellen Kommentar. Ich lasse sie diese vier Infos an eine Methode einer Unter-Klasse der View übergeben, mit eben den vier genannten Parametern $Messageboard::function_feedback(get_class(),__FUNCTION__,$bezeichner,$data).

          Jetzt will ich, dass der Klassenname als "h2" "getagged" wird, vielleicht noch einen Präfix bekommt wie "Klasse: ", analog dann Methode und den kurzen Satz, dannach Tabellisiert das Datenarray.

          Wie würdest Du das machen? Mit echo "<h1>Klasse: $class_name</h1>\n";? Oder per include <h1>Klasse: [code lang=php]<?php echo $class_name;?></h1>[/code]? Oder die Daten in xml umwandeln und dann per XSL transformieren? Ich denke, Du hast Dich scheinbar mit Dir selbst auf eine gängige Lösung geeinigt und nutzt die dann auch konsequent in allen Bereichen, wo das nötig ist.

          Bei mir schaut das momentan so aus:

            
          class Messageboard  
          {  
           public static $Ausgabe="";  
            
           public static function function_feedback ($class_name, $function_name, $message="no message",$to_Tabelize="no table")  
           {  
            self::$Ausgabe .= '<hr><div class="kontrollmeldung">';  
            self::$Ausgabe .= "<h2>Kontrollmeldung: $class_name :: $function_name</h2>";  
            self::$Ausgabe .= "<h3>Nachricht: $message</h3>";  
            
            if (count($to_Tabelize))  
            {  
             self::$Ausgabe .=  "<h3>Tabelle:</h3>";  
             self::$Ausgabe .= Tabelizer::simple_array($to_Tabelize);  
            }  
            else  
            {  
             self::$Ausgabe .="<p>keine Tabelle übergeben</p>";  
            }  
            self::$Ausgabe .= '<hr></div>';  
           }  
            
           public static function Systemfehler ($class_name, $function_name, $message)  
           {  
            self::$Ausgabe .=  "<h2>Fehlermeldung von: $class_name :: $function_name </h2>";  
            self::$Ausgabe .=  "<p>$message</p>";  
           }  
          }//class Messageboard  
            
          
          

          Aus meiner Sicht ist bei obigem Zustand die Frage nach der Ausgabelogik jetzt "Finetuning", vermutlich sind da aber andere Aspekte noch recht "roh". Es ist ja funktional, Frage halt, ob das vom Handling her bzw. der Übersicht her noch optimierungsfähig ist (zB durch Templates).

          Naja, ich hatte gedacht, dass man sich vielleicht auf Begrenzer für Templates "geeinigt" hätte wie beim CSV auf das Komma, die doppelten Hochkommas und den einfachen Absatz. Aber so richtig durchgesetzt hat sich da ja auch nischt. Möglich ja auch was wie <span class="placeholder">name</span>.

          Es gliedert sich wohl grob gesehen in zwei Gruppen. Die eine macht es XML/SGML/HTML-ähnlich, mit dem Vorteil eventuelle Editoren und deren Syntax-Unterstützung nutzen zu können, die andere kocht ein eigenes Süppchen.

          Mit eigenem Süppchen meinst Du zB die HTML_Template_IT mit den curly braces? Wo aber findet sich HTML-ähnliches (zB. bei PEAR oder ZEND?)? Oder sind dass dann Template-Engines für andere Sprachen?

          Dank und Gruß,

          frankx

          --
          tryin to multitain  - Globus = Planet != Welt
          1. echo $begrüßung;

            Mit denen [HTML_Template_IT, HTML_Template_Sigma] hatte ich auch mal angefangen, bevor ich mich vom Gedanken, PHP und HTML ungeachtet der logischen Verarbeitungsschritte strikt trennen zu wollen, verabschiedet hatte.
            Das würde mich jetzt interessieren, was das genau bedeutet, weil es ja sein könnte, dass ich dann den selben Prozess auch durchmache.

            Du bist noch nicht beim MVC angekommen. Die View kümmert sich um sämtliche Ausgabelogik-Dinge. Du betrachtest, so scheint es mir, nur ein Template. Die Entscheidungen, was ausgegeben werden muss, und die Wiederholungen bei Massendaten, willst du möglicherweise dem Controller-Teil aufhalsen.

            Hier mal ein Beispiel für ein kleines Projekt. MVC ist dabei übertrieben und kommt auch eher aus der Desktop-Programm-Welt. So ein Webseiten-Request läuft doch mehr gradlinig durch, eher nach dem guten, alten EVA-Prinzip. Bei der Verarbeitung seien die beiden Arrays $errors und $data entstanden. Beide können leer oder gefüllt sein. Bei $errors ist der Fall klar. Wenn $errors leer ist und $data ebenfalls, ergab die Abfrage einfach nur eine leere Menge. Der folgende Teil wird vom Controller-Teil des Scripts inkludiert, nachdem die Daten ermittelt wurden. Da das Projekt überschaubar klein ist, sind die Variablen einfach global angelegt.

            <html>  
            <head><title>Beispiel</title></head>  
            <body>  
              <div>Navigation usw.</div>  
              
            <?php if ($errors): ?>  
              
              <div>Es sind Fehler aufgetreten:  
                <ul class="errors">  
                  <?php foreach ($errors as $error): ?>  
                    <li><?php echo htmlspecialchars($error) ?></li>  
                  <?php endforeach; ?>  
                </ul>  
              </div>  
              
            <?php else: ?>  
              
              <?php if ($data): ?>  
              
                <table>  
                  <tr>  
                    <th>Überschrift</th>  
                    <th>Überschrift</th>  
                  </tr>  
                  <?php foreach ($data as $record): ?>  
                    <tr>  
                      <td><?php echo htmlspecialchars($record[0]) ?></td>  
                      <td><?php echo htmlspecialchars($record[1]) ?></td>  
                    </tr>  
                  <?php endforeach; ?>  
                </table>  
              
              <?php else: ?>  
              
                <div>Die Anfrage brachte kein Ergebnis.</div>  
              
              <?php endif; ?>  
              
            <?php endif; ?>  
            </body>  
            </html>
            

            Ich möchte beispielsweise - in einer aktuellen Test-/Entwicklungsphase -, dass die aufgerufene Methode einer Klasse nicht nur ein Ergebnis mit Datensätzen zurückgibt, sondern noch den Klassennamen, Methodennamen und einen individuellen Kommentar.

            Das würde ich nicht wollen. Das bedeutet, dass der Ausgabeteil noch deutlich mehr vom Rest wissen muss als nur die auszugebenden Daten und ihre Struktur. Namen von Bezeichnern des Programms sind für mich allenfalls für das Debugging interessant.

            Jetzt will ich, dass der Klassenname als "h2" "getagged" wird, vielleicht noch einen Präfix bekommt wie "Klasse: ", analog dann Methode und den kurzen Satz, dannach Tabellisiert das Datenarray. Wie würdest Du das machen?

            Auf die einfachste Art, die dem Projektumfang angemessen ist. Je komplexer eine Lösung ist, desto fehleranfälliger wird sie.

            Mit echo "<h1>Klasse: $class_name</h1>\n";? Oder per include <h1>Klasse: <?php echo $class_name;?></h1>?

            Die erste Variante ist einfach nur ein String. Die zweite kann vom Editor oder der IDE als HTML-Code angesehen und auch so formatiert und schnelltippunterstützt werden.

            Oder die Daten in xml umwandeln und dann per XSL transformieren?

            Das käme dann infrage, wenn irgendjemand anderes für die Darstellung verantwortlich wäre, und der Umweg über XML sinnvoll ist.

            Es gliedert sich wohl grob gesehen in zwei Gruppen. Die eine macht es XML/SGML/HTML-ähnlich, mit dem Vorteil eventuelle Editoren und deren Syntax-Unterstützung nutzen zu können, die andere kocht ein eigenes Süppchen.
            Mit eigenem Süppchen meinst Du zB die HTML_Template_IT mit den curly braces? Wo aber findet sich HTML-ähnliches (zB. bei PEAR oder ZEND?)? Oder sind dass dann Template-Engines für andere Sprachen?

            Alles was nicht nach HTML/XML aussieht, zähle ich mal in die Eigenes-Süppchen-Gruppe. Zeichen, die in HTML/XML keine Bedeutung haben, wie {} und [] oder $ oder # als Unklammerung oder Einleiter von besonders zu bearbeitenden Dingen. Zu den HTML/XML-ähnlichen, die eigene Elemente verwenden oder Attribute in die Elemente einfügen, zählt beispielsweise PHPTAL.

            echo "$verabschiedung $name";

            1. Hellihello dedlfixy,

              echo $begrüßung;

              Mit denen [HTML_Template_IT, HTML_Template_Sigma] hatte ich auch mal angefangen, bevor ich mich vom Gedanken, PHP und HTML ungeachtet der logischen Verarbeitungsschritte strikt trennen zu wollen, verabschiedet hatte.
              Das würde mich jetzt interessieren, was das genau bedeutet, weil es ja sein könnte, dass ich dann den selben Prozess auch durchmache.

              Du bist noch nicht beim MVC angekommen. Die View kümmert sich um sämtliche Ausgabelogik-Dinge. Du betrachtest, so scheint es mir, nur ein Template. Die Entscheidungen, was ausgegeben werden muss, und die Wiederholungen bei Massendaten, willst du möglicherweise dem Controller-Teil aufhalsen.

              Neinnein, der sollte eigentlich den Request bearbeiten bzw. bestenfalls direkt ans Model weiterleiten, welches dann wiederum sein Ausgabe(n) (Arrays) der View ins Stammbuch schreibt.

              <html>

              <head><title>Beispiel</title></head>
              <body>
                <div>Navigation usw.</div>

              <?php if ($errors): ?>

              <div>Es sind Fehler aufgetreten:
                  <ul class="errors">
                    <?php foreach ($errors as $error): ?>
                      <li><?php echo htmlspecialchars($error) ?></li>
                    <?php endforeach; ?>
                  </ul>
                </div>

              <?php else: ?>

              <?php if ($data): ?>

              <table>
                    <tr>
                      <th>Überschrift</th>
                      <th>Überschrift</th>
                    </tr>
                    <?php foreach ($data as $record): ?>
                      <tr>
                        <td><?php echo htmlspecialchars($record[0]) ?></td>
                        <td><?php echo htmlspecialchars($record[1]) ?></td>
                      </tr>
                    <?php endforeach; ?>
                  </table>

              <?php else: ?>

              <div>Die Anfrage brachte kein Ergebnis.</div>

              <?php endif; ?>

              <?php endif; ?>
              </body>
              </html>

                
              Jup, das ist das, was mir irgendwie noch fehlte, auch wenn Du schon darauf verlinkt hattest. Nicht HTML-Code von PHP echoen lassen, sondern PHP im HTML wohlgeformt eingeben. diese "end(foreach|if)" sehen auch deutlich besser aus als einsame "}" zum beenden einer Schleife/Bedingung.  
                
              
              > > Ich möchte beispielsweise - in einer aktuellen Test-/Entwicklungsphase -, dass die aufgerufene Methode einer Klasse nicht nur ein Ergebnis mit Datensätzen zurückgibt, sondern noch den Klassennamen, Methodennamen und einen individuellen Kommentar.  
              >   
              > Das würde ich nicht wollen. Das bedeutet, dass der Ausgabeteil noch deutlich mehr vom Rest wissen muss als nur die auszugebenden Daten und ihre Struktur. Namen von Bezeichnern des Programms sind für mich allenfalls für das Debugging interessant.  
                
              Ja, ich würde das in dem Fall präventives Debugging nennen. Das kommt dann später wech.  
                
              
              > > > Es gliedert sich wohl grob gesehen in zwei Gruppen. Die eine macht es XML/SGML/HTML-ähnlich, mit dem Vorteil eventuelle Editoren und deren Syntax-Unterstützung nutzen zu können, die andere kocht ein eigenes Süppchen.  
              > > Mit eigenem Süppchen meinst Du zB die HTML\_Template\_IT mit den curly braces? Wo aber findet sich HTML-ähnliches (zB. bei PEAR oder ZEND?)? Oder sind dass dann Template-Engines für andere Sprachen?  
              >   
              > Alles was nicht nach HTML/XML aussieht, zähle ich mal in die Eigenes-Süppchen-Gruppe. Zeichen, die in HTML/XML keine Bedeutung haben, wie {} und [] oder $ oder # als Unklammerung oder Einleiter von besonders zu bearbeitenden Dingen. Zu den HTML/XML-ähnlichen, die eigene Elemente verwenden oder Attribute in die Elemente einfügen, zählt beispielsweise [PHPTAL](http://phptal.motion-twin.com/).  
                
              Merci. Das ist ja (s. deren eigene Intro) sozusagen die Alternative zu o.g. Beipiel. Ich glaub mal spontan, o.g. reicht erstmal für meine Zwecke (;-), bzw. mein Bedürfnis nach einer Art Stringenz/Ordnung im Code.  
                
                
              Dank und Gruß,  
                
              [frankx](http://community.de.selfhtml.org/visitenkarten/view.php?key=82)
              
              -- 
              [tryin to](http://sauer-ernst.de) [multitain](http://multitain.de)  - Globus = Planet != Welt 
              
              1. Du bist noch nicht beim MVC angekommen. Die View kümmert sich um sämtliche Ausgabelogik-Dinge. Du betrachtest, so scheint es mir, nur ein Template. Die Entscheidungen, was ausgegeben werden muss, und die Wiederholungen bei Massendaten, willst du möglicherweise dem Controller-Teil aufhalsen.

                Neinnein, der sollte eigentlich den Request bearbeiten bzw. bestenfalls direkt ans Model weiterleiten, welches dann wiederum sein Ausgabe(n) (Arrays) der View ins Stammbuch schreibt.

                Das Modul schreibt in den View?

                Würde ich nicht so machen. Das Model hält nur die Daten. Die Bearbeitung macht auf jeden Fall der Controller, d.h. wenn du ein Array bzw. von Daten (Model) hast, werden diese vom Controller aufgearbeitet und entsprechend dem View übergeben. Das Model weiß nichts von einem View oder Controller. Im gegensatz dazu weiss das View, wie es an die Daten des Models kommt.

                Dadurch das es in PHP möglich Code und HTML zu mischen, kannst du dir leicht ein View basteln mit dem es möglich ist auch komplexere Kontrukte zu erzeugen, z.b. Schleifen, Bedingungen oder auch das nachladen von Code, d.h. du musst nicht Code und HTML trennen und hast die Möglichkeit dein View sehr flexibel zu gestalten.

                In anderen Sprachen ist dies aufwendiger, da du die gleiche Funktionalität, entweder mit mehreren Dateien erreichen musst (eine für den Code und eine für HTML) oder ein Templatesystem benutzt, mit dem du die Logik ebenfalls umsetzen kannst. Dashat aber den Nachteil, dass derjenige, der die Templates bearbeitet, eine weitere Beschreibungssprache lernen muss. Der Vorteil liegt darin, dass im Template nicht in das System eingegriffen werden kann. Was wichtiger für dich ist magst du entscheiden.

                Wenn ich in PHP programmieren würde, wär mein Ansatz eher der erster. So wie es z.b. auch Wordpress macht, wo du in den Themesordnern mit php Dateien sehr flexibel arbeiten kannst. Aber ich kenn mich mit PHP nicht so gut aus, daher weiß ich nicht ob das das optimale ist.

                Struppi.

            2. Hellihello

              Hier mal ein Beispiel für ein kleines Projekt. MVC ist dabei übertrieben und kommt auch eher aus der Desktop-Programm-Welt. So ein Webseiten-Request läuft doch mehr gradlinig durch, eher nach dem guten, alten EVA-Prinzip. Bei der Verarbeitung seien die beiden Arrays $errors und $data entstanden. Beide können leer oder gefüllt sein. Bei $errors ist der Fall klar. Wenn $errors leer ist und $data ebenfalls, ergab die Abfrage einfach nur eine leere Menge. Der folgende Teil wird vom Controller-Teil des Scripts inkludiert, nachdem die Daten ermittelt wurden. Da das Projekt überschaubar klein ist, sind die Variablen einfach global angelegt.

              <html>

              <head><title>Beispiel</title></head>
              <body>
                <div>Navigation usw.</div>

              <?php if ($errors): ?>

              <div>Es sind Fehler aufgetreten:
                  <ul class="errors">
                    <?php foreach ($errors as $error): ?>
                      <li><?php echo htmlspecialchars($error) ?></li>
                    <?php endforeach; ?>
                  </ul>
                </div>

              <?php else: ?>

              <?php if ($data): ?>

              <table>
                    <tr>
                      <th>Überschrift</th>
                      <th>Überschrift</th>
                    </tr>
                    <?php foreach ($data as $record): ?>
                      <tr>
                        <td><?php echo htmlspecialchars($record[0]) ?></td>
                        <td><?php echo htmlspecialchars($record[1]) ?></td>
                      </tr>
                    <?php endforeach; ?>
                  </table>

              <?php else: ?>

              <div>Die Anfrage brachte kein Ergebnis.</div>

              <?php endif; ?>

              <?php endif; ?>
              </body>
              </html>

              
              >   
                
              Macht es ggf. Sinn, die Einzelteile (wie zB. Menü, Fehlermeldungen, eine Sammlung von Contentinhalten) erst seperat zu erstellen? Also eine Funktion, die zB erstmal die Tabelle generiert:  
                
              ~~~php
                
              <?php  
              function Tabelize($data) {  
              ob_start();  
              ?>  
               <table>  
              <?php foreach ($data as $record): ?>  
                       <tr>  
                         <td><?php echo htmlspecialchars($record[0]) ?></td>  
                         <td><?php echo htmlspecialchars($record[1]) ?></td>  
                       </tr>  
              <?php endforeach; ?>  
               </table>  
              <?php  
               $html_table=ob_get_clean();  
               return $html_table; //oder auch HTML::content_add($html_table) bzw $html->content_add($html_table)  
              }  
              ?>  
              
              

              Damit dann die Einzelteile später im letzen Schritt nur noch ausgechot werden könnten. Das aber wiederum lässt sich ja wohl nur über outputbuffering lösen, oder?

              Um es dann im letzten Schritt als Variable einbauen zu können:

                
              ...  
                
              </head>  
              <body>  
               <div class="menu">  
                <?php echo $menu;?>  
               </div>  
               <div class="content">  
                <?php echo $table1;?>  
                <?php echo $table2;?>  
               </div>  
              </body>  
                
              
              

              Oder ist das Käse?

              Dank und Gruß,

              frankx

              --
              tryin to multitain  - Globus = Planet != Welt
              1. echo $begrüßung;

                Macht es ggf. Sinn, die Einzelteile (wie zB. Menü, Fehlermeldungen, eine Sammlung von Contentinhalten) erst seperat zu erstellen? Also eine Funktion, die zB erstmal die Tabelle generiert:

                Schau dir mal das Zend Framework an. Das ist ganz nach dem MVC-Muster aufgebaut. Dort wird der Begriff ViewHelper für solche Funktionalität verwendet. Beispielsweise macht man sich ja tot, wenn man ein Input-Element mit nicht feststehenden Attributen erzeugen will. Man übergibt dem ViewHelper für Input-Elemente ein paar Daten und der liefert das fertige HTML zurück. Das gleiche für Select-Elemente mit ihren Optionen usw. usf. Das Prinzip kann man natürlich auch auf tabellarische Daten ausdehnen. Innerhalb des ViewHelpers hat man ja meist mehr mit den Daten zu tun und HTML ist eher in kleinen Einsprengseln vertreten.

                Damit dann die Einzelteile später im letzen Schritt nur noch ausgechot werden könnten. Das aber wiederum lässt sich ja wohl nur über outputbuffering lösen, oder?

                Output-Buffering würde ich an der Stelle nicht nehmen, eher normales String-Zusammenbauen mit allen jeweils angemessen erscheinenden Methoden, die PHP so bietet: String-Verkettung mit dem .-Operator, Parsen von $variablen in ""-Strings, sprintf() & Co, __toString()-Magie von Objekten.

                echo "$verabschiedung $name";