Ankündigung

Einklappen
Keine Ankündigung bisher.

Template + while-Schleife

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Template + while-Schleife

    Hallo,

    derzeit versuche ich mich, in Sachen Templates.

    Ich habe folgende Klasse:
    // Template-Klasse.php
    PHP-Code:
    class parser
     
    {
         var 
    $search    =   array();
         var 
    $replace   =   array();
         var 
    $content   =   "";

         
    // die Template-Datei laden
         
    function loadTemplatefile($file)
         {
             
    $this->content file_get_contents($file);
         }

         
    // die Zeilendaten, den Template-Platzhaltern zuweisen
         
    function setVariables($search$replace)
         {
             
    $this->search[$search] = $search;
             
    $this->replace[$search] = $replace;
         }

         
    // die Webseite ausgeben
         
    function show()
         {
             print 
    str_replace($this->search$this->replace$this->content);
         }
     } 
    Diese Klasse sucht nach Platzhaltern und ersetzt diese.
    Bei einem einzelnen Datensatz funzt dies auch, aber wenn ich eine Ergebnistabelle erzeugen möchte, funzt es nicht.

    Die Template-Datei sieht so aus:
    // Result.html
    Code:
    <table>
    <thead>
      <tr>
        <th>ID:</th>
        <th>Bezeichnung:</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>{ID}</td>
        <td>{Bezeichnung}</td>
      </tr>
    </tbody>
    </table>
    Wenn ich mir aber die Daten aus der DB hole und die mir auflisten lassen will, bringt er mir immer nur einen Datensatz zur Ausgabe.

    // Result.php
    PHP-Code:
      $sql $db->query("SELECT id, bezeichnung FROM daten WHERE id BETWEEN 1 AND 100);
      require_once " 
    Template-Klasse.php ";
      
    $template = new parser();
      
    $template->loadTemplatefile("Result.html");

      
    $i = 0;
      while(
    $row = mysql_fetch_array($sql, MYSQL_ASSOC))
      {
          
    $template->setVariables('{ID}', $row['id']);
          
    $template->setVariables('{Bezeichnung}', $row['bezeichnung']
          
    $i++;
      }

      
    $template->show(); 

    Frage: Wieso funzt das in einer Schleife nicht?


    GN


  • #2
    Ich denke $template->show(); muss mit in die Schleife
    Zwei Dinge sind unendlich, das Universum und die menschliche Dummheit, aber bei dem Universum bin ich mir noch nicht ganz sicher. - Albert Einstein

    Kommentar


    • #3
      Du überschreibst doch {ID} nach jedem mal wenn du die Schleife durchläufst. Also beim ersten mal wird z.b. {ID} zu 1 dann wirds beim nächsten Durchlauf {ID} zu 2 und am Ende hast du halt nur den letzten Datensatz.

      Außerdem wird bei dir auch im Template nur einmal das {ID} und {Bezeichnung} angezeigt. Du musst im Template schon definieren was alles geloopt werden soll.

      Kommentar


      • #4
        Zitat von RaZoR
        Du überschreibst doch {ID} nach jedem mal wenn du die Schleife durchläufst. Also beim ersten mal wird z.b. {ID} zu 1 dann wirds beim nächsten Durchlauf {ID} zu 2 und am Ende hast du halt nur den letzten Datensatz.

        Außerdem wird bei dir auch im Template nur einmal das {ID} und {Bezeichnung} angezeigt. Du musst im Template schon definieren was alles geloopt werden soll.
        Hallo,

        wie meinst du das?
        Was muss ich denn alles im Template mit angeben?


        GN

        Kommentar


        • #5
          Hallo GN,

          Was stellst du da für Fragen? Du hast doch die Parser-Klasse selbst geschrieben?! Wenn du dein Template nur an einer Stelle transformierst, wirst du auch nur eine ausgabe bekommen.

          Solltest sowas machen, wobei das Template dann anders gewählt werden muss:

          PHP-Code:

          $sql 
          $db->query("SELECT id, bezeichnung FROM daten WHERE id BETWEEN 1 AND 100);
            require_once " 
          Template-Klasse.php ";
            
          $template = new parser();
            
          $template->loadTemplatefile("Result.html");

            
          $sBuffer = (string)'';
            while(
          $row = mysql_fetch_array($sql, MYSQL_ASSOC))
            {
                
          $template->setVariables('{ID}', $row['id']);
                
          $template->setVariables('{Bezeichnung}', $row['bezeichnung']
                
          $sBuffer .= $template->show();
            }

            echo 
          $sBuffer;
          ?> 
          Aber das hättest du aus den bisherigen Posts auch sehen können...
          Viele Grüße,
          Dr.E.

          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          1. Think about software design before you start to write code!
          2. Discuss and review it together with experts!
          3. Choose good tools (-> Adventure PHP Framework (APF))!
          4. Write clean and reusable software only!
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

          Kommentar


          • #6
            Bei dir wird jetzt einfach {ID} und {Bezeichnung} ersetzt ... aber du willst doch für jeden Eintrag in der Datenbank dass sich dieser Teil hier:
            Code:
            <tr>
                <td>{ID}</td>
                <td>{Bezeichnung}</td>
              </tr>
            wiederholt oder??

            Kommentar


            • #7
              Zitat von RaZoR
              Bei dir wird jetzt einfach {ID} und {Bezeichnung} ersetzt ... aber du willst doch für jeden Eintrag in der Datenbank dass sich dieser Teil hier:
              Code:
              <tr>
                  <td>{ID}</td>
                  <td>{Bezeichnung}</td>
                </tr>
              wiederholt oder??
              Hallo,

              einige Tage später, aber ja.
              Ich möchte, dass für jeden Eintrag in der Datenbank sich dieser Teil ({ID} und {Bezeichnung}) wiederholt.

              GN

              Kommentar


              • #8
                Dann musst du im Template irgendwie definieren dass genau dieser Teil wiederholt werden soll. Irgendwie z.b.

                Code:
                {foreach $array}
                <tr>
                    <td>{$array.ID}</td>
                    <td>{$array.Bezeichnung}</td>
                </td>
                {/foreach}
                Und dann musst du mit deiner Klasse eben {foreach ...} und {/foreach} rausfiltern und den Teil dazwischen per Schleife durchgehen. Das ganze ist allerdings sehr kompliziert daher rate ich dir wenn du ein so komplexes Templatesystem haben möchtest lieber ein fertiges zu nehmen. Smarty

                Kommentar


                • #9
                  tja
                  jetzt kommen wir zum ergebnis, dass eine Moderne template die schleifen unterstützen muss, und noch 3 Tage später kommst du zu dem ergebnis, das auch die laufwariablen auch zur einer Template gehören
                  (um zbs wechselnde farben bei tabelle zu machen).
                  nach einem monat, wäre es auch nicht schlecht ein paar anderen dingen oder funktionen rein zuhauen.
                  Wenn du genug gedult hast, dann entwickelst du etwas was schon vorhanden ist wie Smarty oder andere stringersetzende Templatesystemen die auf basis von einer interpreter-sprache PHP neue Interpreter-sprachen programmiert haben und für mich als Fehlentwicklung zu bezeichnen sind.

                  "Jetzt werde ich als verrückt bezeichnet"

                  Bitte versuch nie mehr PHP von HTML zu trennen, da am ende hast du statt PHP eine andere pseudo-sprache die immer noch in HTML steckt.
                  Trenne bitte deine Geschäftslogik von Ausgabel_und_Layoutlogik und wenn das sein muss, dann verwende bei Ausgabel_und_Layoutlogik die funktionen die PHP bietet, statt kommische pseudo-code, das sich in wirklichkeit kaum von PHP unterscheidet aber performance, arbeitspeicher und unnötige einarbeitungszeit verlangt.
                  beispiel Smarty
                  deine Template würde etwa so aussehen.

                  <table>
                  <thead>
                  <tr>
                  <th>ID:</th>
                  <th>Bezeichnung:</th>
                  </tr>
                  </thead>
                  <tbody>
                  {foreach from=$myArray item=foo}
                  <tr>
                  <td>{$foo.ID}</td>
                  <td>{$foo.Bezeichnung}</td>
                  </tr>
                  {/foreach}
                  </tbody>
                  </table>

                  wuala, du hasst die code bekommen, die sich kaum von normalem PHP-code unterscheidet und die Designer verstehen von diesem code genau so viel wie von php.
                  ausserdem muss du alle ergebnisse von deiner mysql-abfrage erst in ein array zwischenspeichern und erst danach an die assign übergeben und dann mit php noch mal interpretiert wird.
                  Dadurch steigt der speicherverbrauch und sinkt die geschwindigkeit von deiner Anwendung.

                  Wenn du dich für die trennung von Geschäftslogik von Ausgabe und Layoutlogik beschäftigen möchtest, dann werde ich bei bedarf die passende Einsätze vorschlagen.
                  Slava
                  http://bituniverse.com

                  Kommentar


                  • #10
                    Zitat von Slava
                    wuala, du hasst die code bekommen, die sich kaum von normalem PHP-code unterscheidet und die Designer verstehen von diesem code genau so viel wie von php.
                    ganz ehrlich, dieser gedanke ist mir auch schon öfter gekommen. aber zwei grundlegende vorteile hat ein template eben doch.

                    1. Du hast soweit wir möglich Inhalt und Layout getrennt. Wenn Du Dein Template gut machst, brauchst Du Dich nur einmal darum zu kümmern. Danach nur noch nutzen.
                    2. das Layout ist für sich von einem Designer bearbeitbar. Selbst wenn du ein Peudotemplate nutzt, indem du das tust:
                    Code:
                    <table>
                    <thead>
                    <tr>
                    <th>ID:</th>
                    <th>Bezeichnung:</th>
                    </tr>
                    </thead>
                    <tbody>
                    
                    <tr>
                    <td><?= $FooID ?></td>
                    <td><?= $FooBezeichnung ?></td>
                    </tr>
                    
                    </tbody>
                    </table>
                    (mal ohne die Schleife, sonst aber ähnlich simpel) gibts immer noch das Problem, dass die Felder ohne Parsing und konkrete Vorgaben keine Inhalte besitzen. Damit ändert sich zwangsläufig auch das Aussehen der html Anzeige beim Layouten.
                    --

                    „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                    Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                    --

                    Kommentar


                    • #11
                      wenn zbs bei Smarty eine variable nicht existiert, dann gibt es noch eine fehlermeldung, die auch layout zerschiesst.
                      ich würde mal so sagen, das die Template-system, die nur str_replace macht und keine schleifen und andere Funktionen unterstützt ziemlich schnell seine Arbeit machen kann ( schneller als include) aber es dauert eben nicht mehr lange, bis man merkt, dass einfache str_replace nicht mehr ausreicht und der ganze Projekt kann dadurch stark in stocken geraten.
                      Um so ein Problem zu vermeiden, nehmen viele Projektleiter Smarty, da diese Templatesystem in vergleich zu den anderen viel mehr bietet und kann dadurch ein Projekt aus der Sackgasse rausziehen.
                      Ich wundere mich aber, wie gut diese Aussage "wir müssen PHP von HTML trennen" von den anderen gefressen wurde, und zwar so, dass sie vergessen haben, dass es in wirklichkeit um die Trennung von Programm-Gäschäftslogik und Ausgabe-Logik handelt.
                      Ein paar Erfolgsberichte und die Leute versuchen schon um jeden Preis statt PHP eine andere Schein-Sprache einzusetzen, weil ihnen vorgekaut wurde, dass das ein einzige weg ist Geschäftslogik von Layout zu trennen.

                      ich poste mal hier ein Link zur Template-benchmarking (finde es aber nicht gut, dass meine tamplate weniger durchläufe als die andere macht)
                      und wenn die andere für die "PHPTempl" interessieren, dann werde ich die code hier posten.
                      http://www.template-benchmark.de
                      Slava
                      http://bituniverse.com

                      Kommentar


                      • #12
                        Würd mich schon interessieren. Vorallem wenn du hier so auf die Templatesysteme schimpfst warum hast du dir dann deine eigene Klasse geschrieben? Ist es im Endeffekt dann nicht auch wieder das mischen einer Pseudosprache mit HTML ??

                        Kann dein Template auch Caching?

                        Kommentar


                        • #13
                          meine template verwendet keine pseudosprache sondern benutzt ganz normale php code.
                          Ich trenne nicht PHP von HTML
                          ich trenne Geschäftslogik von Ausgabelogik.
                          eine Template ist bei mir ganz normale datei, die php-code statt platzhalter benutzr
                          <?=$variable;?> bzw <?php echo $variable; ?>
                          statt
                          {variable}

                          <?php foreach($myArray as $foo){ ?>
                          statt
                          {foreach from=$myArray item=foo}

                          die Template ist genau so wie bei Smarty oder auch anderer Templatesystem eine datei, die HTML code hat und bei der Ausgabe die Variablen und andere Daten nur für Ausgabe konsumiert. Das ist von MCV -Sicht ein View. Hier muss nur die code drin sein, die wirklich nur für Ausgabe sorgt. Datenbeschaffung und andere Entscheidungen, die mit ausgabe nichts zutun haben, haben hier auch nichts zu suchen.
                          es sieht wirklich fast so aus wie bei dem lätztem Beispiel von @nikosch77.

                          Die Leute, die gelernt haben, dass sie "PHP von HTML trennen müssen" beginnen sofort nach dieser Aussage ein Aufstand zu machen. Ich möchte gerne bevor ich mit meiner classe fortfahre alle Gegenargumente von dieser Ziehlgruppe mit meinem feinem deutsch( ) beantworten.

                          die classe PHPTempl unteracsheidet sich kaum in senen Methoden-namen von den anderen Templatesystemen.
                          ein aufruf kann etwa so aussehen
                          Code:
                          $templ=new PHPTempl;
                          $templ->setheader('Content-Type: text/html; charset=utf-8');
                          $templ->set("content","Üß Probe");
                          $templ->set("li",array("a","b","c"));
                          $templ->set("datum",date("d.m.Y"));
                          //hier wird nichts zwischengespeichert. der ergbnis wird in template geparst $zeile->name
                          $templ->set("zeile",new Result("select name, vorname from user",$dbconnection));
                          $templ->out($absolut_pfad."probetempl.html",true,"utf8_encode");
                          also fast dasselbe wie bei anderen Templaten.

                          Caching? nein, hat sie nicht. Caching ist eine sehr feine Sache, die man nicht unbedingt mit template mieschen muss. Es gibt sehr verschiedene Arten von cache (zeit-gesteuert, event-gesteuert, datei-basierend, db-basierend, shared-memory basierend) , und wenn man sich für ein cache entschieden hatt, dann wird es nicht zu schwer die classe zu erweitern( ist meine meinung nach besser, als unnötige code immer mitschleppen).
                          Slava
                          http://bituniverse.com

                          Kommentar


                          • #14
                            Hallo Slava,

                            ich sehe einige Wiedersprüche in deinen Aussagen: Einerseits sprichst du von Trennung von Ausgabe und Geschäfts-Logik andererseits, implementierst/verwendest du eine Template-Klasse, die sich vom dem, was es schon gibt wenig unterscheidet und sicher nicht der Weisheit letzter Schluss ist. Ich bin mir nicht ganz sicher, ob du nun ein Verfechter von sauberer Programmierung bist, oder es dir nur um Performance geht?! Vielleicht gibst du mir noch eine dritte Aussage, so dass ich das mal für mich verstehe

                            Zum Thema "Template" nochmal eine dritte oder zehnte Aussage:
                            Man kann ganz einfache "Template-Engines" mit "str_replace()" oder "include()" erstellen und es gibt auch schon hunderte davon. Was aber diese alle nicht können ist ordentliche Trennung von Design bzw. Ausgabe und Geschäftslogik und keiner von den Smarties und Co. unterstützt MVC in der Form, wie es eigentlich sein sollte. Ich hab noch kein Symphony gesehen, in dem ich XML-Tags eintragen kann und auf diese in einem Controller als Objekt zugreifen kann.
                            Man muss sich also entscheiden: entweder super Performance und dafür aber schlechte Implementierung oder etwas weniger Performance und Generik und ordentliche Programmierung.

                            Des weiteren Frage ich mich, warum diese Diskussion in nahezu jedem Thread wieder aufflammt. Wie Slava bereits beschreiben hat gibt es hunderte Seiten, die unterschiedliche Template-Systeme vergleichen. Auch ich, weil ich einen wesentlich höheren Anspruch habe, habe meines bereits zur Verfügung gestellt. Nun müsste die Diskussion doch mal ein Ende haben...

                            @Slava: So schwer ist Caching nicht, da sich deine Optionen dadurch schmälern, da wir hier von Web-Anwendungen sprechen, die Request-getrieben sind. Es bietet sich hier eigentlich nur noch Shared-Memory und Lazy-Caching an. Zudem kann man Caching sehr generisch implementieren, so dass man nur beim ersten Aufruf den Mehraufwand hat (Lazy-Caching). Ich persönlich arbeite mit Caching anhand der URL für GET-Anwendungen. POST-Anwendungen sind ausgeschlossen, da die Inhalte dort vom Benutzer bestimmt werden. Man kann hier einfach einen md5-Schlüssel über die REQUEST_URL legen und diesen im CacheManager abfragen.
                            Viele Grüße,
                            Dr.E.

                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                            1. Think about software design before you start to write code!
                            2. Discuss and review it together with experts!
                            3. Choose good tools (-> Adventure PHP Framework (APF))!
                            4. Write clean and reusable software only!
                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                            Kommentar


                            • #15
                              Zitat von dr.e.
                              Hallo Slava,

                              ich sehe einige Wiedersprüche in deinen Aussagen: Einerseits sprichst du von Trennung von Ausgabe und Geschäfts-Logik andererseits, implementierst/verwendest du eine Template-Klasse, die sich vom dem, was es schon gibt wenig unterscheidet und sicher nicht der Weisheit letzter Schluss ist. Ich bin mir nicht ganz sicher, ob du nun ein Verfechter von sauberer Programmierung bist, oder es dir nur um Performance geht?! Vielleicht gibst du mir noch eine dritte Aussage, so dass ich das mal für mich verstehe
                              Hi
                              ja ich verwende auch eine art von template, aber diese template kiene pseudocode benutzt sondern PHP.
                              Ich versuche jetzt mein Weg zu beschreiben.

                              Anfang:
                              php und html ist in einer datei gepackt.

                              Ergebnis=Katastrofe! etwas zu finden oder zu verändern war sehr aufwendig.

                              Nach 6 Monaten:
                              html teile sind so weit wie möglich in variablen und externe Dateien gepackt.
                              Ergebnis=keine Katastroffe, aber es war immer noch schwer die anpassungen in html teilen vorzunehmen.

                              Nach 1 Jahr:
                              nach dem ich ein paar kleinen Anwendungen geschrieben habe und die interessierende unbedingt ein paar Änderungen im Layout haben wollten, die nicht durch CSS lösbar waren haben meine Scripte schon ganz anderes ausgesehen. Ich habe grundsätzlich bei allen scripts wenigstens 2 Dateien gehabt.
                              etwa so:
                              //keine einzige echo oder andere ausgaben
                              //reine Logik und datenbeschafung.
                              Script-Logik.php
                              1)//untersuchen von Requestvariablen und entscheidung welche daten ich brache
                              2)//hier wurden daten gesammelt und einfach in variablen abgespeichert
                              $datum=date(..);
                              $tebelenzeilen=array(der von mysql kommt);
                              ...
                              3)//hier wurde include von ausgabe script gemacht.
                              include "ausgabe.php.inc";
                              -------------------------Ende von Logik und datenbeschafung--------

                              script: ausgabe.php.inc (im abgesichertem ordner)
                              //hier steckte ich die ganze html-code
                              <html>
                              //UND KONSUMIRTE die Variablen von dem Script-Logik.php
                              <h1>heute ist <?=$datum;?></h1>
                              Ich wutse hier genau, woher die daten kommen und wenn ich eine schleife für die ausgabe von tabellenzeilen brauchte habe ich das auch gemacht. dabei benutzte ich statt
                              echo "<tag>$variable</tag";
                              immer
                              <tag><?=$tag;?></tag>
                              für die jenige, die aussehen von dem script ändern wollten war einziges Regel ausgedacht. FINGER WEG VON <?....?> so lange Ihr davon keine Ahnung haben. Mit HTML könnter Ihr machen alles was Ihr wolltet.

                              Ergebnis=Es war alles so wie ich mir vorgestellt habe.
                              Wenn ich oder auch jeman anderer am Aussehen von Ausgaben ändern wollte, hat man dafür nur eine Datei "ausgabe.php.inc" und müsste sich überhaupt keine gedanken machen woher die variablen kammen, man hat sie einfach für Ausgabe benutzt. Dabei war jede in PHP vorhandene function oder steuerungs-strukture, so lange sie für Ausgabe gesorgt hat wie zbs. wordwrap gerechtfertigt (smarty tut das eigentlich auch, benutz aber dafür ein risiger umweg http://smarty.php.net/manual/en/lang...r.wordwrap.php).

                              Schon zur diesem Zeitpunkt ist die Trennung von Geschäftslogik von Ausgabelogik realisiert worden.

                              Aber! ich habe in meinem Script-Logik.php script die Variablen die einfach im luft hangen , $datum und $tebelenzeilen könnte ich bei untersuchung von meinen Logik-Scripten nicht mehr richtig identifizieren (ist das eine zwischenwariable oder wird sie für die Ausgabe benutzt?).
                              Um dieses Problem zu beheben habe ich einfach eine classe geschrieben "PHPTempl" die eine variable einfach an den Layout gebunden hat. jetzt könnte ich schnell nachvollziehen, dass
                              $templ->set("datum",datum(...)) mein datum ist, der direkt an den script-layout der includet wird zur verfügung als $datum stehen wird.

                              Vorteile: Syntax bei den Layoutscripten war genau so verständlich wie auch bei anderen Templatesystemen und für meinen Ausgabescript brauchte ich keine schleifen oder if abfragen, als auch functionen wie wordwrap entwickeln. Die Layout-scripte haben zur laufzeit der ganze umfang von PHP gehabt.
                              Nachteile: genau so wie auch bei anderen Templatesystemen gibt es hier keine Mechenismen, die brutal Geschäftslogik von Ausgabelogik trennen.
                              Das bleibt leider weiterhin an Programmierer überlassen.
                              Zitat von dr.e.
                              Zum Thema "Template" nochmal eine dritte oder zehnte Aussage:
                              Man kann ganz einfache "Template-Engines" mit "str_replace()" oder "include()" erstellen und es gibt auch schon hunderte davon. Was aber diese alle nicht können ist ordentliche Trennung von Design bzw. Ausgabe und Geschäftslogik und keiner von den Smarties und Co. unterstützt MVC in der Form, wie es eigentlich sein sollte. Ich hab noch kein Symphony gesehen, in dem ich XML-Tags eintragen kann und auf diese in einem Controller als Objekt zugreifen kann.
                              Man muss sich also entscheiden: entweder super Performance und dafür aber schlechte Implementierung oder etwas weniger Performance und Generik und ordentliche Programmierung.
                              Ja es gibt mehrere Templaten, aber ich weiss das meine mehr kann und kann gut auch für PDF oder eine Bildausgabe benutzt werden.
                              Ja es wird weiter dem Programmierer übelassen eine Trennlinie zwischen den Geschäftslogik und Ausgabe-logik zu ziehen. Meine Template kann genau wie die andere diese Arbeit abnehmen.
                              Auch zugiff auf ein XML tag hasst du bei meiner Template nur über die zusatzfunction, die als optionaler parameter übergeben wird oder auch wie bei den anderen Templaten, in dem du ausgabe erst zwischenspeicherst.
                              ok
                              PHP-Code:
                              class PHPTempl{
                                var 
                              $header=array();
                                var 
                              $v=array();//asignarray
                                
                              function PHPTempl(){}
                                
                              /*public
                                  hier werden header gesetzt
                                  genau so wie bei functio header
                                  mann kann diese function beliebig oft aufrufen um
                                  mehrere header zu setzen
                                */
                                
                              function setheader($header){
                                 
                              $this->header[]=$header
                                }
                                
                              /*private ignorieren*/
                                
                              function sendheaders(){
                                  if(
                              count($this->header)>0)
                                  for(
                              $i=0;$i<count($this->header);$i++)header($this->header[$i]);
                                }
                                
                                
                              /*public
                                hier werden variablen an template übergeben
                                $templinstanze->set("variablendame",$einevariable);
                                ist variable schon gesetzt, dann wird sie überschrieben
                                */
                                
                              function set($was,$wert){
                                
                              $this->v[$was]=$wert;  
                                }
                                
                              /*
                                public
                                fügt inhalt von (string)$wert zu
                                variable $was.
                                gleiche prinzip wie bei set() nur mit unterschied, dass
                                $wert angähängt und nicht überschrieben wird
                                */
                                
                              function add($was,$wert){
                                if(isset(
                              $this->v[$was])){
                                  
                              $this->v[$was].=$wert;
                                }else{
                                      
                              $this->set($was,$wert);
                                     }
                                }
                                
                                
                              /*ausgabe von tempate
                                @param $templpfad !!!absolute pfad zur templatescript
                                @param $out optional. true=direkte ausgabe
                                                      false=ausgabe als string
                                @param $funk optional. es kann noch name von einer function
                                übergeben werden, die otput zusätzlich behandelt
                                $funk muss ein string als parameter haben und ein string 
                                zurück liefern. prinzip wie bei ob_start("functionname");
                                */
                                
                              function out($templpfad,$out=true,$funk=false){
                                
                              extract($this->v);
                                if(
                              $out && !$funk){
                                
                              $this->sendheaders();  
                                require_once(
                              $templpfad);
                                return 
                              true;
                                }else{
                                     if(!
                              $funk)ob_start();
                                     else 
                              ob_start($funk);
                                     require_once(
                              $templpfad);
                                     
                              $ret ob_get_contents();
                                     
                              ob_end_clean();
                                     if(!
                              $out){return $ret;}
                                     else echo 
                              $ret;
                                    } 
                                }
                              }
                              //ende von template
                              /** erweiterte @example
                              include("benchmark.class.php");
                              $bench=new Benchmark;
                              $bench->start();
                              $templ=new PHPTempl;
                              $templ->setheader('Content-Type: text/html; charset=utf-8');
                              $templ->set("content","Üß Probe");
                              $templ->set("li",array("a","b","c"));
                              $templ->set("futer",date("d.m.Y"));
                              $templ->out("probetempl.html",true,"utf8_encode");
                              $bench->stop();
                              echo $bench->time();
                              */ 
                              simpel zum lachen.

                              Zitat von dr.e.
                              @Slava: So schwer ist Caching nicht, da sich deine Optionen dadurch schmälern, da wir hier von Web-Anwendungen sprechen, die Request-getrieben sind. Es bietet sich hier eigentlich nur noch Shared-Memory und Lazy-Caching an. Zudem kann man Caching sehr generisch implementieren, so dass man nur beim ersten Aufruf den Mehraufwand hat (Lazy-Caching). Ich persönlich arbeite mit Caching anhand der URL für GET-Anwendungen. POST-Anwendungen sind ausgeschlossen, da die Inhalte dort vom Benutzer bestimmt werden. Man kann hier einfach einen md5-Schlüssel über die REQUEST_URL legen und diesen im CacheManager abfragen.
                              ich weis, dass caching nicht so schwer zu entwickeln ist aber ich verwende caching doch getrennt von Template um es fein einsätzen zu können.

                              Da wir bis cachen angekommen sind, möchte ich gerne ein paar fragen stellen.

                              Erste Frage:
                              Ich versuche gerade viel zu oft Shared Memory für chacen einzusetzen. dabei stehen mir leider nur shmop functionen zur verfügung (Simafore ist abgeschaltet). Leider kann ich nicht wegen dieser Einschränkung die Maximalgröße eines gemeinsamen Speicherbereichs ermitteln und habe langsam die Ängste, dass die Anwendung dadurch abschmieren kann. Ich weiss einfach nicht was für ein Verhalten bei zu wenig Arbeitspeicher zu erwarten ist.
                              Wird shmop_oppen einfach FALSE zurückliefern oder könnte das ganz schlimme folgen für PHP oder sogar für OS haben?

                              Zweite Frage:
                              Ist es sinnvoll für die sessionführung nicht dateien sondern Shared Memory zu benutzen?

                              Danke
                              Slava
                              http://bituniverse.com

                              Kommentar

                              Lädt...
                              X