Ein eigenes Template System entwickeln

von Corvin Gröning | 6 | 52930 Aufrufe

Anzeige Hier werben

Es gibt eine große Auswahl an Template Systemen für PHP. Ein sehr beliebtes ist zum Beispiel Smarty. Dennoch spricht vieles dafür, ein eigenes Template System zu entwickeln. Denn dieses kann man optimal an seine Bedürfnisse anpassen: Das eigene Template System bietet alle Funktionen, die man benötigt, aber keine, die man nicht benötigt. Dadurch ist es im Vergleich zu fertigen Lösungen schneller und vor allem flexibler: Erweiterungen lassen sich problemlos implementieren und mit anderen Funktionen des Projekts verknüpfen (zum Beispiel mit einem Error Handler).
Ein weiterer Vorteil ist die sich durch den optimal angepassten Funktionsumfang ergebene geringe Größe des Template Systems. So verbraucht die hier beschriebene Template Klasse etwa 10 KB Speicher, Smarty im Vergleich dazu über 300 KB und wäre somit bei kleineren Projekten um ein Vielfaches größer als das eigentliche Projekt.

Was das fertige Template System können soll

Am Ende soll das Template System folgende Funktionen bieten:

  • Ersetzung von Platzhaltern im Template
  • Includes: Templates innerhalb eines anderen Templates einbinden
  • Spezielle Template Kommentare, welche beim Aufrufen der Webseite nicht angezeigt werden (auch nicht im Quelltext)
  • Sprachdateien: Verwendung von Sprachvariablen innerhalb des Templates und im PHP-Code

Der Aufbau des Template Systems

Das Template System basiert auf einer Klasse namens Template.

Liste aller Eigenschaften und Methodennamen (inkl. Beschreibung)  
PHP
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
<?php
class Template
{
    /**
     * Der Ordner in dem sich die Templates befinden.
     */
    private $templateDir = "templates/";

    /**
     * Der Ordner in dem sich die Sprach-Dateien befinden.
     */
    private $languageDir = "language/";

    /**
     * Der linke Delimter für einen Standard-Platzhalter.
     */
    private $leftDelimiter = '{$';

    /**
     * Der rechte Delimter für einen Standard-Platzhalter.
     */
    private $rightDelimiter = '}';

    /**
     * Der linke Delimter für eine Funktion.
     */
    private $leftDelimiterF = '{';

    /**
     * Der rechte Delimter für eine Funktion.
     */
    private $rightDelimiterF = '}';

    /**
     * Der linke Delimter für ein Kommentar.
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     */
    private $leftDelimiterC = '\{\*';

    /**
     * Der rechte Delimter für ein Kommentar.
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     */
    private $rightDelimiterC = '\*\}';

    /**
     * Der linke Delimter für eine Sprachvariable
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     */
    private $leftDelimiterL = '\{L_';

    /**
     * Der rechte Delimter für eine Sprachvariable
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     */
    private $rightDelimiterL = '\}';

    /**
     * Der komplette Pfad der Templatedatei.
     */
    private $templateFile = "";

    /**
     * Der komplette Pfad der Sprachdatei.
     */
    private $languageFile = "";

    /**
     * Der Dateiname der Templatedatei.
     */
    private $templateName = "";

    /**
     * Der Inhalt des Templates.
     */
    private $template = "";


    /**
     * Die Pfade festlegen.
     */
    public function __construct() {
    }

    /**
     * Eine Templatedatei öffnen.
     */
    public function load()    {
    }

    /**
     * Einen Standard-Platzhalter ersetzen.
     */
    public function assign($replace, $replacement) {
    }

    /**
     * Die Sprachdateien öffnen und Sprachvariablem im Template ersetzen.
     */
    public function loadLanguage() {
    }

    /**
     * Sprachvariablen im Template ersetzen.
     */
    private function replaceLangVars() {
    }

    /**
     * Includes parsen und Kommentare aus dem Template entfernen.
     */
    private function parseFunctions() {
    }

    /**
     * Das "fertige Template" ausgeben.
     */
    public function display() {
    }
}
?>

Im Folgenden werden nun die einzelnen Methoden erklärt.

__construct() - Die Template Klasse vorbereiten

Der Konstruktor bietet die Möglichkeit, der Template Klasse einen alternativen Pfad für den Templates Ordner und den Sprachdateien Ordner zu übergeben. Wenn keine Pfade angegeben werden, verwendet die Template Klasse die Standardpfade, die in den Eigenschaften $templateDir und $languageDir bereits gespeichert sind (templates/ und language/).

Der Konstruktor der Template Klasse  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    /**
     * Die Pfade festlegen.
     *
     * @access    public
     */
    public function __construct($tpl_dir = "", $lang_dir = "") {
        // Template Ordner
        if ( !empty($tpl_dir) ) {
            $this->templateDir = $tpl_dir;
        }

        // Sprachdatei Ordner
        if ( !empty($lang_dir) ) {
            $this->languageDir = $lang_dir;
        }
    }
Beispiel für einen Aufruf von Template() (__construct())  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Möglichkeit 1
$tpl = new Template();

// Möglichkeit 2: der Templates Ordner und der Sprachdateien Ordner wird geändert
$tpl = new Template("tpls/", "lang/");

// Möglichkeit 3: nur der Templates Ordner wird geändert
$tpl = new Template("tpls/");

// Möglichkeit 4: nur der Sprachdateien Ordner wird geändert
$tpl = new Template("", "lang/");

load() - Ein Template öffnen

Die Methode load() versucht, ein Template zu öffnen. Bei erfolgreichem Öffnen wird der Templateinhalt in der Eigenschaft $template gespeichert. Anschließend wird die Methode aufgerufen, die definierte Template Funktionen innerhalb des Templates ersetzt (dazu später mehr).

Die Methode load()  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    /**
     * Eine Templatedatei öffnen.
     *
     * @access    public
     * @param     string $file Dateiname des Templates.
     * @uses      $templateName
     * @uses      $templateFile
     * @uses      $templateDir
     * @uses      parseFunctions()
     * @return    boolean
     */
    public function load($file)    {
        // Eigenschaften zuweisen
        $this->templateName = $file;
        $this->templateFile = $this->templateDir.$file;

        // Wenn ein Dateiname übergeben wurde, versuchen, die Datei zu öffnen
        if( !empty($this->templateFile) ) {
            if( file_exists($this->templateFile) ) {
                $this->template = file_get_contents($this->templateFile);
            } else {
                return false;
            }
        } else {
           return false;
        }

        // Funktionen parsen
        $this->parseFunctions();
    }
Beispiel für einen Aufruf von load()  
PHP
1
$tpl->load("templatename.tpl");

assign() - Einen Platzhalter im Template ersetzen

Mit assign() wird ein Platzhalter im Template ersetzt. Platzhalter haben die folgende Syntax:
{$name_des_platzhalters}

 
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    /**
     * Einen Standard-Platzhalter ersetzen.
     *
     * @access    public
     * @param     string $replace     Name des Platzhalters.
     * @param     string $replacement Der Text, mit dem der Platzhalter ersetzt
     *                                werden soll.
     * @uses      $leftDelimiter
     * @uses      $rightDelimiter
     * @uses      $template
     */
    public function assign($replace, $replacement) {
        $this->template = str_replace( $this->leftDelimiter .$replace.$this->rightDelimiter,
                                       $replacement, $this->template );
    }

Mit dem folgenden Aufruf von assign() wird zum Beispiel der Platzhalter {$test} im Template mit dem Text "Dies ist ein Test" ersetzt.

Beispiel für einen Aufruf von assign()  
PHP
1
$tpl->assign("test", "Dies ist ein Test");

loadLanguage() - Die Sprachdateien laden

Die Methode loadLanguage() erledigt drei Aufgaben: Sie lädt die Sprachdateien, die in einem Array übergeben wurden; ruft die Methode replaceLangVars() auf, welche die Sprachvariablen im Template ersetzt und gibt anschließend das Array $lang zurück, dieses beinhaltet die Sprachvariablen aus allen Sprachdateien.

Sprachvariablen im Template haben die folgende Syntax:
{L_SPRACHVARIABLE}

In einer Sprachdatei werden Sprachvariablen wiefolgt festgelegt:

 
PHP
1
2
$lang['sprachvariable']         = "Ein Text";
$lang['weitere_sprachvariable'] = "Ein weiterer Text";
Die Methode loadLanguage()  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    /**
     * Die Sprachdateien öffnen und Sprachvariablem im Template ersetzen.
     *
     * @access    public
     * @param     array $files Dateinamen der Sprachdateien.
     * @uses      $languageFiles
     * @uses      $languageDir
     * @uses      replaceLangVars()
     * @return    array
     */
    public function loadLanguage($files) {
        $this->languageFiles = $files;

        // Versuchen, alle Sprachdateien einzubinden
        for( $i = 0; $i < count( $this->languageFiles ); $i++ ) {
            if ( !file_exists( $this->languageDir .$this->languageFiles[$i] ) ) {
                return false;
            } else {
                 include_once( $this->languageDir .$this->languageFiles[$i] );
                 // Jetzt steht das Array $lang zur Verfügung
            }
        }

        // Die Sprachvariablen mit dem Text ersetzen
        $this->replaceLangVars($lang);

        // $lang zurückgeben, damit $lang auch im PHP-Code verwendet werden kann
        return $lang;
    }
Beispiel für einen Aufruf von loadLanguage()  
PHP
1
2
$langs[] = "de/sprachdatei_name.php";
$lang = $tpl->loadLanguage($langs); 

replaceLangVars() - Sprachvariablen ersetzen

Wie bereits angesprochen, ersetzt replaceLangVars() die Sprachvariablen im Template.

Die Methode replaceLangVars()  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
    /**
     * Sprachvariablen im Template ersetzen.
     *
     * @access    private
     * @param     string $lang Die Sprachvariablen.
     * @uses      $template
     */
    private function replaceLangVars($lang) {
        $this->template = preg_replace("/\{L_(.*)\}/isUe", "\$lang[strtolower('\\1')]", $this->template);
    }

parseFunctions() - Includes durchführen und Kommentare löschen

Die Methode parseFunctions() wird von load() aufgerufen. Sie ersetzt Include-Anweisungen mit dem entsprechenden Template. {include file="templatename.tpl"} wird mit dem Inhalt der Datei templatename.tpl ersetzt.

Weiterhin entfernt parseFunctions() Template Kommentare, damit diese nachher bei der Ausgabe für den Benutzer auch im Quelltext nicht sichtbar sind. Diese haben die folgende Syntax:
{* Kommentar *}

Die Methode parseFunctions()  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    /**
     * Includes parsen und Kommentare aus dem Template entfernen.
     *
     * @access    private
     * @uses      $leftDelimiterF
     * @uses      $rightDelimiterF
     * @uses      $template
     * @uses      $leftDelimiterC
     * @uses      $rightDelimiterC
     */
    private function parseFunctions() {
        // Includes ersetzen ( {include file="..."} )
        while( preg_match( "/" .$this->leftDelimiterF ."include file=\"(.*)\.(.*)\""
                           .$this->rightDelimiterF ."/isUe", $this->template) )
        {
            $this->template = preg_replace( "/" .$this->leftDelimiterF ."include file=\"(.*)\.(.*)\""
                                            .$this->rightDelimiterF."/isUe",
                                            "file_get_contents(\$this->templateDir.'\\1'.'.'.'\\2')",
                                            $this->template );
        }


        // Kommentare löschen
        $this->template = preg_replace( "/" .$this->leftDelimiterC ."(.*)" .$this->rightDelimiterC ."/isUe",
                                        "", $this->template );
    }

display() - Ausgabe des Templates

Zum Schluss wird das "fertige Template", welches ja nun keines mehr ist, ausgegeben.

Die Methode display()  
PHP
1
2
3
4
5
6
7
8
9
    /**
     * Das "fertige Template" ausgeben.
     *
     * @access    public
     * @uses      $template
     */
    public function display() {
        echo $this->template;
    }
Aufruf von display()  
PHP
1
$tpl->display(); 

Die komplette Template Klasse im Überblick

Hier nun die komplette Template Klasse:

Template.class.php  
PHP
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
<?php
class Template
{
    /**
     * Der Ordner in dem sich die Templates befinden.
     *
     * @access    private
     * @var       string
     */
    private $templateDir = "templates/";

    /**
     * Der Ordner in dem sich die Sprach-Dateien befinden.
     *
     * @access    private
     * @var       string
     */
    private $languageDir = "language/";

    /**
     * Der linke Delimter für einen Standard-Platzhalter.
     *
     * @access    private
     * @var       string
     */
    private $leftDelimiter = '{$';

    /**
     * Der rechte Delimter für einen Standard-Platzhalter.
     *
     * @access    private
     * @var       string
     */
    private $rightDelimiter = '}';

    /**
     * Der linke Delimter für eine Funktion.
     *
     * @access    private
     * @var       string
     */
    private $leftDelimiterF = '{';

    /**
     * Der rechte Delimter für eine Funktion.
     *
     * @access    private
     * @var       string
     */
    private $rightDelimiterF = '}';

    /**
     * Der linke Delimter für ein Kommentar.
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     *
     * @access    private
     * @var       string
     */
    private $leftDelimiterC = '\{\*';

    /**
     * Der rechte Delimter für ein Kommentar.
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     *
     * @access    private
     * @var       string
     */
    private $rightDelimiterC = '\*\}';

    /**
     * Der linke Delimter für eine Sprachvariable
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     *
     * @access    private
     * @var       string
     */
    private $leftDelimiterL = '\{L_';

    /**
     * Der rechte Delimter für eine Sprachvariable
     * Sonderzeichen müssen escapt werden, weil der Delimter in einem regulärem
     * Ausdruck verwendet wird.
     *
     * @access    private
     * @var       string
     */
    private $rightDelimiterL = '\}';

    /**
     * Der komplette Pfad der Templatedatei.
     *
     * @access    private
     * @var       string
     */
    private $templateFile = "";

    /**
     * Der komplette Pfad der Sprachdatei.
     *
     * @access    private
     * @var       string
     */
    private $languageFile = "";

    /**
     * Der Dateiname der Templatedatei.
     *
     * @access    private
     * @var       string
     */
    private $templateName = "";

    /**
     * Der Inhalt des Templates.
     *
     * @access    private
     * @var       string
     */
    private $template = "";


    /**
     * Die Pfade festlegen.
     *
     * @access    public
     */
    public function __construct($tpl_dir = "", $lang_dir = "") {
        // Template Ordner
        if ( !empty($tpl_dir) ) {
            $this->templateDir = $tpl_dir;
        }

        // Sprachdatei Ordner
        if ( !empty($lang_dir) ) {
            $this->languageDir = $lang_dir;
        }
    }

    /**
     * Eine Templatedatei öffnen.
     *
     * @access    public
     * @param     string $file Dateiname des Templates.
     * @uses      $templateName
     * @uses      $templateFile
     * @uses      $templateDir
     * @uses      parseFunctions()
     * @return    boolean
     */
    public function load($file)    {
        // Eigenschaften zuweisen
        $this->templateName = $file;
        $this->templateFile = $this->templateDir.$file;

        // Wenn ein Dateiname übergeben wurde, versuchen, die Datei zu öffnen
        if( !empty($this->templateFile) ) {
            if( file_exists($this->templateFile) ) {
                $this->template = file_get_contents($this->templateFile);
            } else {
                return false;
            }
        } else {
           return false;
        }

        // Funktionen parsen
        $this->parseFunctions();
    }

    /**
     * Einen Standard-Platzhalter ersetzen.
     *
     * @access    public
     * @param     string $replace     Name des Platzhalters.
     * @param     string $replacement Der Text, mit dem der Platzhalter ersetzt
     *                                werden soll.
     * @uses      $leftDelimiter
     * @uses      $rightDelimiter
     * @uses      $template
     */
    public function assign($replace, $replacement) {
        $this->template = str_replace( $this->leftDelimiter .$replace.$this->rightDelimiter,
                                       $replacement, $this->template );
    }

    /**
     * Die Sprachdateien öffnen und Sprachvariablem im Template ersetzen.
     *
     * @access    public
     * @param     array $files Dateinamen der Sprachdateien.
     * @uses      $languageFiles
     * @uses      $languageDir
     * @uses      replaceLangVars()
     * @return    array
     */
    public function loadLanguage($files) {
        $this->languageFiles = $files;

        // Versuchen, alle Sprachdateien einzubinden
        for( $i = 0; $i < count( $this->languageFiles ); $i++ ) {
            if ( !file_exists( $this->languageDir .$this->languageFiles[$i] ) ) {
                return false;
            } else {
                 include_once( $this->languageDir .$this->languageFiles[$i] );
                 // Jetzt steht das Array $lang zur Verfügung
            }
        }

        // Die Sprachvariablen mit dem Text ersetzen
        $this->replaceLangVars($lang);

        // $lang zurückgeben, damit $lang auch im PHP-Code verwendet werden kann
        return $lang;
    }

    /**
     * Sprachvariablen im Template ersetzen.
     *
     * @access    private
     * @param     string $lang Die Sprachvariablen.
     * @uses      $template
     */
    private function replaceLangVars($lang) {
        $this->template = preg_replace("/\{L_(.*)\}/isUe", "\$lang[strtolower('\\1')]", $this->template);
    }

    /**
     * Includes parsen und Kommentare aus dem Template entfernen.
     *
     * @access    private
     * @uses      $leftDelimiterF
     * @uses      $rightDelimiterF
     * @uses      $template
     * @uses      $leftDelimiterC
     * @uses      $rightDelimiterC
     */
    private function parseFunctions() {
        // Includes ersetzen ( {include file="..."} )
        while( preg_match( "/" .$this->leftDelimiterF ."include file=\"(.*)\.(.*)\""
                           .$this->rightDelimiterF ."/isUe", $this->template) )
        {
            $this->template = preg_replace( "/" .$this->leftDelimiterF ."include file=\"(.*)\.(.*)\""
                                            .$this->rightDelimiterF."/isUe",
                                            "file_get_contents(\$this->templateDir.'\\1'.'.'.'\\2')",
                                            $this->template );
        }


        // Kommentare löschen
        $this->template = preg_replace( "/" .$this->leftDelimiterC ."(.*)" .$this->rightDelimiterC ."/isUe",
                                        "", $this->template );
    }

    /**
     * Das "fertige Template" ausgeben.
     *
     * @access    public
     * @uses      $template
     */
    public function display() {
        echo $this->template;
    }
}
?>

Ein komplettes Anwendungsbeispiel

Anschließend ein komplettes Anwendungsbeispiel, dieses besteht aus sieben Dateien:
index.php
Template.class.php
language/de/lang_main.php
templates/header.tpl
templates/footer.tpl
templates/navigation.tpl
templates/index.tpl

templates/header.tpl  
HTML
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de">
<head>
<title>{$website_title}</title>
<meta http-equiv="Content-Type" content="text/xhtml; charset=ISO-8859-1" />
</head>
<body>
{include file="navigation.tpl"}
templates/footer.tpl  
HTML
1
2
</body>
</html>
templates/navigation.tpl  
HTML
1
<a href="/">Link 1</a>, <a href="/">Link 2</a>, <a href="/">Link 3</a><br /><br />
templates/index.tpl  
HTML
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{* Header einbinden *}
{include file="header.tpl"}

<h1>{L_START}</h1>
{L_THE_TIME_IS}: {$time}

<br /><br />

{$test}

{* Footer einbinden *}
{include file="footer.tpl"}
language/de/lang_main.php  
PHP
1
2
3
4
5
<?php
$lang['start']       = "Startseite";
$lang['the_time_is'] = "Die aktuelle Uhrzeit ist";
$lang['test']        = "Dies ist ein Test.";
?>
index.php  
PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
include("Template.class.php");

// Das Template laden
$tpl = new Template();
$tpl->load("index.tpl");

// Die Sprachdatei laden
$langs[] = "de/lang_main.php";
$lang = $tpl->loadLanguage($langs);

// Platzhalter ersetzen
$tpl->assign( "website_title", "MyHomepage" );
$tpl->assign( "time",          date("H:i") );

// Zugriff auf eine Sprachvariable
$tpl->assign( "test",          $lang['test'] );

// Und die Seite anzeigen
$tpl->display();
?>

Die Ausgabe sollte wie folgt aussehen:

null

Abschließende Überlegungen

Nun gilt es, sich Gedanken zu machen, wie es weiter gehen soll. Als erstes muss man das gesamte Template System natürlich verstanden haben. Anschließend sollte man sich überlegen, wie man das Template System für die eigenen Zwecke verwenden kann: Eventuell muss oder soll die Funktionsweise leicht verändert werden. So könnten zum Beispiel die Templates und Sprachvariablen aus einer Datenbank abgerufen werden, anstatt aus Textdateien. Weiterhin wird vielleicht eine Funktion benötigt, die eine Schleifenkonstruktion im Template ersetzt, um ein (mehrdimensionales) Array, das zum Beispiel Datensätze aus einer Datenbank enthalten könnte, darzustellen.