eigenes Template-System

uhuwe

Mitglied
So in etwa habe ich mir das Ganze vorgestellt.

index.php:
PHP:
<?php 
include("includes/config.php"); 
include("include/sql.php"); 
include("includes/common.php") 

//ggf.: $title="title"; $css="css/style.css"; 

while($read=mysql_fetch_array($sql)) 
{ 
$variable1=$read[feld1]; 
$variable2=$read[feld2]; 
$variable3=$read[feld3]; 
} 

include("templates/header.tpl"); 
include("templates/index.tpl"); 
include("templates/footer.tpl);
?>

Template-Datei:

index.tpl:
HTML:
<html> 
<head> 
<title>{title}</title> 
<style type=text/css> 
[include css] 
</style> 
</head> 
<body> 
<table> 
<tr> 
[rows sql] 
<td>{variable1}</td> 
<td>{variable2}</td> 
<td>{variable3}</td> 
[/rows] 
</tr> 
</table>


So, und in der common.php habe ich mir den tpl-Parser vorgestellt.

Nur wie müßte ich den schreiben?
 
Zuletzt bearbeitet:
Hi,

Es gibt doch das Tempate-System Smarty. Wenn du dass nicht nehmen willst, dann probier doch ersteinmal selber in PHP einen zu proggen. Wenn du da nicht weiter kommst, helfen wir dir gerne.
Aber so nach dem Motto "so soll es sein/funktionieren, macht doch mal bitte", gibt es hier glaube ich nicht.

Zudem würde ich das ganze mit Arrays lösen.
PHP:
$platzhalter = array();
#...
$platzhalter['variable1']=$read[feld1];  
$platzhalter['variable2']=$read[feld2];  
$platzhalter['variable3']=$read[feld3];

und dann mit einer foreach-Schleife weitermachen.
PHP:
foreach($platzhalter as $bezeichner => $value)
{
  #Im Template suchen und ersetzten
}

Musst es dann halt noch ein bisschen auf deine Bedürfnisse ausbauen, versteht sich.

mb fanste
 
wenn dan würde ich ereg_replace() benutzen.

Ich habe aber eine andere Möglichkeit. An den Stellen, wo was hinkommt schreibe ich z.B. "x##x" dann lasse ich die Datei mit explode aus einandernehemen.

Zum Anzeigen benutze ich:
echo $datei[0];
echo "titel";
echo $datei[1];
echo "text";
echo $datei[2];
 
@wieschoo
Das ist aber nicht grad die beste Lösung ;)

Alle TS funktionieren im prinzip auf dem oben von mir genannten Weg. Natürlich arbeitest du dann in der Schleife mit preg_replace, oder Ähnlichem.
 
fanste hat gesagt.:
Alle TS funktionieren im prinzip auf dem oben von mir genannten Weg.
Nicht ganz... beispielsweise XSLT (Mann, heute habe ich wohl den Klugertag).

Ich würde auf jeden Fall auf preg_replace() setzen. Allerdings stellt sich mir immernoch die Frage, wieso uhuwe unbedingt ein eigenes Templatesystem schreiben will.
@uhuwe: Ich würde mir erst einmal Smarty ansehen. Das System ist ziemlich ausgereift, hat eine breite Community und wird in vielen Foren/Mailinglists behandelt.
Wenn dir Smarty nicht genügt, kannst du dich immer noch an einem eigenen Templatesystem versuchen.
Wenn du das Ad-Hoc willst: http://www.php.net/manual/en/function.preg-replace.php
 
Hallo,

nunja die Meinung zu Templates ist sehr unterschiedlich. Bevor ich persönlich anfangen würde einen Template Parser zu schreiben (was in der Regel ganz gut mit Preg-Replace funktioniert), würde ich mir persönlich lieber überlegen ob dies überhaupt notwendig ist. Schließlich wurde PHP konzipiert um mit einer Skriptsyntax auf C-Befehle zugreifen zu können (=> PHP ist eigentlich eine Templatesprache).

Klar, PHP-Funktionenen ist in jedem Fall ein wenig mehr arbeit... wenn man jedoch eine halbwegs klare Objektstruktur schafft, sind PHP-Templates deutlich schneller als jedes vergleichbare Parser-System.

Ich mittlerweile benutzte nur noch PHP-Templates, auch wenn einige Designer damit Probleme haben - höchstens hier würde ich vielleicht dazu neigen administrativ zu auf ein Parser basierendes Template-System zurückzugreifen - wobei ich versuche immer davon zu überzeugen, das es nicht ratvoll sein kann eine eigene Templatesprache zu lernen - schließlich ist reiner PHP-Code auch nicht komplizierter als die wirklich peverse und eigenwillige Syntax von so manchen Templatesystem.

Nunja, ich poste Dir einfach mal mein Template-Script - Es ist PHP5 aber relativ einfach gehalten ;)

PHP:
<?
// file: template.class.inc
// written on 2005-10-09 by okuehn (irresponder.com)

class Template {
	public $file = "";
	private $variables = Array();

	function __construct() {
		return;
	}
	
	function __get($name) {
		if (isset($this->variables[$name]))
				return $this->variables[$name];
		return false;
	}
	
	function __set($name, $value) {
		if (!isset($this->variables[$name])) {
			$this->variables[$name] = $value;
			return true;
		}
		return false;
	}

	function display($file_path) {
		if (is_file($file_path))
			return $this->bufferFile($file_path);
		return false;
	}
	
	function bufferFile($file) {
		$result = "";
		// referenz zu template-objekt herstellen
		$_ = $this;
		if (is_file($file)) {
			ob_start();
			include $file_path;
			$result = ob_get_contents();
			ob_end_clean();
			return $result;
		} else die ("Template '$file' not found!");
	}
}

/*
Beispiel zur Verwendung (angepasst an angebenes Beispiel)
*/

$t = new Template();

$t->hw = 'Neuer Wert: Variable wird durch die Objekt-Funktion im $variables-Array der entsprechenden Instanz erzeugt ;).';
$t->document_title = 'Template-Test';
$t->css_file = './css/style.css';

$some_valid_mysql_query_result = mysql_query('SELECT * FROM `test`;');

$sql = Array();
while ($tmp = mysql_fetch_array($some_valid_mysql_query_result)) {
	$sql[] = $tmp;
}
$t->sql = $sql;

// erstelle root-konstante
define(__ROOT__, dirname(__FILE__));

// ausgabe template file
echo $t->display(__ROOT__.'/test.tpl');
// ende
?>
/***  file: test.tpl ***/
<html> 
<head> 
<title><?php echo $_->document_title; ?></title> 
<style type=text/css> 
<?php echo file_get_contents($_->css_file);  ?>
</style> 
</head> 
<body> 
<table> 
<tr> 
<?php 
// $key enthält in diesem Fall den Schlüssel des aktuellen Array-Indizies (0, 1 usw. ^= Rows)
foreach ($_->sql as $key => $value) { ?>
	<td><?php echo $value['variable1']; ?></td> 
	<td><?php echo $value['variable2']; ?></td> 
	<td><?php echo $value['variable3']; ?></td> 
<?php } ?>
</tr> 
</table> 
</body>
</html>

Das einzige Problem das ich mit PHP-Templates sehe ist das keinerlei Einschränkung der Funktionalität möglich ist, d.h. alle PHP-Funktionen können ausgeführt werden. Das kann aber auch mitunter recht hilfreich sein, gerade wenn man Objektorientiert arbeitet. Siehe Singleton-Pattern etc. ;)

Wie mir meine Erfahrung bisher zeigte war nie verkehrt einfach gänzlich auf Template-Parser (was ja letzenendes Erleichterung verschaffen soll, den Projektcode aber eigentlich nur tierisch aufbläht) zu verzichten, die Inhalte die der Benutzer letzenendes verfasst benötigen in den wenigstens Fällen ein Template bzw. PHP-Code - Textile z. B. ist ein hervorragendes Mittel inhaltlichen Kontext zu formatieren.

Ok, ich denke ich könnte noch stundenlang weiterschreiben - Wie gesagt die Meinungen sind zahlreich und weitgreifen - mir reicht mein System vollkommen aus. Eine strikte Trennung zw. Template-Anwendungslogik und Benutzerinhalten ist allerdings grundsätzlich empfehlenswert, auch wenn ich vielleicht ein wenig vom Thema abschweife ;)

Gruß
 
Zuletzt bearbeitet:
Zurück