[PHP] [Tutorial] Template-Klasse

Dieses Thema im Forum "Webentwicklung" wurde erstellt von Ma-Ju, 4. November 2006 .

Schlagworte:
Status des Themas:
Es sind keine weiteren Antworten möglich.
  1. 4. November 2006
    [Tutorial] Template-Klasse

    So, ich melde mich mal wieder hier. Ich werde euch jetzt mal zeigen, wie man eine einfache Template-Klasse macht!

    Was sind Templates?
    Mit Templates könnt ihr Code und Design trennen. Auf Dauer bei jeder Ausgabe immer ein echo schreiben, dass ist ganz schön unübersichtlich und langwierig. Templates nehmen euch da eine ganze Menge Arbeit ab.
    In einer Template-Datei könnt ihr pures HTML schreiben und dort Platzhalter für eure PHP-Variablen einfügen. Im PHP-Script könnt ihr die Platzhalter dann mit Werten füllen.

    Was machen wir?
    Wir werden eine Klasse erstellen, mit der wir eine Template-Datei laden und Platzhalter ersetzen können. Es gibt sicher viele Methoden, dies zu machen, aber diese wird relativ simpel sein, sodass sie von vielen verstanden werden sollte.

    Grundvoraussetzungen?
    Ich setze voraus, dass ihr den grundlegenden Umgang mit PHP gewohnt seid. Außerdem solltet ihr schon etwas Erfahrung mit Objekten haben, denn näher werde ich auf einzelne Funktionen und Schlüsselwörter nicht eingehen.

    Auf Los geht's los!
    So, und dann beginnen wir auch gleich!
    Erstmal sollten wir uns überlegen, was unsere Templateklasse alles können muss und was sie für Eigenschaften hat.

    Eine Templateklasse brauch:
    - eine Template-Datei
    - ein Template-Pfad
    - Template-Tags mit Werten
    - Klammern für einen Tag

    Eine Templateklasse muss:
    - das fertig geparste Template ausgeben
    - Platzhalter einlesen
    - Platzhalter ersetzen
    - eine Template-Datei öffnen


    Nun übersetzen wir das mal in PHP!

    PHP:
    <? php

     // Wir erstellen eine neue Klasse "tpl"
     class  tpl  {
        var      $tplfile ;  // Der Name des Templates
             var  $tplpath ;  // Der Pfad zum Template
             var  $tag_content ;  // Der Inhalt eines Tags
             var  $tag ;  // Die Klammern um einen Tag

        // Der Konstruktor
             function  tpl ( $tplpath  =  "templates/" ) {
        }

             // Eine Methode, um eine Datei zu öffnen
             function  open ( $filename ) {
        }

             // Liest Platzhalter ein
             function  define (& $tagname ,  $value ) {
        }

             // Ersetze Platzhalter
             function  assign ( $input ) {
        }

             // Das fertige Template wird ausgegeben
             function  display ( $input ) {
        }
    }

     ?>
    Jetzt nehmen wir uns mal den Konstruktor vor. Hier werden jetzt ein paar Werte gespeichert.

    PHP:
    <? php
     function  tpl ( $tplpath  =  "templates/" ) {
             $this -> tplpath  =  $tplpath ;  // Der Name des Pfades
             $this -> tag        = array( '{' ,  '}' );  // Geschweifte Klammern für Platzhalter
     }
     ?>
    So, das war auch schon der Konstruktor. Nicht besonders viel.
    Jetzt müssen wir aber auch noch die Template-Datei öffnen:

    PHP:
    <? php
     function  open ( $filename ) {
             $file  = @ fopen ( $filename );  // Datei öffnen
             $content  = @ fread ( $file ,  filesize ( $filename ));  // Datei lesen
             fclose ( $file );  // Die Datei schließen

             return  $file ;  // Rückgabewert: $file
     }
     ?>
    Als nächstes werden die Platzhalter eingesetzt:

    PHP:
    <? php
     function  define (& $tagname ,  $value ) {
             $this -> tagcontent [ $tagname ] =  $value ;  // Platzhalter abspeichern
     }
     ?>
    Und hier werden sie umgewandelt:

    PHP:
    <? php
     function  assign ( $input ) {
        foreach(     $this -> tagcontent  as  $key  =>  $value ) {
                 $input  =  str_replace ( $this -> tag [ 0 ]. $key . $this -> tag [ 1 ],  $value ,  $input );  // Ersetzen
             }

        return      $input ;  // Rückgabewert: $input
     }
    Und jetzt kommen wir auch schon zur Ausgabe!

    PHP:
    <? php
     function  display ( $tplfile ) {
             $this -> tplfile  =  $tplfile ;
             $input  =  $this -> open ( $this -> tplpath . $this -> tplfile );  // Template wird geöffnet
             $input  =  $this -> assign ( $input );  // Platzhalter werden durch Inhalt ersetzt

             return  $input ;  // Rückgabewert: $input
     }

     ?>
    Soooo, und jetzt zeige ich euch, wie ihr das ganze aufruft!

    PHP:
    <? php

     include( "tpl.class.php" );  // Template-Klasse einfügen

     $tpl  = new  tpl ( "templates/" );  // Neues Template, die Ordnerangabe ist optional

    // Platzhalter definieren
     $tpl -> define ( "pagetitle" ,  "Die große Tutorial Site" );
     $tpl -> define ( "now" ,  date ( "d.m.y H:i" );
     $tpl -> define ( "welcome" ,  "Herzlich Willkommen auf unserer Seite!" );
     $tpl -> define ( "content" ,  "Hier werdet ihr in Zukunft viele Infos finden!" );

     // Template definieren
     $tpl -> display ( "index.tpl" );

     ?>
    Die "index.tpl" müsste dann ungefähr so aussehen:

    PHP:
    < html >
    <     head >
        <     title >{ pagetitle }</ title >
    </     head >
    <     body >
     Datum und Uhrzeit : { now }< br >< br >
    {     welcome }< br >
    {     content }
    </     body >
    </     html >
    Es gibt sicherlich viel bessere Open-Source Template-Engines im Internet, allen voran auch SMARTY, woran ich mich etwas orientiert habe. Aber dieses Script soll ein Denkanstoß an euch sein, wie ihr eure Klasse machen könntet!
    Ich habe die Klasse nicht getestet, wenn irgendwas nicht klappt, schreibt es bitte hier hinein! Bin über jede Kritk dankbar!

    Schönen Abend noch!
     
  3. 4. November 2006
    AW: [Tutorial] Template-Klasse

    Naja, also ich weiß nicht ob einem diese Klasse viel bringt, das meiste was man wirklich braucht, wie schleifen etc. ist nicht implementiert. SMARTY ist viel zu oberpowered, am simpelsten ist eifnach mit eval oder include zu arbeiten, wobei ich die zweite methode bevorzuge.

    FlowFlo
     
  4. 4. November 2006
    AW: [Tutorial] Template-Klasse

    schleifen kann man aber auch umgehen
    dafür muss man nur das template mehr aufspalten und die schleife selber in PHP schreiben
    naja, ich bleib bei meiner einstellung, dass eine angepasste smarty-engine fast das beste ist
    ausser man hat so viel zeit sich selber eine wirklich gute und für seine eigenen zwecke angepasste engine zu schreiben
    aber wie der autor schon geschrieben hat: dies ist nunmal eine sehr simple art und reicht entsprechend auch für einfache zwecke
     
  5. 4. November 2006
    AW: [Tutorial] Template-Klasse

    schönes tut, leicht verständlich für anfänger

    aber muss das hier:
    PHP:
    <? php
     function  open ( $filename ) {
             $file  = @ fopen ( $file );  // Datei öffnen
             $content  = @ fread ( $file ,  filesize ( $filename ));  // Datei lesen
             fclose ( $file );  // Die Datei schließen

             return  $file ;  // Rückgabewert: $file
     }
     ?> 
    nicht

    PHP:
    <? php
     function  open ( $filename ) {
             $file  = @ fopen ( $filename );  // Datei öffnen
             $content  = @ fread ( $file ,  filesize ( $filename ));  // Datei lesen
             fclose ( $filename );  // Die Datei schließen

             return  $file ;  // Rückgabewert: $file
     }
     ?> 
    lauten?
     
  6. 4. November 2006
    AW: [Tutorial] Template-Klasse

    Nein.


    PHP:
    <? php
    function  open ( $filename ) {
             $file  = @ fopen ( $file );  // Datei öffnen
             $content  = @ fread ( $file ,  filesize ( $filename ));  // Datei lesen
             fclose ( $file );  // Die Datei schließen

             return  $file ;  // Rückgabewert: $file
    }
    ?> 
    muss

    PHP:
    <? php
    function  open ( $filename ) {
             $file  = @ fopen ( $filename );  // Datei öffnen
             $content  = @ fread ( $file ,  filesize ( $filename ));  // Datei lesen
             fclose ( $file );  // Die Datei schließen

             return  $file ;  // Rückgabewert: $file
    }
    ?> 
    lauten!
     
  7. 4. November 2006
    AW: [Tutorial] Template-Klasse

    ja muss es !
    sonst funktioniert es nicht

    Gruß mrJones

    EDIT:// sorry, hatte nicht gemerkt, dass schon jemand geantwortet hatte...
     
  8. 4. November 2006
    AW: [Tutorial] Template-Klasse

    Ich habs abgeändert, danke für den Tipp.

    Wie gesagt, ich will mehr die Arbeit mit Templates erläutern. Sicherlich, man kann dann auch noch Schleifen usw. einarbeiten, aber das hätte wohl den Rahmen dieses Tutorials gesprengt und außerdem hatte ich keine Lust darauf.
    Ich habs ja vorher nichtmal getestet, wie gesagt, soll nur den Funktionsablauf beschreiben.
    Früher hab ich auch eval() benutzt, aber das finde ich mittlerweile einfach zu unübersichtlich. Und per include() trennt man ja nicht wirklich Code und Design.
     
  9. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.