![[HaBo]](/styles/default/logoklein.png)
Hallo,
nachdem im Teil 3 dieser Tutorialserie die Frage aufkam, wie man nach dem MVC-Prinzip dynamische Tables usw. ausgibt, hab ich mir gedacht, "Da muss ich mal ein weiteres Tutorial drüber schreiben".
Wer nicht weiß was MVC ist oder was es bedeutet, der kann sich das ganze mal auf Wikipedia anschauen.
Bei unserem kleinen Framework wäre dann das Template = View, die Action = Controller und z.B. die DBMapper (zu denen kommen wir in einem weiteren Tutorial) = Model. Um jetzt z.B. die Daten aus einer Datenbank als Tabelle ins Template zu bekommen, greifen wir auf Layouter zurück.
Aber was genau macht der Layouter?
Der Layouter nimmt die Daten, die z.B. aus einer DB kommen, entgegen und rendert nun z.B. eine Tabelle daraus und übergibt diese ans Template.
Was brauchen wir also alles?
Wir brauchen eine neue Klasse, diese nennen wir TestLayouter.class.php und legen Sie ins Core Verzeichnis.
Hier mal der Source der Klasse, ich hab die Klasse so einfach wie möglich gehalten. Es werden also keine Requestdaten oder so verarbeitet.
TestLayouter.class.php
Ok, das war die TestLayouter-Klasse, kommen wir nun zur benutzung der Klasse.
Dazu brauchen wir folgende Dateien aus dem letzten Tutorial:
Main.class.php
Main.tpl.php
Wir öffnen die Main.class.php, und erweitern die Klasse so, dass Sie danach folgendermaßen ausschaut.
Gut gut, jetzt haben wir zwar den Layouter in die Action eingebaut, aber ausgegeben wird deshalb auch noch nichts.
Deshalb öffnen wir nun das Template und erweitern es um ein einfaches echo $this->get('table');
Das Template sieht dann folgendermaßen aus:
Und das wars dann auch schon wieder, nun können wir dynamisch generierte Daten im Template ausgegeben.
Ich hoffe Ihr seit auch beim nächsten Mal wieder dabei, wenn es heißt "Wir bauen uns ein Framework, und PHP ist geil!".
nachdem im Teil 3 dieser Tutorialserie die Frage aufkam, wie man nach dem MVC-Prinzip dynamische Tables usw. ausgibt, hab ich mir gedacht, "Da muss ich mal ein weiteres Tutorial drüber schreiben".
Wer nicht weiß was MVC ist oder was es bedeutet, der kann sich das ganze mal auf Wikipedia anschauen.
Bei unserem kleinen Framework wäre dann das Template = View, die Action = Controller und z.B. die DBMapper (zu denen kommen wir in einem weiteren Tutorial) = Model. Um jetzt z.B. die Daten aus einer Datenbank als Tabelle ins Template zu bekommen, greifen wir auf Layouter zurück.
Aber was genau macht der Layouter?
Der Layouter nimmt die Daten, die z.B. aus einer DB kommen, entgegen und rendert nun z.B. eine Tabelle daraus und übergibt diese ans Template.
Was brauchen wir also alles?
Wir brauchen eine neue Klasse, diese nennen wir TestLayouter.class.php und legen Sie ins Core Verzeichnis.
Hier mal der Source der Klasse, ich hab die Klasse so einfach wie möglich gehalten. Es werden also keine Requestdaten oder so verarbeitet.
TestLayouter.class.php
PHP:
class TestLayouter {
// Hier werden die Daten (Dataset, Array, ...) gespeichert
private $data;
// Der Tabelle geben wir natürlich eine ID, so hat man es später
// beim einbau einer Paginierung einfacher
private $id;
// Hier werden die Outputdaten gespeichert
private $buffer;
/**
* Der Konstruktor, wurde keine Id übergeben, so wird eine Exception
* ausgelöst. Da es vorkommen kann, dass eine Tabelle noch keine Daten
* hat, wird hier keine Exception ausgelöst.
*/
public function __construct($data, $id) {
$this->data = $data;
if (empty($id)) {
throw new Exception('Keine Id übergeben!');
}
$this->id = $id;
}
/**
* Die toString Methode wird aufgerufen, wenn man das Objekt mit
* z.B. echo new TestLayouter($data, 'test'); aufruft.
* In dieser Methode wird die Tabelle erzeugt.
*/
public function __toString() {
if (empty($this->data)) {
return "<p>Keine Daten zum Anzeigen gefunden!</p>";
}
$this->openTable();
$rowCnt = sizeof($this->data);
for ($row = 0; $row < $rowCnt; $row++) {
$this->openRow();
$columnCnt = sizeof($this->data[$row]);
for ($col = 0; $col < $columnCnt; $col++) {
$this->writeColumn($this->data[$row][$col]);
}
$this->closeRow();
}
$this->closeTable();
return $this->buffer;
}
/**
* Wir öffnen die Table und setzen die ID
*/
private function openTable() {
$this->buffer = "<table id='" . $this->id . "'>\n";
}
/**
* Zum öffnen einer Zeile(Row)
*/
private function openRow() {
$this->buffer .= "\t<tr>\n";
}
/**
* Zum schreiben einer Spalte(Column)
*/
private function writeColumn($value) {
$this->buffer .= "\t\t<td>" . $value . "</td>\n";
}
/**
* Schließt die Zeile
*/
private function closeRow() {
$this->buffer .= "\t</tr>\n";
}
/**
* Schließt die Table
*/
private function closeTable() {
$this->buffer .= "</table>\n";
}
}Ok, das war die TestLayouter-Klasse, kommen wir nun zur benutzung der Klasse.
Dazu brauchen wir folgende Dateien aus dem letzten Tutorial:
Main.class.php
Main.tpl.php
Wir öffnen die Main.class.php, und erweitern die Klasse so, dass Sie danach folgendermaßen ausschaut.
PHP:
class Main extends Action {
public function __toString() {
return 'Die Main Action';
}
public function run() {
AutoLoader::loadPackage('core\TestLayouter.class.php');
$tpl = new Template();
$text = 'Dies ist ein Text der dem Template übergeben wurde!';
$tpl->assign('text', $text);
$data = null;
// Hier wird nur schnell zu Testzwecken das Array mit 10x10 Spalten befüllt
for ($i = 0; $i < 10; $i++) {
for ($j = 0; $j < 10; $j++) {
$data[$i][] = ($i+1) * ($j+1);
}
}
// Hier übergeben wir eine Instanz des Layouters an das Template
$tpl->assign('table', new TestLayouter($data, 'test'));
$tpl->display('main.Main');
}
}Gut gut, jetzt haben wir zwar den Layouter in die Action eingebaut, aber ausgegeben wird deshalb auch noch nichts.
Deshalb öffnen wir nun das Template und erweitern es um ein einfaches echo $this->get('table');
Das Template sieht dann folgendermaßen aus:
PHP:
<?php
$this->includeAction('main.IncMainHeader');
?>
<h1>Dies ist unser erstes Template!</h1>
<p>
Hier wird dann ein Text angezeigt!
<br />
<?php echo $this->get('text'); ?>
</p>
<br />
<?php
// Hier wird die Tabelle ausgegeben.
echo $this->get('table');
?>
<?php
$this->includeAction('main.IncMainFooter');
?>Und das wars dann auch schon wieder, nun können wir dynamisch generierte Daten im Template ausgegeben.
Ich hoffe Ihr seit auch beim nächsten Mal wieder dabei, wenn es heißt "Wir bauen uns ein Framework, und PHP ist geil!".
