Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Templates

Einklappen

Neue Werbung 2019

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

  • [Erledigt] Templates

    Hi!

    Ich bin gerade dabei meine Seite neu zu programmieren und will diesmal nicht wieder so ein durcheinander haben. Templates wären da ja schonmal der richtige Ansatz... allerdings möchte ich nicht irgendwelche vorgefertigten Dinger eir Smarty nehmen, sondern den Mist selber schreiben!

    Kennt jemand ne Anleitung zu dem Thema oder kann mir so weiterhelfen?

    MfG TWron


  • #2
    Hmm so viel gehört doch eigentlich nicht dazu. Ihc hab mir eine eigenen Klasse dafür geschrieben, die im prinzip nur eine Handvoll funktionen benötigt:

    str_replace(), file(), implode(), empty() und strstr()

    Mehr als das habe ich wirklich nicht gebruacht um mir meine eigenes kleines Template System zu bauen.

    Kommentar


    • #3
      ich hab da auch schon nen bissl was hinbekommen.... nur das problem ist, dass ich nicht mehrere templates zur gleichen zeit verwalten kann.

      wenn ich die index.tpl ausgelesen habe, kann ich die news.tpl nicht mehr lesen...
      außerdem kann ich nur durch strings ersetzen.... ziel ist aber, dass ich zb in der index.tpl die designvariable MAIN durch includes ersetze.

      Kommentar


      • #4
        such mal nach phptemplate, da gibts irgendwo eine klasse, die hat nur 20 zeilen oder so, die is sehr aufschlussreich, und finger weg von str_replace, das is SAULANGSAM, viele templatesysteme arbeiten damit, obwohl es längst überholt ist.

        Kommentar


        • #5
          seit php5 salonfähig ist benutze ich xslt...
          Feine Sach dat.

          Kommentar


          • #6
            warum nicht str_replace.... das is schneller als ereg(i)_replace

            was soll ich denn besser nehmen?

            Kommentar


            • #7
              das beste ist es das template folgendermaßen aufzubauen, dann ist ein str_replace nicht nötig:

              PHP-Code:
              <html>
              <body>
              blah blub
              <?=$variable1?>
              blubidibla
              <?=$variable2?>
              </body>
              </html>
              wozu rechenzeit mit str_replaces verschwenden, nur damit das <?=$var?> mit [var] oä ersetzt wird...

              Kommentar


              • #8
                das verfehlt aber den sinn...
                1. will php und html komplett trennen und
                2. soll der designer die templates ändern können

                hab jetzt mal das hier gefunden.... was haltet ihr davon?

                http://www.inphpfriend.de/forum/showthread.php?t=124

                Kommentar


                • #9
                  das hat sehr wohl sinn, glaub mir ein str_replace is langsamer.. der designer wird wohl noch <?=$var?> statt [var] schreiben können. ich zeig dir mal die klasse dazu:

                  PHP-Code:
                  <?php


                  /* template.php
                  *
                  *    *---------*
                  *    |  USAGE  |
                  *    *---------*

                  *   -| Cached Template |-
                  *
                  *   $tpl = & new CachedTemplate($cache_name);
                  *   if(!($tpl->is_cached())) {
                  *      $tpl->set('title', 'My Title');
                  *      $tpl->set('list', array('cat', 'dog', 'mouse'));
                  *   }
                  *   echo $tpl->fetch_cache($templatefile);

                  *
                  *   -| normal Template |-
                  *
                  *   $tpl = & new Template();
                  *      $tpl->set('title', 'My Title');
                  *      $tpl->set('list', array('cat', 'dog', 'mouse'));
                  *   echo $tpl->fetch($templatefile);
                  *
                  */

                  class Template {
                      var 
                  $vars/// Holds all the template variables

                      /**
                       * Constructor
                       *
                       * @param $file string the file name you want to load
                       */
                      
                  function Template($file null) {
                          
                  $this->file $file;
                      }

                      
                  /**
                       * Set a template variable.
                       */
                      
                  function set($name$value) {
                          
                  $this->vars[$name] = is_object($value) ? $value->fetch() : $value;
                      }

                      
                  /**
                       * Open, parse, and return the template file.
                       *
                       * @param $file string the template file name
                       */
                      
                  function fetch($file null) {
                          if(!
                  $file$file $this->file;

                          
                  extract($this->vars);          // Extract the vars to local namespace
                          
                  ob_start();                    // Start output buffering
                          
                  include($file);                // Include the file
                          
                  $contents ob_get_contents(); // Get the contents of the buffer
                          
                  ob_end_clean();                // End buffering and discard
                          
                  return $contents;              // Return the contents
                      
                  }
                  }

                  /**
                  * An extension to Template that provides automatic caching of
                  * template contents.
                  */
                  class CachedTemplate extends Template {
                      var 
                  $cache_id;
                      var 
                  $expire;
                      var 
                  $cached;

                      
                  /**
                       * Constructor.
                       *
                       * @param $cache_id string unique cache identifier
                       * @param $expire int number of seconds the cache will live
                       */
                      
                  function CachedTemplate($cache_id null$expire 900) {
                          
                  $this->Template();
                          
                  $this->cache_id $cache_id 'cache/' md5($cache_id) : $cache_id;
                          
                  $this->expire   $expire;
                      }

                      
                  /**
                       * Test to see whether the currently loaded cache_id has a valid
                       * corrosponding cache file.
                       */
                      
                  function is_cached() {
                          if(
                  $this->cached) return true;

                          
                  // Passed a cache_id?
                          
                  if(!$this->cache_id) return false;

                          
                  // Cache file exists?
                          
                  if(!file_exists($this->cache_id)) return false;

                          
                  // Can get the time of the file?
                          
                  if(!($mtime filemtime($this->cache_id))) return false;

                          
                  // Cache expired?
                          
                  if(($mtime $this->expire) < time()) {
                              @
                  unlink($this->cache_id);
                              return 
                  false;
                          }
                          else {
                              
                  /**
                               * Cache the results of this is_cached() call.  Why?  So
                               * we don't have to double the overhead for each template.
                               * If we didn't cache, it would be hitting the file system
                               * twice as much (file_exists() & filemtime() [twice each]).
                               */
                              
                  $this->cached true;
                              return 
                  true;
                          }
                      }

                      
                  /**
                       * This function returns a cached copy of a template (if it exists),
                       * otherwise, it parses it as normal and caches the content.
                       *
                       * @param $file string the template file
                       */
                      
                  function fetch_cache($file) {
                          if(
                  $this->is_cached()) {
                              
                  $fp = @fopen($this->cache_id'r');
                              
                  $contents fread($fpfilesize($this->cache_id));
                              
                  fclose($fp);
                              return 
                  $contents;
                          }
                          else {
                              
                  $contents $this->fetch($file);

                              
                  // Write the cache
                              
                  if($fp = @fopen($this->cache_id'w')) {
                                  
                  fwrite($fp$contents);
                                  
                  fclose($fp);
                              }
                              else {
                                  die(
                  'Unable to write cache.');
                              }

                              return 
                  $contents;
                          }
                      }
                  }



                  ?>
                  die is jetz durch die comments und den cache etwas aufgebläht aber in der grundfunktion grad mal 10 zeilen oder so

                  Kommentar


                  • #10
                    aber wie bekomm ich jetzt die verf*$%?en includes darein? ^^

                    Kommentar


                    • #11
                      welche includes?
                      meinst du untertemplates?

                      das kann man wohl einem designer auch noch zumuten
                      <? include("untertemplate")?>

                      zu schreiben oder??

                      Kommentar


                      • #12
                        Hi,

                        dann lege ich nochmal meinen Standpunkt dar.

                        Ich halte smarty und die obige Klasse die über fopen arbeitet alles für gewurschtel. Den PHP Entwicklern wurde mit DOM und der XSLT Lib, imo perfekte Werkzeuge für die Trennung von Code und Design zur Verfügung gestellt.

                        Die Zukunft liegt bei XML. Mit XSL steht uns eine Sprache zur Verfügung die diese Daten auf jede nur erdenkliche weise darstellen kannst.

                        Warum also das Rad neu erfinden?

                        gruß

                        Kommentar


                        • #13
                          dachte, das geht erst ab php5?

                          Kommentar


                          • #14
                            ich meine keine untertemplates, sonder includete scripte.... zb gb

                            @shoryuken:
                            wie würdest du denn jetzt an meiner statt verfahren?

                            Kommentar


                            • #15
                              Also habe nen test gemacht mit ner einfachen form beider templatesysteme.

                              hauptfile:

                              PHP-Code:
                              <?php
                              include ("template.php");

                              $zeit1=microtime();

                              for (
                              $i=0;$i<300;$i++){
                              $temp1=new template1("temp1.tpl");
                              $temp1->assign("inhalt","Dies ist der Inhalt");
                              $temp1->out();
                              }

                              $zeit2=microtime();


                              for (
                              $i=0;$i<300;$i++){
                              $temp2=new template2();
                              $temp2->set("inhalt","Dies ist der Inhalt");
                              echo 
                              $temp2->fetch("temp2.tpl");
                              }

                              $zeit3=microtime();
                              echo 
                              "

                              $zeit1
                              $zeit2
                              $zeit3
                              "
                              ;
                              echo 
                              "template1: ";
                              echo 
                              $zeit2-$zeit1."
                              "
                              ;
                              echo 
                              "template2: ";
                              echo 
                              $zeit3-$zeit2."


                              Um Faktor "
                              .($zeit2-$zeit1)/($zeit3-$zeit2)." langsamer!";

                              ?>


                              template.php:

                              PHP-Code:
                              <?php
                              class template1
                              {
                                  var 
                              $template;

                                  function 
                              template1($file)
                                  {
                                          if(
                              $fp = @fopen($file"r")) {
                                              
                              $this->template fread($fpfilesize($file));
                                              
                              fclose ($fp);
                                          } else {
                                              return 
                              false;
                                          }

                                      return 
                              true;
                                  }

                                  function 
                              assign($replace$replacement)
                                  {
                                      
                              $this->template str_replace("{".$replace."}"$replacement$this->template);
                                      return  
                              true;
                                  }

                                  function 
                              out()
                                  {
                                      echo 
                              $this->template;
                                      return 
                              true;
                                  }
                              }

                              class 
                              template2 {
                                  var 
                              $vars;

                                  function 
                              set($name$value) {
                                      
                              $this->vars[$name] = $value;
                                  }

                                  function 
                              fetch($file) {
                                      
                              extract($this->vars);          // Extract the vars to local namespace
                                      
                              ob_start();                    // Start output buffering
                                      
                              include($file);                // Include the file
                                      
                              $contents ob_get_contents(); // Get the contents of the buffer
                                      
                              ob_end_clean();                // End buffering and discard
                                      
                              return $contents;              // Return the contents
                                  
                              }
                              }

                              ?>
                              temp1.tpl:
                              Code:
                              <div>
                              Überschrift
                              
                              {inhalt}
                              </div>
                              temp2.tpl

                              Code:
                              <div>
                              Überschrift
                              
                              <?=$inhalt?>
                              </div>
                              ergebnisse:
                              (es wurde minuswerte ignoriert, da diese nur entstehen, wenn der timestampwert unterschiedlich ist)

                              Versuch1:
                              template1: 0.036244
                              template2: 0.028356
                              Um Faktor 1.27817745803 langsamer!

                              Versuch2:
                              template1: 0.039728
                              template2: 0.02788
                              Um Faktor 1.42496413199 langsamer!

                              Versuch3:
                              template1: 0.036436
                              template2: 0.028733
                              Um Faktor 1.26808895695 langsamer!

                              Versuch4:
                              template1: 0.036789
                              template2: 0.028194
                              Um Faktor 1.30485209619 langsamer!

                              Versuch5:
                              template1: 0.042334
                              template2: 0.028699
                              Um Faktor 1.47510366215 langsamer!


                              so kann man abschließend sagen, daß die str_replace-version um ca 1/3 langsamer ist. dies macht sich bei größeren templates mit mehr variablen noch viel stärker bemerkbar.

                              edit:
                              includes kannst du doch machen, wie sonst auch, was is da anders?

                              Kommentar

                              Lädt...
                              X