mirror of
https://github.com/smarty-php/smarty.git
synced 2025-08-05 02:44:27 +02:00
add new de files
This commit is contained in:
didou
39
docs/de/bookinfo.xml
Executable file
39
docs/de/bookinfo.xml
Executable file
@@ -0,0 +1,39 @@
|
|||||||
|
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||||
|
<!-- $Revision$ -->
|
||||||
|
<bookinfo id="bookinfo">
|
||||||
|
<title>Smarty - the compiling PHP template engine</title>
|
||||||
|
<authorgroup id="authors">
|
||||||
|
<author>
|
||||||
|
<firstname>Monte</firstname><surname>Ohrt <monte@ispi.net></surname>
|
||||||
|
</author>
|
||||||
|
<author>
|
||||||
|
<firstname>Andrei</firstname><surname>Zmievski <andrei@php.net></surname>
|
||||||
|
</author>
|
||||||
|
</authorgroup>
|
||||||
|
<pubdate>&build-date;</pubdate>
|
||||||
|
<copyright>
|
||||||
|
<year>2001-2004</year>
|
||||||
|
<holder>ispi of Lincoln, Inc.</holder>
|
||||||
|
</copyright>
|
||||||
|
</bookinfo>
|
||||||
|
|
||||||
|
<!-- Keep this comment at the end of the file
|
||||||
|
Local variables:
|
||||||
|
mode: sgml
|
||||||
|
sgml-omittag:t
|
||||||
|
sgml-shorttag:t
|
||||||
|
sgml-minimize-attributes:nil
|
||||||
|
sgml-always-quote-attributes:t
|
||||||
|
sgml-indent-step:1
|
||||||
|
sgml-indent-data:t
|
||||||
|
indent-tabs-mode:nil
|
||||||
|
sgml-parent-document:nil
|
||||||
|
sgml-default-dtd-file:"../../../../manual.ced"
|
||||||
|
sgml-exposed-tags:nil
|
||||||
|
sgml-local-catalogs:nil
|
||||||
|
sgml-local-ecat-files:nil
|
||||||
|
End:
|
||||||
|
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||||
|
vim: et tw=78 syn=sgml
|
||||||
|
vi: ts=1 sw=1
|
||||||
|
-->
|
||||||
426
docs/de/getting-started.xml
Normal file
426
docs/de/getting-started.xml
Normal file
@@ -0,0 +1,426 @@
|
|||||||
|
<!-- Smarty German Documentation Port -->
|
||||||
|
<!-- $Id$ -->
|
||||||
|
<!-- $Author$ -->
|
||||||
|
<!-- $Revision$ -->
|
||||||
|
<part id="getting.started">
|
||||||
|
<title>Erste Schritte</title>
|
||||||
|
<chapter id="what.is.smarty">
|
||||||
|
<title>Was ist Smarty?</title>
|
||||||
|
<para>
|
||||||
|
Smarty ist eine Template-Engine für PHP. Genauer gesagt erlaubt es
|
||||||
|
die einfache Trennung von Applikations-Logik und Design/Ausgabe. Dies
|
||||||
|
ist vor allem wünschenswert, wenn der Applikationsentwickler nicht
|
||||||
|
die selbe Person ist wie der Designer. Nehmen wir zum Beispiel eine
|
||||||
|
Webseite die Zeitungsartikel ausgibt. Der Titel, die Einführung,
|
||||||
|
der Author und der Inhalt selbst enthalten keine Informationen darüber
|
||||||
|
wie sie dargestellt werden sollen. Also werden sie von der Applikation
|
||||||
|
an Smarty übergeben, damit der Designer in den Templates mit einer Kombination von
|
||||||
|
HTML- und Template-Tags die Ausgabe (Tabellen, Hintergrundfarben,
|
||||||
|
Schriftgrössen, Stylesheets, etc.) gestalten kann. Falls nun die
|
||||||
|
Applikation eines Tages angepasst werden muss, ist dies für den
|
||||||
|
Designer nicht von Belang, da die Inhalte immer noch genau gleich
|
||||||
|
übergeben werden. Genauso kann der Designer die Ausgabe der
|
||||||
|
Daten beliebig verändern, ohne dass eine Änderung der
|
||||||
|
Applikation vorgenommen werden muss. Somit k<>nnen der Programmierer
|
||||||
|
die Applikations-Logik und der Designer die Ausgabe frei anpassen,
|
||||||
|
ohne sich dabei in die Quere zu kommen.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Was Smarty nicht kann: Smarty versucht nicht die gesamte Logik aus dem
|
||||||
|
Template zu verbannen. Solange die verwendete Logik ausschlie<69>lich für die
|
||||||
|
Ausgabe verwendet wird, kann sie auch im Template eingebettet werden. Ein Tip:
|
||||||
|
versuchen Sie Applikations-Logik aus dem Template und Präsentations-Logik
|
||||||
|
aus der Applikation herauszuhalten. Nur so bleibt die Applikation auf absehbere Zeit
|
||||||
|
gut skalier- und wartbar.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Einer der einzigartigen Aspekte von Smarty ist die Kompilierung der
|
||||||
|
Templates. Smarty liest die Template-Dateien und generiert daraus neue
|
||||||
|
PHP-Skripte; von da an werden nur noch diese Skripte verwendet. Deshalb
|
||||||
|
müssen Templates nicht für jeden Seitenaufruf performance-intensiv
|
||||||
|
neu geparst werden und jedes Template kann voll von PHP Compiler-Cache
|
||||||
|
Lösungen profitieren.
|
||||||
|
(Zend, http://www.zend.com; PHP Accelerator, http://www.php-accelerator.co.uk)
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Ein paar Smarty Charakteristiken
|
||||||
|
</para>
|
||||||
|
<itemizedlist>
|
||||||
|
<listitem><para>Sehr schnell.</para></listitem>
|
||||||
|
<listitem><para>Sehr effizient, da der PHP-Parser die 'schmutzige' Arbeit übernimmt.</para></listitem>
|
||||||
|
<listitem><para>Kein Overhead durch Template-Parsing, nur einmaliges kompilieren.</para></listitem>
|
||||||
|
<listitem><para>Re-kompiliert nur gänderte Templates.</para></listitem>
|
||||||
|
<listitem><para>Sie können die Engine um <link linkend="language.custom.functions">individuelle Funktionen</link> und <link linkend="language.modifiers">Variablen-Modifikatoren</link> erweitern.</para></listitem>
|
||||||
|
<listitem><para>Konfigurierbare Syntax f<>r Template-Tags: Sie können {}, {{}}, <!--{}-->, etc. verwenden.</para></listitem>
|
||||||
|
<listitem><para>'if/elseif/else/endif'-Konstrukte werden direkt dem PHP-Parser übergeben. Somit können {if ...} Ausdr<64>cke sowohl sehr einfach als auch sehr komplex sein.</para></listitem>
|
||||||
|
<listitem><para>Unbegrenzte Verschachtelung von 'section', 'if' und anderen Blöcken.</para></listitem>
|
||||||
|
<listitem><para>Ermöglicht die direkte Einbettung von PHP-Code. (Obwohl es weder benötigt noch empfohlen wird, da die Engine einfach erweiterbar ist.)</para></listitem>
|
||||||
|
<listitem><para>Eingebauter Caching-Support</para></listitem>
|
||||||
|
<listitem><para>Beliebige Template-Quellen</para></listitem>
|
||||||
|
<listitem><para>Eigene Cache-Handling Funktionen</para></listitem>
|
||||||
|
<listitem><para>Plugin Architektur</para></listitem>
|
||||||
|
</itemizedlist>
|
||||||
|
</chapter>
|
||||||
|
<chapter id="installation">
|
||||||
|
<title>Installation</title>
|
||||||
|
<sect1 id="installation.requirements">
|
||||||
|
<title>Anforderungen</title>
|
||||||
|
<para>
|
||||||
|
Smarty benötigt einen Webserver mit PHP >=4.0.6.
|
||||||
|
</para>
|
||||||
|
</sect1>
|
||||||
|
|
||||||
|
<sect1 id="installing.smarty.basic">
|
||||||
|
<title>Basis Installation</title>
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
Dieser Leitfaden geht davon aus, dass Sie Ihr Webserver- und PHP-Setup kennen
|
||||||
|
und mit den Namenskonventionen für Dateien und Verzeichnisse Ihres Betriebssystems
|
||||||
|
vertraut sind. Im Folgenden wird ein Unix-Dateisystem verwendet, stellen Sie also
|
||||||
|
sicher, dass sie die für Ihr Betriebssystem nötigen Änderungen vornehmen.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Das Beispiel geht davon aus, dass '/php/includes' in Ihrem PHP-'include_path'
|
||||||
|
liegt. Konsultieren Sie das PHP-Manual für weiterführende Informationen hierzu.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
<para>
|
||||||
|
Installieren Sie als erstes die Smarty-Library Dateien. Diese Dateien
|
||||||
|
sollten von Ihnen NICHT editiert und von allen Applikationen
|
||||||
|
verwendet werden. Sie werden nur erneuert, wenn Sie eine neue Version von Smarty installieren.
|
||||||
|
</para>
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
Wir empfehlen keine Änderungen an den Smarty-Library Dateien vorzunehmen.
|
||||||
|
Dies macht ein mögliches Upgrade wesentlich einfacher. Sie müssen
|
||||||
|
diese Dateien auch nicht anpassen, um Smarty zu konfigurieren! Benutzen Sie f<>r
|
||||||
|
diesen Zwecke eine Instanz der Smarty-Klasse.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Folgende Library Dateien werden mit Smarty geliefert und werden benötigt:
|
||||||
|
</para>
|
||||||
|
<example>
|
||||||
|
<title>Smarty-Library Dateiliste</title>
|
||||||
|
<screen>
|
||||||
|
Smarty.class.php
|
||||||
|
Smarty_Compiler.class.php
|
||||||
|
Config_File.class.php
|
||||||
|
debug.tpl
|
||||||
|
/core/*.php (alle)
|
||||||
|
/plugins/*.php (alle)</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Sie können diese Dateien entweder in Ihrem PHP-'include_path' oder
|
||||||
|
auch in irgend einem anderen Verzeichnis ablegen, solange die Konstante
|
||||||
|
<link linkend="constant.smarty.dir">SMARTY_DIR</link> auf den korrekten
|
||||||
|
Pfad zeigt. Im Folgenden werden Beispiele für beide Fälle aufgezeigt.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
So erzeugt man eine Instanz der Smarty-Klasse im PHP-Skript:
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Smarty Instanz erstellen:</title>
|
||||||
|
<screen>
|
||||||
|
require('Smarty.class.php');
|
||||||
|
$smarty = new Smarty;</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Versuchen Sie das Skript auszuführen. Wenn Sie eine Fehlermeldung erhalten dass
|
||||||
|
<emphasis>Smarty.class.php</emphasis> nicht gefunden werden konnte, versuchen Sie folgendes:
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Absoluter Pfad übergeben</title>
|
||||||
|
<screen>
|
||||||
|
require('/usr/local/lib/php/Smarty/Smarty.class.php');
|
||||||
|
$smarty = new Smarty;</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Library Verzeichnis dem Include-Pfad hinzufügen</title>
|
||||||
|
<screen>
|
||||||
|
// editieren Sie php.ini, fügen Sie das Smarty
|
||||||
|
// Verzeichnis Ihrem include_path hinzu, und starten Sie den Webserver neu
|
||||||
|
// Danach sollte folgendes Funktionieren.
|
||||||
|
require('Smarty.class.php');
|
||||||
|
$smarty = new Smarty;</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>SMARTY_DIR manuell setzen</title>
|
||||||
|
<screen>
|
||||||
|
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
|
||||||
|
require(SMARTY_DIR.'Smarty.class.php');
|
||||||
|
$smarty = new Smarty;</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Jetzt, wo die Library Dateien an ihrem Platz sind, wird es
|
||||||
|
Zeit, die Smarty Verzeichnisse zu erstellen.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Für unser Beispiel werden wir die Smarty Umgebung für eine
|
||||||
|
Gästebuch-Applikation konfigurieren. Wir verwenden den Applikationsnamen
|
||||||
|
nur, um die Verzeichnis-Struktur zu verdeutlichen. Sie können die selbe
|
||||||
|
Umgebung für alle Ihre Applikationen verwenden indem Sie 'guestbook'
|
||||||
|
durch dem Namen Ihrer Applikation ersetzen.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Stellen Sie sicher, dass Sie die DocumentRoot Ihres Webservers kennen.
|
||||||
|
In unserem Beispiel lautet sie '/web/www.domain.com/docs/'.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Die Smarty Verzeichnisse werden in den Klassen-Variablen $template_dir,
|
||||||
|
$compile_dir, $config_dir und $cache_dir definiert. Die Standardwerte sind:
|
||||||
|
"templates", "templates_c", "configs" und "cache". Für unser Beispiel
|
||||||
|
legen wir alle diese Verzeichnisse unter '/web/www.domain.com/smarty/guestbook/' an.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
Wir empfehlen, diese Verzeichnisse ausserhalb der DocumentRoot anzulegen,
|
||||||
|
um mögliche Direktzugriffe zu verhindern.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
In Ihrer DocumentRoot muss mindestens eine Datei liegen, die für Browser
|
||||||
|
zugänglich ist. Wir nennen dieses Skript 'index.php', und legen
|
||||||
|
es in das Verzeichnis '/guestbook/' in unserer DocumentRoot.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
Bequem ist es, den Webserver so zu konfigurieren, dass 'index.php' als
|
||||||
|
Standard-Verzeichnis-Index verwendet wird. Somit kann man das Skript
|
||||||
|
direkt mit 'http://www.domain.com/guestbook/' aufrufen. Falls Sie Apache
|
||||||
|
verwenden, lässt sich dies konfigurieren indem Sie 'index.php'
|
||||||
|
als letzten Eintrag für DirectoryIndex verwenden. (Jeder Eintrag muss
|
||||||
|
mit einem Leerzeichen abgetrennt werden).
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Die Dateistruktur bis jetzt:
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Beispiel der Dateistruktur</title>
|
||||||
|
<screen>
|
||||||
|
/usr/local/lib/php/Smarty/Smarty.class.php
|
||||||
|
/usr/local/lib/php/Smarty/Smarty_Compiler.class.php
|
||||||
|
/usr/local/lib/php/Smarty/Config_File.class.php
|
||||||
|
/usr/local/lib/php/Smarty/debug.tpl
|
||||||
|
/usr/local/lib/php/Smarty/plugins/*.php
|
||||||
|
/usr/local/lib/php/Smarty/core/*.php
|
||||||
|
|
||||||
|
/web/www.mydomain.com/smarty/guestbook/templates/
|
||||||
|
/web/www.mydomain.com/smarty/guestbook/templates_c/
|
||||||
|
/web/www.mydomain.com/smarty/guestbook/configs/
|
||||||
|
/web/www.mydomain.com/smarty/guestbook/cache/
|
||||||
|
|
||||||
|
/web/www.mydomain.com/docs/guestbook/index.php</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
Falls Sie kein Caching und keine Konfigurationsdateien verwenden, ist es nicht
|
||||||
|
erforderlich die Verzeichnisse '$config_dir' und '$cache_dir' zu erstellen.
|
||||||
|
Es wird jedoch trotzdem empfohlen, da diese Funktionalitäten eventuell später
|
||||||
|
genutzt werden sollen.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Smarty benötigt Schreibzugriff auf die Verzeichnisse '$compile_dir' und '$cache_dir'.
|
||||||
|
Stellen Sie also sicher, dass der Webserver-Benutzer (normalerweise Benutzer 'nobody' und Gruppe 'nogroup')
|
||||||
|
in diese Verzeichnisse schreiben kann. (In OS X lautet der Benutzer normalerweise 'www' und
|
||||||
|
ist in der Gruppe 'www'). Wenn Sie Apache verwenden, können Sie in der httpd.conf (gew<65>hnlich in '/usr/local/apache/conf/')
|
||||||
|
nachsehen, unter welchem Benutzer Ihr Server läuft.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Dateirechte einrichten</title>
|
||||||
|
<screen>
|
||||||
|
|
||||||
|
chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/templates_c/
|
||||||
|
chmod 770 /web/www.mydomain.com/smarty/guestbook/templates_c/
|
||||||
|
|
||||||
|
chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/cache/
|
||||||
|
chmod 770 /web/www.mydomain.com/smarty/guestbook/cache/</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
'chmod 770' setzt ziemlich strenge Rechte und erlaubt nur dem Benutzer 'nobody'
|
||||||
|
und der Gruppe 'nobody' Lese-/Schreibzugriff auf diese Verzeichnisse. Falls Sie
|
||||||
|
die Rechte so setzen möchten, dass auch andere Benutzer die Dateien lesen
|
||||||
|
können (vor allem für Ihren eigenen Komfort), so erreichen Sie dies mit 775.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Nun müssen wir die 'index.tpl' Datei erstellen, welche Smarty laden soll.
|
||||||
|
Die Datei wird in Ihrem '$template_dir' abgelegt.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Editieren von /web/www.mydomain.com/smarty/guestbook/templates/index.tpl</title>
|
||||||
|
<screen>
|
||||||
|
|
||||||
|
{* Smarty *}
|
||||||
|
|
||||||
|
Hallo, {$name}!</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
{* Smarty *} ist ein Template-Kommentar. Der wird zwar nicht benötigt,
|
||||||
|
es ist jedoch eine gute Idee jedes Template mit einem Kommentar zu versehen.
|
||||||
|
Dies erleichtert die Erkennbarkeit des Templates, unabhängig von der
|
||||||
|
verwendeten Dateierweiterung. (Zum Beispiel für Editoren die Syntax-Highlighting
|
||||||
|
unterstützen.)
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Als nächstes editieren wir die Datei 'index.php'. Wir erzeugen eine
|
||||||
|
Smarty-Instanz, weisen dem Template eine Variable zu und geben 'index.tpl' aus.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Editieren von /web/www.mydomain.com/docs/guestbook/index.php</title>
|
||||||
|
<screen>
|
||||||
|
|
||||||
|
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
|
||||||
|
require(SMARTY_DIR.'Smarty.class.php');
|
||||||
|
|
||||||
|
$smarty = new Smarty;
|
||||||
|
|
||||||
|
$smarty->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
|
||||||
|
$smarty->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
|
||||||
|
$smarty->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
|
||||||
|
$smarty->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/';
|
||||||
|
|
||||||
|
$smarty->assign('name','Ned');
|
||||||
|
|
||||||
|
$smarty->display('index.tpl');</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
In unserem Beispiel verwenden wir durchwegs absolute Pfadnamen zu den
|
||||||
|
Smarty-Verzeichnissen. Falls '/web/www.mydomain.com/smarty/guestbook/' in
|
||||||
|
Ihrem PHP-'include_path' liegt, wäre dies nicht nötig. Es ist jedoch
|
||||||
|
effizienter und weniger fehleranfällig die Pfade absolut zu setzen.
|
||||||
|
Und es garantiert, dass Smarty die Templates aus dem geplanten Verzeichnis lädt.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Wenn Sie 'index.php' nun in Ihrem Webbrowser öffnen, sollte 'Hallo, Ned!' ausgegeben werden.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Die Basis-Installation von Smarty wäre somit beendet.
|
||||||
|
</para>
|
||||||
|
</sect1>
|
||||||
|
<sect1 id="installing.smarty.extended">
|
||||||
|
<title>Erweiterte Konfiguration</title>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
|
||||||
|
Dies ist eine Weiterführung der <link linkend="installing.smarty.basic">Basis Installation</link>, bitte lesen Sie diese zuerst!
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Ein flexiblerer Weg um Smarty aufzusetzen ist, die Klasse zu erweitern und
|
||||||
|
eine eigene Smarty-Umgebung zu initialisieren. Anstatt immer wieder
|
||||||
|
die Verzeichnisse zu definieren, kann diese Aufgabe auch in einer einzigen
|
||||||
|
Datei erledigt werden. Beginnen wir, indem wir ein neues Verzeichnis namens '/php/includes/guestbook/'
|
||||||
|
erstellen und eine Datei namens 'setup.php' darin anlegen.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Editieren von /php/includes/guestbook/setup.php</title>
|
||||||
|
<screen>
|
||||||
|
|
||||||
|
// Smarty Library Dateien laden
|
||||||
|
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
|
||||||
|
require(SMARTY_DIR.'Smarty.class.php');
|
||||||
|
|
||||||
|
// ein guter Platz um Applikations spezifische Libraries zu laden
|
||||||
|
// require('guestbook/guestbook.lib.php');
|
||||||
|
|
||||||
|
class Smarty_GuestBook extends Smarty {
|
||||||
|
|
||||||
|
function Smarty_GuestBook() {
|
||||||
|
|
||||||
|
|
||||||
|
// Konstruktor. Diese Werte werden für jede Instanz automatisch gesetzt
|
||||||
|
|
||||||
|
$this->Smarty();
|
||||||
|
|
||||||
|
$this->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
|
||||||
|
$this->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
|
||||||
|
$this->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
|
||||||
|
$this->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/';
|
||||||
|
|
||||||
|
$this->caching = true;
|
||||||
|
$this->assign('app_name','Guest Book');
|
||||||
|
}
|
||||||
|
|
||||||
|
}</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<note>
|
||||||
|
<title>Technische Bemerkung</title>
|
||||||
|
<para>
|
||||||
|
In unserem Beispiel werden die Library Dateien ausserhalb der DocumentRoot
|
||||||
|
abgelegt. Diese Dateien könnten sensitive Informationen enthalten,
|
||||||
|
die wir nicht zugänglich machen möchten.
|
||||||
|
Deshalb legen wir alle Library Dateien in '/php/includes/guestbook/' ab
|
||||||
|
und laden sie in unserem 'setup.php' Skript, wie Sie im oben gezeigten
|
||||||
|
Beispiel sehen können.
|
||||||
|
</para>
|
||||||
|
</note>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Nun passen wir 'index.php' an, um 'setup.php' zu verwenden:
|
||||||
|
</para>
|
||||||
|
|
||||||
|
<example>
|
||||||
|
<title>Editieren von /web/www.mydomain.com/docs/guestbook/index.php</title>
|
||||||
|
<screen>
|
||||||
|
|
||||||
|
require('guestbook/setup.php');
|
||||||
|
|
||||||
|
$smarty = new Smarty_GuestBook;
|
||||||
|
|
||||||
|
$smarty->assign('name','Ned');
|
||||||
|
|
||||||
|
$smarty->display('index.tpl');</screen>
|
||||||
|
</example>
|
||||||
|
|
||||||
|
<para>
|
||||||
|
Wie Sie sehen können, ist es sehr einfach eine Instanz von Smarty zu erstellen.
|
||||||
|
Mit Hilfe von Smarty_GuestBook werden alle Variablen automatisch initialisiert.
|
||||||
|
</para>
|
||||||
|
|
||||||
|
</sect1>
|
||||||
|
|
||||||
|
</chapter>
|
||||||
|
</part>
|
||||||
6
docs/de/language-defs.ent
Normal file
6
docs/de/language-defs.ent
Normal file
@@ -0,0 +1,6 @@
|
|||||||
|
<!-- $Revision$ -->
|
||||||
|
|
||||||
|
<!ENTITY SMARTYManual "Smarty - die kompilierende PHP Template-Engine">
|
||||||
|
<!ENTITY SMARTYDesigners "Smarty für Template Designer">
|
||||||
|
<!ENTITY SMARTYProgrammers "Smarty für Programmierer">
|
||||||
|
<!ENTITY Appendixes "Anhänge">
|
||||||
73
docs/de/preface.xml
Normal file
73
docs/de/preface.xml
Normal file
@@ -0,0 +1,73 @@
|
|||||||
|
<!-- Smarty German Documentation Port -->
|
||||||
|
<!-- $Id$ -->
|
||||||
|
<!-- $Author$ -->
|
||||||
|
<!-- $Revision$ -->
|
||||||
|
|
||||||
|
<preface id="preface">
|
||||||
|
<title>Vorwort</title>
|
||||||
|
<para>
|
||||||
|
Die Frage, wie man die Applikations-Logik eines PHP-Scriptes vom Layout trennt, ist unzweifelhaft
|
||||||
|
eines der am häfigsten diskutierten Themen. Da PHP als
|
||||||
|
"in HTML eingebettete Scripting-Sprache" angepriesen wird, ergibt sich
|
||||||
|
nach einigen Projekten in denen man HTML und PHP gemischt hat schnell die Idee,
|
||||||
|
Funktionalität und Darstellung zu trennen. Dazu kommt, dass in vielen Firmen Applikationsentwickler
|
||||||
|
und Designer nicht die selbe Person sind. In Konsequenz beginnt die Suche nach einer Template-L<>sung.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Als Beispiel: In unserer Firma funktioniert die Entwicklung einer Applikation
|
||||||
|
wie folgt: Nachdem die Spezifikationen erstellt sind, entwickelt der
|
||||||
|
Interface Designer einen Prototypen des Interfaces und übergibt dieses
|
||||||
|
dem Programmierer. Der Programmierer implementiert die Geschäftslogik
|
||||||
|
in PHP und verwendet den Interface-Prototypen zur Erstellung eines Template-Skeletts.
|
||||||
|
Danach übergibt der Programmierer die Templates dem HTML/Webseiten-Designer
|
||||||
|
welcher ihnen den letzten Schliff verleiht. Das Projekt kann mehrfach zwischen
|
||||||
|
dem Programmieren und dem Designer ausgetauscht werden. Deshalb ist es wichtig,
|
||||||
|
dass die Trennung von Logik und Design klar stattfindet. Der Programmierer will
|
||||||
|
sich normalerweise nicht mit HTML herumschlagen müssen und möchte auch
|
||||||
|
nicht, dass der Designer seinen PHP-Code verändert. Designer selbst
|
||||||
|
benötigen Konfigurationsdateien, dynamische Blöcke und andere Interface spezifische
|
||||||
|
Eigenheiten, möchten aber auch nicht direkt mit PHP in Berührung kommen.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Die meisten Template-Engines die heutzutage angeboten werden, bieten eine
|
||||||
|
rudimentäre Möglichkeit Variablen in einem Template zu ersetzen
|
||||||
|
und beherschen eine eingeschränkte Funktionalität für dynamische
|
||||||
|
Blöcke. Unsere Anforderungen forderten jedoch ein wenig mehr. Wir wollten
|
||||||
|
erreichen, dass sich Programmierer überhaupt nicht um HTML Layouts
|
||||||
|
kümmern müssen. Dies war aber fast unumgänglich. Wenn ein
|
||||||
|
Designer zum Beispiel alternierende Farben in einer Tabelle einsetzen wollte,
|
||||||
|
musste dies vorhergehend mit dem Programmierer abgesprochen werden. Wir wollten
|
||||||
|
weiter, dass dem Designer Konfigurationsdateien zur Verfügung stünden,
|
||||||
|
aus denen er Variablen für seine Templates extrahieren kann. Die Liste ist endlos.
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Wir begannen 1999 mit der Spezifikation der Template Engine. Nachdem dies
|
||||||
|
erledigt war, fingen wir an eine Engine in C zu schreiben, die - so hofften
|
||||||
|
wir - in PHP eingebaut würde. Nach einer hitzigen Debatte darüber
|
||||||
|
was eine Template Engine können sollte und was nicht, und nachdem wir feststellen
|
||||||
|
mussten, dass ein paar komplizierte technische Probleme auf uns zukommen
|
||||||
|
würden, entschlossen wir uns die Template Engine in PHP als Klasse
|
||||||
|
zu realisieren, damit sie von jederman verwendet und angepasst werden kann.
|
||||||
|
So schrieben wir also eine Engine, die wir <productname>SmartTemplate</productname>
|
||||||
|
nannten (anm: diese Klasse wurde nie veröffentlicht). SmartTemplate
|
||||||
|
erlaubte uns praktisch alles zu tun was wir uns vorgenommen hatten: normale
|
||||||
|
Variablen-Ersetzung, Möglichkeiten weitere Templates einzubinden,
|
||||||
|
Integration von Konfigurationsdateien, Einbetten von PHP-Code, limitierte 'if'-Funktionalität
|
||||||
|
und eine sehr robuste Implementation von dynamischen Blöcken die
|
||||||
|
mehrfach verschachtelt werden konnten. All dies wurde mit Regulären Ausdrücken
|
||||||
|
erledigt und der Sourcecode wurde ziemlich unübersichtlich. Für grössere
|
||||||
|
Applikationen war die Klasse auch bemerkenswert langsam, da das Parsing bei jedem
|
||||||
|
Aufruf einer Seite durchlaufen werden musste. Das grösste Problem aber war,
|
||||||
|
dass der Programmierer das Setup, die Templates und dynamische Blöcke in seinem
|
||||||
|
PHP-Skript definieren musste. Die nächste Frage war: wie können wir dies
|
||||||
|
weiter vereinfachen?
|
||||||
|
</para>
|
||||||
|
<para>
|
||||||
|
Dann kam uns die Idee, aus der schlie<69>lich Smarty wurde. Wir wussten
|
||||||
|
wie schnell PHP-Code ohne den Overhead des Template-Parsing ist. Wir wussten
|
||||||
|
ebenfalls wie pedantisch PHP aus Sicht eines durchschnittlichen
|
||||||
|
Designers ist und dass dies mit einer einfacheren Template-Syntax
|
||||||
|
verborgen werden kann. Was wäre also, wenn wir diese
|
||||||
|
beiden Stärken vereinten? Smarty war geboren...
|
||||||
|
</para>
|
||||||
|
</preface>
|
||||||
Reference in New Issue
Block a user