mirror of
https://github.com/smarty-php/smarty.git
synced 2025-08-07 03:44:26 +02:00
german docs: change fileencoding from iso-8859-1 to utf-8
This commit is contained in:
@@ -8,12 +8,12 @@
|
||||
<sect1 id="tips.blank.var.handling">
|
||||
<title>Handhabung unangewiesener Variablen</title>
|
||||
<para>
|
||||
Manchmal m<EFBFBD>chten Sie vielleicht, dass anstatt einer Leerstelle ein
|
||||
Manchmal möchten Sie vielleicht, dass anstatt einer Leerstelle ein
|
||||
Standardwert ausgegeben wird - zum Beispiel um im
|
||||
Tabellenhintergrund "&nbsp;" auszugeben, damit er korrekt
|
||||
angezeigt wird. Damit daf<EFBFBD>r keine <link
|
||||
angezeigt wird. Damit dafür keine <link
|
||||
linkend="language.function.if">{if}</link> Anweisung verwendet
|
||||
werden muss, gibt es in Smarty eine Abk<EFBFBD>rzung: die Verwendung des
|
||||
werden muss, gibt es in Smarty eine Abkürzung: die Verwendung des
|
||||
<emphasis>default</emphasis> Variablen-Modifikators.
|
||||
</para>
|
||||
<example>
|
||||
@@ -28,7 +28,7 @@
|
||||
{/if}
|
||||
|
||||
|
||||
{* k<EFBFBD>rzer: *}
|
||||
{* kürzer: *}
|
||||
{$titel|default:" "}
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -44,10 +44,10 @@
|
||||
<sect1 id="tips.default.var.handling">
|
||||
<title>Handhabung von Standardwerten</title>
|
||||
<para>
|
||||
Wenn eine Variable in einem Template h<EFBFBD>ufig zum Einsatz kommt,
|
||||
kann es ein bisschen st<EFBFBD>rend wirken, den <link
|
||||
Wenn eine Variable in einem Template häufig zum Einsatz kommt,
|
||||
kann es ein bisschen störend wirken, den <link
|
||||
linkend="language.modifier.default"><emphasis>default</emphasis></link>-Modifikator
|
||||
jedes mal anzuwenden. Sie k<EFBFBD>nnen dies umgehen, indem Sie der
|
||||
jedes mal anzuwenden. Sie können dies umgehen, indem Sie der
|
||||
Variable mit der <link
|
||||
linkend="language.function.assign">{assign}</link> Funktion einen
|
||||
Standardwert zuweisen.
|
||||
@@ -59,7 +59,7 @@
|
||||
{* schreiben sie dieses statement an den Anfang des Templates *}
|
||||
{assign var="titel" value=$titel|default:"kein Titel"}
|
||||
|
||||
{* falls 'titel' bei der Anweisung leer war, enth<EFBFBD>lt es nun den Wert
|
||||
{* falls 'titel' bei der Anweisung leer war, enthält es nun den Wert
|
||||
'kein Titel' wenn Sie es ausgeben *}
|
||||
{$titel}
|
||||
]]>
|
||||
@@ -81,17 +81,17 @@
|
||||
bindet diese mit<link
|
||||
linkend="language.function.include">{include}</link> ein. Was
|
||||
geschieht aber wenn der Header einen seitenspezifischen Titel
|
||||
haben soll? Smarty bietet die M<EFBFBD>glichkeit, dem eingebundenen
|
||||
haben soll? Smarty bietet die Möglichkeit, dem eingebundenen
|
||||
Template, Variablen als <link
|
||||
linkend="language.syntax.attributes">Attribute</link> zu
|
||||
<EFBFBD>bergeben.
|
||||
übergeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>Die Titel-Variable dem Header-Template zuweisen</title>
|
||||
<para>
|
||||
<filename>mainpage.tpl</filename> - Beim Aufbau der Hauptseite
|
||||
wird der Titel "Hauptseite" an <filename>header.tpl</filename>
|
||||
<EFBFBD>bergeben und dort verwendet.
|
||||
übergeben und dort verwendet.
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
@@ -114,7 +114,7 @@
|
||||
</programlisting>
|
||||
<para>
|
||||
<filename>header.tpl</filename> - Zur Info: wenn kein $titel
|
||||
<EFBFBD>bergeben wurde wird hier mittels des <link
|
||||
übergeben wurde wird hier mittels des <link
|
||||
linkend="language.modifier.default">default</link>-Modifikator der
|
||||
Titel "Nachrichten" verwendet.
|
||||
</para>
|
||||
@@ -141,17 +141,17 @@
|
||||
<sect1 id="tips.dates">
|
||||
<title>Zeitangaben</title>
|
||||
<para>
|
||||
Um dem Template Designer h<EFBFBD>chstm<EFBFBD>gliche Kontrolle <EFBFBD>ber die Ausgabe
|
||||
von Zeitangaben/Daten zu erm<EFBFBD>glichen, ist es empfehlenswert Daten
|
||||
Um dem Template Designer höchstmögliche Kontrolle über die Ausgabe
|
||||
von Zeitangaben/Daten zu ermöglichen, ist es empfehlenswert Daten
|
||||
immer als <ulink url="&url.php-manual;time">Timestamp</ulink> zu
|
||||
<EFBFBD>bergeben. Der Designer kann danach die Funktion <link
|
||||
linkend="language.modifier.date.format">date_format</link> f<EFBFBD>r die
|
||||
übergeben. Der Designer kann danach die Funktion <link
|
||||
linkend="language.modifier.date.format">date_format</link> für die
|
||||
Formatierung verwenden.
|
||||
</para>
|
||||
<para>
|
||||
Bemerkung: Seit Smarty 1.4.0 ist es m<EFBFBD>glich jede Timestamp zu
|
||||
<EFBFBD>bergeben, welche mit strtotime() ausgewertet werden kann. Dazu
|
||||
geh<EFBFBD>ren Unix-Timestamps und MySQL-Timestamps.
|
||||
Bemerkung: Seit Smarty 1.4.0 ist es möglich jede Timestamp zu
|
||||
übergeben, welche mit strtotime() ausgewertet werden kann. Dazu
|
||||
gehören Unix-Timestamps und MySQL-Timestamps.
|
||||
</para>
|
||||
<example>
|
||||
<title>Die Verwendung von date_format</title>
|
||||
@@ -193,8 +193,8 @@ AUSGABE:
|
||||
Falls <link
|
||||
linkend="language.function.html.select.date">{html_select_date}</link>
|
||||
in einem Template verwendet wird, hat der Programmierer die
|
||||
M<EFBFBD>glichkeit den Wert wieder in ein Timestamp-Format zu
|
||||
<EFBFBD>ndern. Dies kann zum Beispiel wie folgt gemacht werden:
|
||||
Möglichkeit den Wert wieder in ein Timestamp-Format zu
|
||||
ändern. Dies kann zum Beispiel wie folgt gemacht werden:
|
||||
</para>
|
||||
<example>
|
||||
<title>Formular Datum-Elemente nach Timestamp konvertieren</title>
|
||||
@@ -236,10 +236,10 @@ function makeTimeStamp($year="",$month="",$day="")
|
||||
<title>WAP/WML</title>
|
||||
<para>
|
||||
WAP/WML Templates verlangen, dass ein Content-Type Header im
|
||||
Template angegeben wird. Der einfachste Weg um dies zu tun, w<EFBFBD>re,
|
||||
Template angegeben wird. Der einfachste Weg um dies zu tun, wäre,
|
||||
eine Funktion zu schreiben, welche den Header ausgibt. Falls sie
|
||||
den Caching Mechanismus verwenden, sollten Sie auf das
|
||||
'insert'-Tag zur<EFBFBD>ckgreifen ('insert'-Tags werden nicht gecached),
|
||||
'insert'-Tag zurückgreifen ('insert'-Tags werden nicht gecached),
|
||||
um ein optimales Ergebnis zu erzielen. Achten Sie darauf, dass vor
|
||||
der Ausgabe des Headers keine Daten an den Client gesendet werden,
|
||||
da die gesendeten Header-Daten ansonsten von Client verworfen
|
||||
@@ -309,24 +309,24 @@ function insert_header($params)
|
||||
Instanz von Smarty, weisen die Variablen mit <link
|
||||
linkend="api.assign">assign()</link> zu und geben das Template mit
|
||||
<link linkend="api.display">display()</link> aus. Wenn wir also
|
||||
zum Beispiel einen B<EFBFBD>rsenticker in unserem Template haben, stellen
|
||||
zum Beispiel einen Börsenticker in unserem Template haben, stellen
|
||||
wir die Kursinformationen in unserer Anwendung zusammen, weisen
|
||||
Sie dem Template zu und geben es aus. W<EFBFBD>re es jedoch nicht nett
|
||||
diesen B<EFBFBD>rsenticker einfach in ein Template einer anderen
|
||||
Applikation einbinden zu k<EFBFBD>nnen ohne deren Programmcode zu <EFBFBD>ndern?
|
||||
Sie dem Template zu und geben es aus. Wäre es jedoch nicht nett
|
||||
diesen Börsenticker einfach in ein Template einer anderen
|
||||
Applikation einbinden zu können ohne deren Programmcode zu ändern?
|
||||
</para>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen PHP-Code mit {php}{/php} in Ihre Templates einbetten.
|
||||
So k<EFBFBD>nnen Sie Templates erstellen, welche die Datenstrukturen zur
|
||||
Sie können PHP-Code mit {php}{/php} in Ihre Templates einbetten.
|
||||
So können Sie Templates erstellen, welche die Datenstrukturen zur
|
||||
Anweisung der eigenen Variablen enthalten. Durch die Bindung von
|
||||
Template und Logik entsteht so eine eigenst<EFBFBD>ndig lauff<EFBFBD>hige
|
||||
Template und Logik entsteht so eine eigenständig lauffähige
|
||||
Komponente.
|
||||
</para>
|
||||
<example>
|
||||
<title>Template/Script Komponenten</title>
|
||||
<para>
|
||||
<filename>function.load_ticker.php</filename> -
|
||||
Diese Datei geh<EFBFBD>rt ins <link
|
||||
Diese Datei gehört ins <link
|
||||
linkend="variable.plugins.dir">$plugins directory</link>
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
@@ -369,8 +369,8 @@ Stock Name: {$ticker.name} Stock Price: {$ticker.price}
|
||||
<para>
|
||||
Haben Sie sich auch schon gewundert, wie Ihre E-mail Adresse auf
|
||||
so viele Spam-Mailinglisten kommt? Ein Weg, wie Spammer E-mail
|
||||
Adressen sammeln, ist <EFBFBD>ber Webseiten. Um dieses Problem zu
|
||||
bek<EFBFBD>mpfen, k<EFBFBD>nnen sie den 'mailto'-Plugin verwenden. Er <EFBFBD>ndert
|
||||
Adressen sammeln, ist über Webseiten. Um dieses Problem zu
|
||||
bekämpfen, können sie den 'mailto'-Plugin verwenden. Er ändert
|
||||
die Zeichenfolge mit Javascript so, dass sie im HTML Quellcode
|
||||
nicht lesbar ist, jedoch von jedem Browser wieder zusammengesetzt
|
||||
werden kann. Den <link
|
||||
@@ -392,8 +392,8 @@ senden
|
||||
<title>Technische Details</title>
|
||||
<para>
|
||||
Die Codierung mit Javascript ist nicht sehr sicher, da ein
|
||||
m<EFBFBD>glicher Spammer die Decodierung in sein Sammelprogramm
|
||||
einbauen k<EFBFBD>nnte. Es wird jedoch damit gerechnet, dass, da
|
||||
möglicher Spammer die Decodierung in sein Sammelprogramm
|
||||
einbauen könnte. Es wird jedoch damit gerechnet, dass, da
|
||||
Aufwand und Ertrag sich nicht decken, dies nicht oft der Fall
|
||||
ist.
|
||||
</para>
|
||||
|
@@ -5,29 +5,29 @@
|
||||
<title>Debugging Konsole</title>
|
||||
<para>
|
||||
Smarty wird mit einer eingebauten Debugging Konsole
|
||||
ausgeliefert. Diese Konsole informiert <EFBFBD>ber die im aufgerufenen
|
||||
ausgeliefert. Diese Konsole informiert über die im aufgerufenen
|
||||
Template <link
|
||||
linkend="language.function.include">eingebundenen</link> Templates,
|
||||
die <link linkend="api.assign">zugewiesenen</link> Variablen und die
|
||||
<link
|
||||
linkend="language.config.variables">Konfigurations-Variablen</link>.
|
||||
Die Formatierung der Konsole wird <EFBFBD>ber das Template <link
|
||||
Die Formatierung der Konsole wird über das Template <link
|
||||
linkend="variable.debug.tpl">debug.tpl</link> gesteuert. Um
|
||||
debugging zu aktivieren, setzten Sie <link
|
||||
linkend="variable.debugging">$debugging</link> auf 'true' und (falls
|
||||
n<EFBFBD>tig) <EFBFBD>bergeben in <link
|
||||
nötig) übergeben in <link
|
||||
linkend="variable.debug.tpl">$debug_tpl</link> den Pfad zum
|
||||
Debugtemplate (normalerweise <link
|
||||
linkend="constant.smarty.dir">SMARTY_DIR</link>debug.tpl). Wenn Sie
|
||||
danach eine Seite laden, sollte ein Javascript-Fenster ge<EFBFBD>ffnet
|
||||
danach eine Seite laden, sollte ein Javascript-Fenster geöffnet
|
||||
werden in welchem Sie alle Informationen zur aufgerufenen Seite
|
||||
finden. Falls Sie die Variablen eines bestimmten Templates ausgeben
|
||||
wollen, k<EFBFBD>nnen Sie dazu die Funktion <link
|
||||
wollen, können Sie dazu die Funktion <link
|
||||
linkend="language.function.debug">{debug}</link> verwenden. Um
|
||||
debugging auszuschalten, k<EFBFBD>nnen Sie <link
|
||||
debugging auszuschalten, können Sie <link
|
||||
linkend="variable.debugging">$debugging</link> auf 'false' setzen.
|
||||
Sie k<EFBFBD>nnen debugging auch tempor<EFBFBD>r aktivieren, in dem Sie der
|
||||
aufgerufenen URL SMARTY_DEBUG mit <EFBFBD>bergeben, dies muss jedoch
|
||||
Sie können debugging auch temporär aktivieren, in dem Sie der
|
||||
aufgerufenen URL SMARTY_DEBUG mit übergeben, dies muss jedoch
|
||||
zuerst mit <link
|
||||
linkend="variable.debugging.ctrl">$debugging_ctrl</link> aktiviert
|
||||
werden.
|
||||
@@ -35,12 +35,12 @@
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Die Debugging Konsole funktioniert nicht f<EFBFBD>r Daten die via <link
|
||||
Die Debugging Konsole funktioniert nicht für Daten die via <link
|
||||
linkend="api.fetch">fetch()</link> geladen wurden, sondern nur
|
||||
f<EFBFBD>r Daten die via <link linkend="api.display">display()</link>
|
||||
für Daten die via <link linkend="api.display">display()</link>
|
||||
ausgegeben werden. Die Konsole besteht aus ein paar Zeilen
|
||||
Javascript welche am Ende jeder Seite eingef<EFBFBD>gt werden. Wenn
|
||||
Sie Javascript nicht m<EFBFBD>gen, k<EFBFBD>nnen Sie die Ausgabe in
|
||||
Javascript welche am Ende jeder Seite eingefügt werden. Wenn
|
||||
Sie Javascript nicht mögen, können Sie die Ausgabe in
|
||||
'debug.tpl' selbst definieren. Debug-Ausgaben werden nicht gecached
|
||||
und Informationen zu 'debug.tpl' selbst werden nicht ausgegeben.
|
||||
</para>
|
||||
|
@@ -7,10 +7,10 @@
|
||||
Konfigurationsdateien sind ein praktischer Weg um Template-Variablen
|
||||
aus einer gemeinsamen Datei zu lesen. Ein Beispiel sind die
|
||||
Template-Farben. Wenn Sie die Farben einer Applikation anpassen
|
||||
wollen, m<EFBFBD>ssen Sie normalerweise alle Templates durcharbeiten,
|
||||
und die entsprechenden Werte <EFBFBD>ndern. Mit einer
|
||||
Konfigurationsdatei k<EFBFBD>nnen Sie alle Definitionen in einer
|
||||
einzigen Datei vornehmen, und somit auch einfach <EFBFBD>ndern.
|
||||
wollen, müssen Sie normalerweise alle Templates durcharbeiten,
|
||||
und die entsprechenden Werte ändern. Mit einer
|
||||
Konfigurationsdatei können Sie alle Definitionen in einer
|
||||
einzigen Datei vornehmen, und somit auch einfach ändern.
|
||||
</para>
|
||||
<example>
|
||||
<title>Beispiel der Konfigurationsdatei-Syntax</title>
|
||||
@@ -28,9 +28,9 @@ pageTitle = "Customer Info"
|
||||
[Login]
|
||||
pageTitle = "Login"
|
||||
focus = "username"
|
||||
Intro = """Diese Zeile erstreckt sich <EFBFBD>ber
|
||||
Intro = """Diese Zeile erstreckt sich über
|
||||
mehrere Zeilen, und muss deswegen
|
||||
mit dreifachen Anf<EFBFBD>hrungszeichen
|
||||
mit dreifachen Anführungszeichen
|
||||
umschlossen werden."""
|
||||
|
||||
# hidden section
|
||||
@@ -43,17 +43,17 @@ pass=foobar
|
||||
</example>
|
||||
<para>
|
||||
<link linkend="language.config.variables">Die Werte in einer
|
||||
Konfigurationsdatei</link> k<EFBFBD>nnen in einfachen/doppelten
|
||||
Anf<EFBFBD>hrungszeichen notiert werden. Falls Sie einen Wert haben der
|
||||
sich <EFBFBD>ber mehrere Zeilen ausbreitet muss dieser Wert in
|
||||
dreifachen Anf<EFBFBD>hrungszeichen (""") eingebettet werden. Die
|
||||
Kommentar-Syntax kann frei gew<EFBFBD>hlt werden, solange sie nicht der
|
||||
Konfigurationsdatei</link> können in einfachen/doppelten
|
||||
Anführungszeichen notiert werden. Falls Sie einen Wert haben der
|
||||
sich über mehrere Zeilen ausbreitet muss dieser Wert in
|
||||
dreifachen Anführungszeichen (""") eingebettet werden. Die
|
||||
Kommentar-Syntax kann frei gewählt werden, solange sie nicht der
|
||||
normalen Syntax entsprechen. Wir empfehlen die Verwendung von
|
||||
<literal>#</literal> (Raute) am Anfang jeder Kommentar-Zeile.
|
||||
</para>
|
||||
<para>
|
||||
Dieses Beispiel hat 2 'sections'. 'section'-Namen werden von
|
||||
[]-Zeichen umschlossen und k<EFBFBD>nnen alle Zeichen ausser
|
||||
[]-Zeichen umschlossen und können alle Zeichen ausser
|
||||
<literal>[</literal> und <literal>]</literal> enthalten. Die vier
|
||||
Variablen welche am Anfang der Datei definiert werden sind globale
|
||||
Variablen. Diese Variablen werden immer geladen. Wenn eine
|
||||
@@ -71,13 +71,13 @@ pass=foobar
|
||||
geladen.
|
||||
</para>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen Variablen oder auch ganze 'sections' verstecken indem
|
||||
Sie können Variablen oder auch ganze 'sections' verstecken indem
|
||||
Sie dem Namen ein '.' voranstellen. Dies ist besonders wertvoll wenn
|
||||
Ihre Applikation sensitive Informationen aus der Konfigurationsdatei
|
||||
liest welche von der Template-Engine nicht verwendet werden. Falls
|
||||
eine Drittpartei eine <EFBFBD>nderung an der Konfigurationsdatei
|
||||
vornimmt k<EFBFBD>nnen Sie so sicherstellen, dass die sensitiven Daten
|
||||
nicht in deren Template geladen werden k<EFBFBD>nnen.
|
||||
eine Drittpartei eine Änderung an der Konfigurationsdatei
|
||||
vornimmt können Sie so sicherstellen, dass die sensitiven Daten
|
||||
nicht in deren Template geladen werden können.
|
||||
</para>
|
||||
<para>
|
||||
Siehe auch: <link
|
||||
|
@@ -5,15 +5,15 @@
|
||||
<title>Grundlegende Syntax</title>
|
||||
<para>
|
||||
Alle Smarty Template-Tags werden mit Trennzeichen umschlossen. Normalerweise
|
||||
sind dies: <literal>{</literal> und <literal>}</literal>, sie k<EFBFBD>nnen aber
|
||||
auch <link linkend="variable.left.delimiter">ver<EFBFBD>ndert</link> werden.
|
||||
sind dies: <literal>{</literal> und <literal>}</literal>, sie können aber
|
||||
auch <link linkend="variable.left.delimiter">verändert</link> werden.
|
||||
</para>
|
||||
<para>
|
||||
F<EFBFBD>r die folgenden Beispiele wird davon ausgegangen, dass Sie die
|
||||
Für die folgenden Beispiele wird davon ausgegangen, dass Sie die
|
||||
Standard-Trennzeichen verwenden. Smarty erachtet alle Inhalte ausserhalb
|
||||
der Trennzeichen als statisch und unver<EFBFBD>nderbar. Sobald Smarty
|
||||
auf Template-Tags st<EFBFBD>sst, versucht es diese zu interpretieren und die
|
||||
entsprechenden Ausgaben an deren Stelle einzuf<EFBFBD>gen.
|
||||
der Trennzeichen als statisch und unveränderbar. Sobald Smarty
|
||||
auf Template-Tags stösst, versucht es diese zu interpretieren und die
|
||||
entsprechenden Ausgaben an deren Stelle einzufügen.
|
||||
</para>
|
||||
|
||||
&designers.language-basic-syntax.language-syntax-comments;
|
||||
|
@@ -4,7 +4,7 @@
|
||||
<sect1 id="language.escaping">
|
||||
<title>Smarty Parsing umgehen</title>
|
||||
<para>
|
||||
Manchmal ist es w<EFBFBD>nschenswert, dass Smarty Teile eines
|
||||
Manchmal ist es wünschenswert, dass Smarty Teile eines
|
||||
Templates nicht parst. Dies ist zum Beispiel der Fall, wenn
|
||||
Javascript oder CSS im Template eingebettet werden. Da diese
|
||||
Sprachen selbst { und } nutzen, erkennt Smarty diese als Start-
|
||||
@@ -17,10 +17,10 @@
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Um solche Inhalte trotzdem im gleichen Template einzubetten, k<EFBFBD>nnen
|
||||
Um solche Inhalte trotzdem im gleichen Template einzubetten, können
|
||||
Sie <link linkend="language.function.literal">{literal}
|
||||
.. {/literal}</link> Bl<EFBFBD>cke verwenden. Die aktuell benutzten
|
||||
Trennzeichen k<EFBFBD>nnen Sie mit <link
|
||||
.. {/literal}</link> Blöcke verwenden. Die aktuell benutzten
|
||||
Trennzeichen können Sie mit <link
|
||||
linkend="language.function.ldelim">{ldelim}</link>, <link
|
||||
linkend="language.function.ldelim">{rdelim}</link>, <link
|
||||
linkend="language.variables.smarty.ldelim">{$smarty.ldelim}</link>
|
||||
@@ -29,7 +29,7 @@
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Manchmal ist es auch einfacher, die Trennzeichen selbst zu <EFBFBD>ndern:
|
||||
Manchmal ist es auch einfacher, die Trennzeichen selbst zu ändern:
|
||||
<link linkend="variable.left.delimiter">$left_delimiter</link> und
|
||||
<link linkend="variable.right.delimiter">$right_delimiter</link>
|
||||
definieren diese.
|
||||
@@ -51,7 +51,7 @@ $smarty->display('example.tpl');
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
example.tpl w<EFBFBD>rde somit wie folgt aussehen:
|
||||
example.tpl würde somit wie folgt aussehen:
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
|
@@ -29,7 +29,7 @@
|
||||
|
||||
<para>
|
||||
Siehe auch die <link linkend="language.function.math">{math}-Funktion</link>
|
||||
f<EFBFBD>r komplexere Berechnungen.
|
||||
für komplexere Berechnungen.
|
||||
</para>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
@@ -10,8 +10,8 @@
|
||||
Beispiel: {* das ist ein Kommentar *} Smarty-Kommentare werden in
|
||||
der Ausgabe nicht dargestellt und vor allem dazu verwendet, die
|
||||
Templates verständlicher aufzubauen. Smarty Kommentare werden
|
||||
sind in der eng<EFBFBD>ltigen Ausgabe NICHT dargestellt. (im Gegensatz zu
|
||||
<!-- HTML Kommentaren -->). Sie sind n<EFBFBD>tzlich um in den
|
||||
sind in der engültigen Ausgabe NICHT dargestellt. (im Gegensatz zu
|
||||
<!-- HTML Kommentaren -->). Sie sind nützlich um in den
|
||||
Templates interne Anmerkungen zu hinterlassen.
|
||||
</para>
|
||||
<example>
|
||||
@@ -36,7 +36,7 @@
|
||||
{include file=#includeFile#}
|
||||
|
||||
{* Ausgabe der drop-down Liste *}
|
||||
{* Dieser <select> Block ist <EFBFBD>berfl<EFBFBD>ssig *}
|
||||
{* Dieser <select> Block ist überflüssig *}
|
||||
{*
|
||||
<select name=firma>
|
||||
{html_options options=$vals selected=$selected}
|
||||
|
@@ -41,13 +41,13 @@
|
||||
linkend="language.function.if">if</link>, <link
|
||||
linkend="language.function.section">section</link> und <link
|
||||
linkend="language.function.strip">strip</link>. Diese Funktionen
|
||||
k<EFBFBD>nnen nicht ver<EFBFBD>ndert werden.
|
||||
können nicht verändert werden.
|
||||
</para>
|
||||
<para>
|
||||
Individuelle Funktionen die die F<EFBFBD>higkeiten von Smarty erweitern
|
||||
werden als Plugins implementiert. Diese Funktionen k<EFBFBD>nnen von Ihnen
|
||||
angepasst werden, oder Sie k<EFBFBD>nnen selbst neue Plugins
|
||||
hinzuf<EFBFBD>gen. <link
|
||||
Individuelle Funktionen die die Fähigkeiten von Smarty erweitern
|
||||
werden als Plugins implementiert. Diese Funktionen können von Ihnen
|
||||
angepasst werden, oder Sie können selbst neue Plugins
|
||||
hinzufügen. <link
|
||||
linkend="language.function.html.options">{html_options}</link> und
|
||||
<link
|
||||
linkend="language.function.html.select.date">{html_select_date}</link>
|
||||
|
@@ -2,17 +2,17 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.6 Maintainer: andreas Status: ready -->
|
||||
<sect1 id="language.syntax.quotes">
|
||||
<title>Variablen mit Doppelten Anf<EFBFBD>hrungszeichen</title>
|
||||
<title>Variablen mit Doppelten Anführungszeichen</title>
|
||||
<para>
|
||||
Smarty erkennt <link linkend="api.assign">zugewiesene</link> <link
|
||||
linkend="language.syntax.variables">Variablen</link> mit doppelten
|
||||
Anf<EFBFBD>hrungszeichen solange die Variablen nur Zahlen, Buchstaben,
|
||||
Anführungszeichen solange die Variablen nur Zahlen, Buchstaben,
|
||||
Understriche oder Klammern [] enthalten. Mit allen anderen Zeichen
|
||||
wie Punkt, Objekt Referenzen, etc muss die Vairable mit Backticks
|
||||
(``) umschlossen sein.
|
||||
</para>
|
||||
<example>
|
||||
<title>Syntax von eingebetteten Anf<EFBFBD>rungszeichen</title>
|
||||
<title>Syntax von eingebetteten Anfürungszeichen</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
SYNTAX BEISPIELE:
|
||||
@@ -22,7 +22,7 @@ SYNTAX BEISPIELE:
|
||||
{func var="test $foo[bar] test"} <-- sieht $foo[bar]
|
||||
{func var="test $foo.bar test"} <-- sieht $foo (nicht $foo.bar)
|
||||
{func var="test `$foo.bar` test"} <-- sieht $foo.bar
|
||||
{func var="test `$foo.bar` test"|escape} <-- Modifikatoren ausserhalb der Anf<EFBFBD>hrungsz.!
|
||||
{func var="test `$foo.bar` test"|escape} <-- Modifikatoren ausserhalb der Anführungsz.!
|
||||
|
||||
PRAKTISCHE BEISPIELE:
|
||||
{include file="subdir/$tpl_name.tpl"} <-- ersetzt $tpl_name durch wert
|
||||
|
@@ -5,16 +5,16 @@
|
||||
<title>Variablen</title>
|
||||
<para>
|
||||
Templatevariablennamen beginnen mit einem $dollar-Zeichen. Sie
|
||||
k<EFBFBD>nnen Ziffer, Buchstaben und Unterstriche ('_') enthalten, sehr
|
||||
<EFBFBD>hnlich den <ulink
|
||||
können Ziffer, Buchstaben und Unterstriche ('_') enthalten, sehr
|
||||
ähnlich den <ulink
|
||||
url="&url.php-manual;language.variables">Variablen in PHP</ulink>.
|
||||
Numerische Arrayindizes k<EFBFBD>nnen referenziert werden und auch
|
||||
Numerische Arrayindizes können referenziert werden und auch
|
||||
Nichtnumerische. Zugriff auf Objekteigenschaften und -methoden ist
|
||||
auch m<EFBFBD>glich.
|
||||
auch möglich.
|
||||
<link
|
||||
linkend="language.config.variables">Konfigurationsvariablen</link>
|
||||
sind einer Ausname was die Dollarzeichen-Syntax angeht. Diese werden
|
||||
durch umgebende #Doppelkreuze# oder <EFBFBD>ber die Varible <link
|
||||
durch umgebende #Doppelkreuze# oder über die Varible <link
|
||||
linkend="language.variables.smarty.config">$smarty.config</link>
|
||||
referenziert.
|
||||
</para>
|
||||
@@ -24,12 +24,12 @@
|
||||
<![CDATA[
|
||||
{$foo} <-- Zeigt einfache Variable an (kein Array oder Objekt)
|
||||
{$foo[4]} <-- Zeigt 5. Element von einem Array an, deren Schlussel bei 0 beginnen
|
||||
{$foo.bar} <-- Zeigt das Element zum Schl<EFBFBD>ssel "bar" des Arrays an (wie PHPs $foo['bar'])
|
||||
{$foo.$bar} <-- Zeigt das Element eines variablen Schl<EFBFBD>ssels an (wie PHPs $foo[$bar])
|
||||
{$foo.bar} <-- Zeigt das Element zum Schlüssel "bar" des Arrays an (wie PHPs $foo['bar'])
|
||||
{$foo.$bar} <-- Zeigt das Element eines variablen Schlüssels an (wie PHPs $foo[$bar])
|
||||
{$foo->bar} <-- Zeigt eine Eigenschaft "bar" des Objekts $foo an
|
||||
{$foo->bar()} <-- Zeigt den R<EFBFBD>ckgabewert der Objectmethode "bar" an
|
||||
{$foo->bar()} <-- Zeigt den Rückgabewert der Objectmethode "bar" an
|
||||
{#foo#} <-- Zeift die Konfigurationsvariable "foo" an
|
||||
{$smarty.config.foo} <-- Synonym f<EFBFBD>r {#foo#}
|
||||
{$smarty.config.foo} <-- Synonym für {#foo#}
|
||||
{$foo[bar]} <-- Syntax zum zugriff auf Element in einer Section-Schleife, siehe {section}
|
||||
{assign var=foo value="baa"}{$foo} <-- Gibt "baa" aus, siehe {assign}
|
||||
|
||||
@@ -40,7 +40,7 @@ Viele weitere Kombinationen sind erlaubt
|
||||
{$foo[4].baz}
|
||||
{$foo[4].$baz}
|
||||
{$foo.bar.baz[4]}
|
||||
{$foo->bar($baz,2,$bar)} <-- Parameter <EFBFBD>bergeben
|
||||
{$foo->bar($baz,2,$bar)} <-- Parameter übergeben
|
||||
{"foo"} <-- Statische (konstante) Werte sind auch erlaubt
|
||||
]]>
|
||||
</programlisting>
|
||||
|
@@ -7,12 +7,12 @@
|
||||
{capture} wird verwendet, um die Template-Ausgabe abzufangen und in
|
||||
einer Variable zu speichern. Der Inhalt zwischen {capture
|
||||
name="foo"} und {/capture} wird unter der im 'name' Attribut
|
||||
angegebenen Capture-Variablen abgelegt und kann <EFBFBD>ber <link
|
||||
angegebenen Capture-Variablen abgelegt und kann über <link
|
||||
linkend="language.variables.smarty.capture">$smarty.capture.foo</link>
|
||||
angesprochen werden. Falls kein 'name'-Attribut <EFBFBD>bergeben wurde,
|
||||
angesprochen werden. Falls kein 'name'-Attribut übergeben wurde,
|
||||
wird der Inhalt in 'default' (also $smarty.capture.default)
|
||||
abgelegt. Jede {capture} Sektion muss mit {/capture} beendet
|
||||
werden. {capture}-Bl<EFBFBD>cke k<EFBFBD>nnen verschachtelt sein.
|
||||
werden. {capture}-Blöcke können verschachtelt sein.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -25,7 +25,7 @@
|
||||
<row>
|
||||
<entry>Attribut Name</entry>
|
||||
<entry>Typ</entry>
|
||||
<entry>Ben<EFBFBD>tigt</entry>
|
||||
<entry>Benötigt</entry>
|
||||
<entry>Standardwert</entry>
|
||||
<entry>Beschreibung</entry>
|
||||
</row>
|
||||
|
@@ -8,7 +8,7 @@
|
||||
linkend="language.config.variables">Variablen aus einer
|
||||
Konfigurationsdatei</link> in das Template zu laden. Sehen sie
|
||||
<link linkend="config.files">Config Files
|
||||
(Konfigurationsdateien)</link> f<EFBFBD>r weitere Informationen.
|
||||
(Konfigurationsdateien)</link> für weitere Informationen.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -53,7 +53,7 @@
|
||||
geladen werden. 'parent' bedeutet, dass die Variablen sowohl in
|
||||
den lokalen Context, als auch in den Context des aufrufenden
|
||||
Templates eingebunden werden. 'global' bedeutet, dass die
|
||||
Variablen von allen Templates zug<EFBFBD>nglich sind.
|
||||
Variablen von allen Templates zugänglich sind.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -62,9 +62,9 @@
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>No</emphasis></entry>
|
||||
<entry>
|
||||
Definiert, ob die Variablen von allen Templates aus zug<EFBFBD>nglich
|
||||
sind. WICHTIG: Dieses Attribut wird von 'scope' abgel<EFBFBD>st und
|
||||
sollte nicht mehr verwendet werden. Falls 'scope' <EFBFBD>bergeben
|
||||
Definiert, ob die Variablen von allen Templates aus zugänglich
|
||||
sind. WICHTIG: Dieses Attribut wird von 'scope' abgelöst und
|
||||
sollte nicht mehr verwendet werden. Falls 'scope' übergeben
|
||||
wurde, wird 'global' ignoriert.
|
||||
</entry>
|
||||
</row>
|
||||
@@ -81,7 +81,7 @@
|
||||
#Dies ist ein Konfigurationsdateikommentar
|
||||
|
||||
# globale Variablen
|
||||
seitenTitel = "Hauptmen<EFBFBD>"
|
||||
seitenTitel = "Hauptmenü"
|
||||
bodyHintergrundFarbe = #000000
|
||||
tabelleHintergrundFarbe = #000000
|
||||
reiheHintergrundFarbe = #00ff00
|
||||
@@ -112,9 +112,9 @@ seitenTitel = "Kundeninfo"
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
<link linkend="config.files">Konfigurationsdateien</link> k<EFBFBD>nnen
|
||||
<link linkend="config.files">Konfigurationsdateien</link> können
|
||||
Abschnitte enthalten. Um Variablen aus einem Abschnitt zu laden,
|
||||
k<EFBFBD>nnen Sie das Attribut <emphasis>section</emphasis> <EFBFBD>bergeben.
|
||||
können Sie das Attribut <emphasis>section</emphasis> übergeben.
|
||||
</para>
|
||||
<para>
|
||||
Bemerkung: <emphasis>Konfigurationdatei-Abschnitte
|
||||
@@ -146,7 +146,7 @@ seitenTitel = "Kundeninfo"
|
||||
<para>
|
||||
Siehe <link
|
||||
linkend="variable.config.overwrite">$config_overwrite</link>
|
||||
bez<EFBFBD>glich Arrays von Konfigurationsvariablen.
|
||||
bezüglich Arrays von Konfigurationsvariablen.
|
||||
</para>
|
||||
<para>
|
||||
Siehe auch <link
|
||||
|
@@ -11,18 +11,18 @@
|
||||
Array zu durchlaufen. Die Syntax von
|
||||
<emphasis>foreach</emphasis>-Schleifen ist viel einfacher als die
|
||||
von <emphasis>section</emphasis>. <emphasis>{foreach}</emphasis>
|
||||
Tags m<EFBFBD>ssen mit <emphasis>{/foreach}</emphasis> tags kombiniert
|
||||
Tags müssen mit <emphasis>{/foreach}</emphasis> tags kombiniert
|
||||
werden. Erforderliche Parameter sind: <emphasis>from</emphasis> und
|
||||
<emphasis>item</emphasis>. Der Name der {foreach}-Schleife kann
|
||||
frei vergeben werden und sowohl Buchstaben, Zahlen als auch
|
||||
Unterstriche enthalten. <emphasis>foreach</emphasis>-Schleifen
|
||||
k<EFBFBD>nnen verschachtelt werden, dabei ist zu beachten, dass sich die
|
||||
können verschachtelt werden, dabei ist zu beachten, dass sich die
|
||||
definierten Namen voneinander unterscheiden. Die
|
||||
<emphasis>from</emphasis> Variable (normalerweise ein assoziatives
|
||||
Array) definiert die Anzahl der von <emphasis>foreach</emphasis> zu
|
||||
durchlaufenen Iterationen. <emphasis>foreachelse</emphasis> wird
|
||||
ausgef<EFBFBD>hrt wenn keine Werte in der <emphasis>from</emphasis>
|
||||
Variable <EFBFBD>bergeben wurden.
|
||||
ausgeführt wenn keine Werte in der <emphasis>from</emphasis>
|
||||
Variable übergeben wurden.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -53,21 +53,21 @@
|
||||
<entry>string</entry>
|
||||
<entry>Ja</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Name f<EFBFBD>r das aktuelle Element.</entry>
|
||||
<entry>Name für das aktuelle Element.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>key</entry>
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Name f<EFBFBD>r den aktuellen Schl<EFBFBD>ssel.</entry>
|
||||
<entry>Name für den aktuellen Schlüssel.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>name</entry>
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Name der 'foreach'-Schleife, f<EFBFBD>r die Abfrage der 'foreach'-Eigenschaften.</entry>
|
||||
<entry>Name der 'foreach'-Schleife, für die Abfrage der 'foreach'-Eigenschaften.</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
@@ -107,7 +107,7 @@ id: 1002<br>
|
||||
<title>{foreach} - item und key</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
// Der Schl<EFBFBD>ssel enth<EFBFBD>lt den Schl<EFBFBD>ssel des jeweils iterierten Wertes
|
||||
// Der Schlüssel enthält den Schlüssel des jeweils iterierten Wertes
|
||||
// die Zuweisung sieht wie folgt aus:
|
||||
<?php
|
||||
$smarty->assign('kontakte', array(
|
||||
@@ -170,7 +170,7 @@ id: 1002<br>
|
||||
Foreach-Loops haben auch eigene Variablen welche die Foreach
|
||||
Eigenschaften enthalten. Diese werden wie folgt ausgewiesen:
|
||||
{$smarty.foreach.foreachname.varname}. foreachname ist der Name der
|
||||
als <emphasis>name</emphasis> Attribut von Foreach <EFBFBD>bergeben wurden.
|
||||
als <emphasis>name</emphasis> Attribut von Foreach übergeben wurden.
|
||||
</para>
|
||||
|
||||
<sect2 id="foreach.property.iteration">
|
||||
@@ -209,7 +209,7 @@ id: 1002<br>
|
||||
<title>total</title>
|
||||
<para>
|
||||
<emphasis>total</emphasis> gibt die Anzahl Iterationen des Foreach
|
||||
Loops aus und kann in- oder nach- Foreach Bl<EFBFBD>cken verwendet werden.
|
||||
Loops aus und kann in- oder nach- Foreach Blöcken verwendet werden.
|
||||
</para>
|
||||
</sect2>
|
||||
</sect1>
|
||||
|
@@ -5,7 +5,7 @@
|
||||
<title>{if},{elseif},{else}</title>
|
||||
<para>
|
||||
<emphasis>{if}</emphasis>-Statements in Smarty erlauben die selbe
|
||||
Flexibilit<EFBFBD>t wie in PHP, bis auf ein paar Erweiterungen f<EFBFBD>r die
|
||||
Flexibilität wie in PHP, bis auf ein paar Erweiterungen für die
|
||||
Template-Engine. Jedes <emphasis>{if}</emphasis> muss mit einem
|
||||
<emphasis>{/if}</emphasis> kombiniert
|
||||
sein. <emphasis>{else}</emphasis> und <emphasis>{elseif}</emphasis>
|
||||
@@ -16,15 +16,15 @@
|
||||
</para>
|
||||
<para>
|
||||
Wenn <link linkend="variable.security">$security</link> angeschaltet
|
||||
wurde, dann m<EFBFBD>ssen alle verwendeten PHP-Funktionen im
|
||||
wurde, dann müssen alle verwendeten PHP-Funktionen im
|
||||
<emphasis>IF_FUNCS</emphasis>-Array in dem <link
|
||||
linkend="variable.security.settings">$security_settings</link>-Array
|
||||
deklariert werden.
|
||||
</para>
|
||||
<para>
|
||||
Hier eine Liste der erlaubten Operatoren. Bedingungsoperatoren
|
||||
m<EFBFBD>ssen von umgebenden Elementen mit Leerzeichen abgetrennt werden.
|
||||
PHP-<EFBFBD>quivalente sind, sofern vorhanden, angeben.
|
||||
müssen von umgebenden Elementen mit Leerzeichen abgetrennt werden.
|
||||
PHP-Äquivalente sind, sofern vorhanden, angeben.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -32,14 +32,14 @@
|
||||
<colspec colname="Alternativen" align="center" />
|
||||
<colspec colname="Syntax Beispiel" />
|
||||
<colspec colname="Bedeutung" />
|
||||
<colspec colname="PHP <EFBFBD>quivalent" />
|
||||
<colspec colname="PHP Äquivalent" />
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Operator</entry>
|
||||
<entry>Alternativen</entry>
|
||||
<entry>Syntax Beispiel</entry>
|
||||
<entry>Bedeutung</entry>
|
||||
<entry>PHP <EFBFBD>quivalent</entry>
|
||||
<entry>PHP Äquivalent</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
@@ -61,7 +61,7 @@
|
||||
<entry>></entry>
|
||||
<entry>gt</entry>
|
||||
<entry>$a gt $b</entry>
|
||||
<entry>gr<EFBFBD><EFBFBD>er als</entry>
|
||||
<entry>größer als</entry>
|
||||
<entry>></entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -75,7 +75,7 @@
|
||||
<entry>>=</entry>
|
||||
<entry>gte, ge</entry>
|
||||
<entry>$a ge $b</entry>
|
||||
<entry>gr<EFBFBD><EFBFBD>er oder gleich</entry>
|
||||
<entry>größer oder gleich</entry>
|
||||
<entry>>=</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -182,17 +182,17 @@
|
||||
{/if}
|
||||
|
||||
|
||||
{* einbetten von php Funktionsaufrufen ('gt' steht f<EFBFBD>r 'gr<EFBFBD>sser als') *}
|
||||
{* einbetten von php Funktionsaufrufen ('gt' steht für 'grösser als') *}
|
||||
{if count($var) gt 0}
|
||||
...
|
||||
{/if}
|
||||
|
||||
{* Auf "ist array" <EFBFBD>berpr<EFBFBD>fen. *}
|
||||
{* Auf "ist array" überprüfen. *}
|
||||
{if is_array($foo) }
|
||||
.....
|
||||
{/if}
|
||||
|
||||
{* Auf "ist nicht null" <EFBFBD>berpr<EFBFBD>fen. *}
|
||||
{* Auf "ist nicht null" überprüfen. *}
|
||||
{if isset($foo) }
|
||||
.....
|
||||
{/if}
|
||||
|
@@ -5,7 +5,7 @@
|
||||
<title>include_php (PHP-Code einbinden)</title>
|
||||
<para>
|
||||
Die Verwendung von {include_php} wird nicht mehr empfohlen, die
|
||||
gleiche funktionalit<EFBFBD>t kann auch mit <link
|
||||
gleiche funktionalität kann auch mit <link
|
||||
linkend="tips.componentized.templates">Template/Script
|
||||
Komponenten</link> erreicht werden.
|
||||
</para>
|
||||
@@ -54,26 +54,26 @@
|
||||
Falls <link linkend="variable.security">Sicherheit</link> aktiviert
|
||||
ist, muss das einzubindende Skript im <link
|
||||
linkend="variable.trusted.dir">$trusted_dir</link> Pfad
|
||||
liegen. {include_php} muss das Attribut 'file' <EFBFBD>bergeben werden, das
|
||||
liegen. {include_php} muss das Attribut 'file' übergeben werden, das
|
||||
den Pfad - entweder relativ zu <link
|
||||
linkend="variable.trusted.dir">$trusted_dir</link> oder absolut -
|
||||
zum Skript enth<EFBFBD>lt.
|
||||
zum Skript enthält.
|
||||
</para>
|
||||
<para>
|
||||
Normalerweise wird ein PHP-Skript nur einmal pro Aufruf geladen,
|
||||
selbst wenn es mehrfach eingebunden wird. Sie k<EFBFBD>nnen dieses
|
||||
selbst wenn es mehrfach eingebunden wird. Sie können dieses
|
||||
Verhalten durch die Verwendung des <emphasis>once</emphasis>
|
||||
Attributs steuern. Wenn Sie 'once' auf 'false' setzen, wird die
|
||||
Datei immer wenn sie eingebunden wird auch neu geladen.
|
||||
</para>
|
||||
<para>
|
||||
Optional kann das <emphasis>assign</emphasis> Attribut <EFBFBD>bergeben
|
||||
Optional kann das <emphasis>assign</emphasis> Attribut übergeben
|
||||
werden. Die Ausgabe von <emphasis>include_php</emphasis> wird dann
|
||||
nicht direkt eingef<EFBFBD>gt, sondern in der durch assign benannten
|
||||
nicht direkt eingefügt, sondern in der durch assign benannten
|
||||
Template-Variable abgelegt.
|
||||
</para>
|
||||
<para>
|
||||
Das Objekt '$smarty' kann in dem eingebundenen PHP-Script <EFBFBD>ber
|
||||
Das Objekt '$smarty' kann in dem eingebundenen PHP-Script über
|
||||
'$this' angesprochen werden.
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -6,7 +6,7 @@
|
||||
<para>
|
||||
{include}-Tags werden verwendet, um andere Templates in das aktuelle
|
||||
Template einzubinden. Alle Variablen des aktuellen Templates sind
|
||||
auch im eingebundenen Template verf<EFBFBD>gbar. Das {include}-Tag muss ein
|
||||
auch im eingebundenen Template verfügbar. Das {include}-Tag muss ein
|
||||
'file' Attribut mit dem Pfad zum einzubindenden Template enthalten.
|
||||
</para>
|
||||
<para>
|
||||
@@ -19,7 +19,7 @@
|
||||
Die Werte aller zugewiesenen Variablen werden wiederhergestellt, sobald
|
||||
ein eingebundenes Template wieder verlassen wurde. Das bedeutet, dass in
|
||||
einem eingebundenen Template alle Variablen des einbindenden Template
|
||||
verwendet und ver<EFBFBD>ndert werden k<EFBFBD>nnen, diese <EFBFBD>nderungen aber verloren sind,
|
||||
verwendet und verändert werden können, diese Änderungen aber verloren sind,
|
||||
sobald das {include} abgearbeitet wurde.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
@@ -58,7 +58,7 @@
|
||||
<entry>[var typ]</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Variablen welche dem Template lokal <EFBFBD>bergeben werden sollen.</entry>
|
||||
<entry>Variablen welche dem Template lokal übergeben werden sollen.</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
@@ -84,14 +84,14 @@
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen dem einzubindenden Template Variablen als Attribute
|
||||
<EFBFBD>bergeben. Alle explizit <EFBFBD>bergebenen Variablen sind nur im
|
||||
Sie können dem einzubindenden Template Variablen als Attribute
|
||||
übergeben. Alle explizit übergebenen Variablen sind nur im
|
||||
Anwendungsbereich (scope) dieses Template
|
||||
verf<EFBFBD>gbar. Attribut-Variablen <EFBFBD>berschreiben aktuelle
|
||||
verfügbar. Attribut-Variablen überschreiben aktuelle
|
||||
Template-Variablen, falls sie den gleichen Namen haben.
|
||||
</para>
|
||||
<example>
|
||||
<title>include-Funktion und Variablen <EFBFBD>bergabe</title>
|
||||
<title>include-Funktion und Variablen Übergabe</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
{include file='header.tpl' title='Hauptmenu' table_bgcolor='#c0c0c0'}
|
||||
@@ -108,7 +108,7 @@
|
||||
ausserhalb des '$template_dir' einzubinden:
|
||||
</para>
|
||||
<example>
|
||||
<title>Beispiele f<EFBFBD>r Template-Ressourcen bei der 'include'-Funktion</title>
|
||||
<title>Beispiele für Template-Ressourcen bei der 'include'-Funktion</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
{* absoluter Dateipfad *}
|
||||
@@ -117,7 +117,7 @@
|
||||
{* absoluter Dateipfad (gleich) *}
|
||||
{include file='file:/usr/local/include/templates/header.tpl'}
|
||||
|
||||
{* absoluter Dateipfad unter Windows ("file:"-Prefix MUSS <EFBFBD>bergeben werden) *}
|
||||
{* absoluter Dateipfad unter Windows ("file:"-Prefix MUSS übergeben werden) *}
|
||||
{include file='file:C:/www/pub/templates/header.tpl'}
|
||||
|
||||
{* einbinden aus Template-Ressource namens 'db' *}
|
||||
@@ -127,7 +127,7 @@
|
||||
{include file="$module.tpl"}
|
||||
{*
|
||||
Dies hier Funktioniert nicht, da Variablen innerhalb einfacher
|
||||
Anf<EFBFBD>hrungszeichen nicht interpoliert werden.
|
||||
Anführungszeichen nicht interpoliert werden.
|
||||
*}
|
||||
{include file='$module.tpl'}
|
||||
]]>
|
||||
|
@@ -2,13 +2,13 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.6 Maintainer: andreas Status: ready -->
|
||||
<sect1 id="language.function.insert">
|
||||
<title>insert (einf<EFBFBD>gen)</title>
|
||||
<title>insert (einfügen)</title>
|
||||
<para>
|
||||
{insert}-Tags funktionieren <EFBFBD>hnlich den <link
|
||||
{insert}-Tags funktionieren ähnlich den <link
|
||||
linkend="language.function.include">{include}</link>-Tags, werden
|
||||
aber nicht gecached, falls <link linkend="caching">caching</link>
|
||||
eingeschaltet ist. Sie werden bei jedem Aufruf des Templates
|
||||
ausgef<EFBFBD>hrt.
|
||||
ausgeführt.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -53,16 +53,16 @@
|
||||
<entry>[var typ]</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Variablen die der 'insert'-Funktion <EFBFBD>bergeben werden sollen.</entry>
|
||||
<entry>Variablen die der 'insert'-Funktion übergeben werden sollen.</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<para>
|
||||
Stellen Sie sich vor, sie h<EFBFBD>tten ein Template mit einem
|
||||
Stellen Sie sich vor, sie hätten ein Template mit einem
|
||||
Werbebanner. Dieser Banner kann verschiedene Arten von Inhalten
|
||||
haben: Bilder, HTML, Flash, etc. Deshalb k<EFBFBD>nnen wir nicht einfach
|
||||
einen statischen Link verwenden und m<EFBFBD>ssen vermeiden, dass dieser
|
||||
haben: Bilder, HTML, Flash, etc. Deshalb können wir nicht einfach
|
||||
einen statischen Link verwenden und müssen vermeiden, dass dieser
|
||||
Inhalt gecached wird. Hier kommt das {insert}-Tag ins Spiel. Das
|
||||
Template kennt die Variablen '#banner_location_id#' und '#site_id#'
|
||||
(zum Beispiel aus einer <link
|
||||
@@ -78,29 +78,29 @@
|
||||
</example>
|
||||
<para>
|
||||
In diesem Beispiel verwenden wir die Funktion 'getBanner' und
|
||||
<EFBFBD>bergeben die Parameter '#banner_location_id#' und '#site_id#'.
|
||||
übergeben die Parameter '#banner_location_id#' und '#site_id#'.
|
||||
Smarty wird daraufhin in Ihrer Applikatiopn nach einer Funktion
|
||||
namens 'getBanner' suchen und diese mit den Parametern
|
||||
'#banner_location_id#' und '#site_id#' aufrufen. Allen
|
||||
'insert'-Funktionen in Ihrer Applikation muss 'insert_'
|
||||
vorangestellt werden, um Konflikte im Namensraum zu vermeiden. Ihre
|
||||
'insert_getBanner()'-Funktion sollte etwas mit den <EFBFBD>bergebenen
|
||||
Parametern unternehmen und das Resultat zur<EFBFBD>ckgeben. Dieses
|
||||
'insert_getBanner()'-Funktion sollte etwas mit den übergebenen
|
||||
Parametern unternehmen und das Resultat zurückgeben. Dieses
|
||||
Resultat wird an der Stelle des 'insert'-Tags in Ihrem Template
|
||||
ausgegeben. In diesem Beispiel w<EFBFBD>rde Smarty folgende Funktion
|
||||
ausgegeben. In diesem Beispiel würde Smarty folgende Funktion
|
||||
aufrufen: insert_getBanner(array("lid" => "12345","sid" => "67890"))
|
||||
und die erhaltenen Resultate an Stelle des 'insert'-Tags ausgeben.
|
||||
</para>
|
||||
<para>
|
||||
Falls Sie das 'assign'-Attribut <EFBFBD>bergeben, wird die Ausgabe des
|
||||
Falls Sie das 'assign'-Attribut übergeben, wird die Ausgabe des
|
||||
'insert'-Tags in dieser Variablen abgelegt. Bemerkung: dies ist
|
||||
nicht sinnvoll, wenn <link linkend="variable.caching">Caching</link>
|
||||
eingeschaltet ist.
|
||||
</para>
|
||||
<para>
|
||||
Falls Sie das 'script'-Attribut <EFBFBD>bergeben, wird das angegebene
|
||||
PHP-Skript vor der Ausf<EFBFBD>hrung der {insert}-Funktion eingebunden.
|
||||
Dies ist n<EFBFBD>tzlich, um die {insert}-Funktion erst in diesem Skript zu
|
||||
Falls Sie das 'script'-Attribut übergeben, wird das angegebene
|
||||
PHP-Skript vor der Ausführung der {insert}-Funktion eingebunden.
|
||||
Dies ist nützlich, um die {insert}-Funktion erst in diesem Skript zu
|
||||
definieren. Der Pfad kann absolut oder relativ zu <link
|
||||
linkend="variable.trusted.dir">$trusted_dir</link> angegeben werden.
|
||||
Wenn Sicherheit eingeschaltet ist, muss das Skript in <link
|
||||
@@ -108,17 +108,17 @@
|
||||
</para>
|
||||
<para>
|
||||
Als zweites Argument wird der {insert}-Funktion das Smarty-Objekt
|
||||
selbst <EFBFBD>bergeben. Damit kann dort auf die Informationen im
|
||||
selbst übergeben. Damit kann dort auf die Informationen im
|
||||
Smarty-Objekt zugegriffen werden.
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Es gibt die M<EFBFBD>glichkeit, Teile des Templates nicht zu cachen. Wenn
|
||||
Es gibt die Möglichkeit, Teile des Templates nicht zu cachen. Wenn
|
||||
Sie <link linkend="caching">caching</link> eingeschaltet haben,
|
||||
werden {insert}-Tags nicht gecached. Sie werden jedesmal
|
||||
ausgef<EFBFBD>hrt, wenn die Seite erstellt wird - selbst innerhalb
|
||||
gecachter Seiten. Dies funktioniert gut f<EFBFBD>r Dinge wie Werbung
|
||||
ausgeführt, wenn die Seite erstellt wird - selbst innerhalb
|
||||
gecachter Seiten. Dies funktioniert gut für Dinge wie Werbung
|
||||
(Banner), Abstimmungen, Wetterberichte, Such-Resultate,
|
||||
Benutzer-Feedback-Ecke, etc.
|
||||
</para>
|
||||
|
@@ -4,9 +4,9 @@
|
||||
<sect1 id="language.function.literal">
|
||||
<title>literal</title>
|
||||
<para>
|
||||
{literal}-Tags erlauben es, einen Block w<EFBFBD>rtlich auszugeben,
|
||||
{literal}-Tags erlauben es, einen Block wörtlich auszugeben,
|
||||
d.h. von der Interpretation durch Smarty auszuschliessen. Dies ist
|
||||
vor allem f<EFBFBD>r Javascript- oder andere Bl<EFBFBD>cke n<EFBFBD>tzlich, die
|
||||
vor allem für Javascript- oder andere Blöcke nützlich, die
|
||||
geschwungene Klammern verwenden. Alles was zwischen den
|
||||
{literal}{/literal} Tags steht, wird direkt angezeigt. Wenn in
|
||||
einem {literal}-Block temlate-Tags verwendet werden sollen, is es
|
||||
|
@@ -7,8 +7,8 @@
|
||||
{php}-Tags erlauben es, PHP-Code direkt in das Template
|
||||
einzubetten. Der Inhalt wird nicht 'escaped', egal wie <link
|
||||
linkend="variable.php.handling">$php_handling</link> konfiguriert
|
||||
ist. Dieses Tag ist nur f<EFBFBD>r erfahrene Benutzer gedacht und wird
|
||||
auch von diesen normalerweise nicht ben<EFBFBD>tigt.
|
||||
ist. Dieses Tag ist nur für erfahrene Benutzer gedacht und wird
|
||||
auch von diesen normalerweise nicht benötigt.
|
||||
</para>
|
||||
<example>
|
||||
<title>{php}-Tags</title>
|
||||
@@ -24,10 +24,10 @@
|
||||
<note>
|
||||
<title>Technical Note</title>
|
||||
<para>
|
||||
Um auf PHP-Variablen in {php}-Bl<EFBFBD>cken zugreifen zu k<EFBFBD>nnen, kann es
|
||||
n<EFBFBD>tig sein, die Variable als <ulink
|
||||
Um auf PHP-Variablen in {php}-Blöcken zugreifen zu können, kann es
|
||||
nötig sein, die Variable als <ulink
|
||||
url="&url.php-manual;global">global</ulink> zu deklarieren. Der
|
||||
{php}-Bl<EFBFBD>ck l<EFBFBD>uft n<EFBFBD>mlich nicht in einem globalen Kontext, sondern
|
||||
{php}-Blöck läuft nämlich nicht in einem globalen Kontext, sondern
|
||||
im Kontext der method des laufenden $smarty-Objektes.
|
||||
</para>
|
||||
</note>
|
||||
|
@@ -5,20 +5,20 @@
|
||||
<title>section,sectionelse</title>
|
||||
<para>
|
||||
Template-{sections} werden verwendet, um durch <emphasis
|
||||
role="bold">Arrays</emphasis> zu iterieren (<EFBFBD>hnlich wie <link
|
||||
role="bold">Arrays</emphasis> zu iterieren (ähnlich wie <link
|
||||
linkend="language.function.foreach">{foreach}</link>). Jedes
|
||||
<emphasis>section</emphasis>-Tag muss mit einem
|
||||
<emphasis>/section</emphasis>-Tag kombiniert
|
||||
werden. <emphasis>name</emphasis> und <emphasis>loop</emphasis> sind
|
||||
erforderliche Parameter. Der Name der 'section' kann frei gew<EFBFBD>hlt
|
||||
erforderliche Parameter. Der Name der 'section' kann frei gewählt
|
||||
werden, muss jedoch aus Buchstaben, Zahlen oder Unterstrichen
|
||||
bestehen. {sections} k<EFBFBD>nnen verschachtelt werden. Dabei ist zu
|
||||
bestehen. {sections} können verschachtelt werden. Dabei ist zu
|
||||
beachten, dass sich ihre Namen unterscheiden. Aus der
|
||||
'loop'-Variable (normalerweise ein Array von Werten) resultiert die
|
||||
Anzahl der Iterationen, die durchlaufen werden. Wenn ein Wert aus
|
||||
der 'loop'-Variable innerhalb der {section} ausgegeben werden soll,
|
||||
muss der 'section-name' umschlossen mit [] angef<EFBFBD>gt werden.
|
||||
<emphasis>sectionelse</emphasis> wird ausgef<EFBFBD>hrt, wenn keine Werte
|
||||
muss der 'section-name' umschlossen mit [] angefügt werden.
|
||||
<emphasis>sectionelse</emphasis> wird ausgeführt, wenn keine Werte
|
||||
in der 'loop'-Variable enthalten sind.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
@@ -50,7 +50,7 @@
|
||||
<entry>[$variable_name]</entry>
|
||||
<entry>Ja</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Der Name des Z<EFBFBD>hlers f<EFBFBD>r die Iterationen.</entry>
|
||||
<entry>Der Name des Zählers für die Iterationen.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>start</entry>
|
||||
@@ -58,12 +58,12 @@
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>0</emphasis></entry>
|
||||
<entry>
|
||||
Definiert die Startposition. Falls ein negativer Wert <EFBFBD>bergeben
|
||||
Definiert die Startposition. Falls ein negativer Wert übergeben
|
||||
wird, berechnet sich die Startposition ausgehend vom Ende des
|
||||
Arrays. Wenn zum Beispiel 7 Werte in einem Array enthalten sind
|
||||
und die Startposition -2 ist, ist die berechnete Startposition
|
||||
5. Unerlaubte Werte (Werte ausserhalb der Gr<EFBFBD>sse des Arrays)
|
||||
werden automatisch auf den n<EFBFBD>chstm<EFBFBD>glichen Wert gesetzt.
|
||||
5. Unerlaubte Werte (Werte ausserhalb der Grösse des Arrays)
|
||||
werden automatisch auf den nächstmöglichen Wert gesetzt.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -74,7 +74,7 @@
|
||||
<entry>
|
||||
Definiert die Schrittweite mit welcher das Array durchlaufen
|
||||
wird. 'step=2' iteriert durch 0, 2, 4, etc. Wenn ein negativer
|
||||
Wert <EFBFBD>bergeben wurde, wird das Array r<EFBFBD>ckw<EFBFBD>rts durchlaufen.
|
||||
Wert übergeben wurde, wird das Array rückwärts durchlaufen.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -169,7 +169,7 @@ id: 1000<br />
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
{* die 'loop'-Variable definiert nur die Anzahl der Iterationen,
|
||||
Sie k<EFBFBD>nnen in dieser 'section' auf jeden Wert des Templates
|
||||
Sie können in dieser 'section' auf jeden Wert des Templates
|
||||
zugreifen. Dieses Beispiel geht davon aus, dass $KundenId, $Namen und
|
||||
$Adressen Arrays sind, welche die selbe Anzahl Werte enthalten *}
|
||||
{section name=kunde loop=$KundenId}
|
||||
@@ -187,7 +187,7 @@ address: {$Adressen[kunde]}<br>
|
||||
<![CDATA[
|
||||
|
||||
id: 1000<br>
|
||||
name: Peter M<EFBFBD>ller <br>
|
||||
name: Peter Müller <br>
|
||||
adresse: 253 N 45th<br>
|
||||
<p>
|
||||
id: 1001<br>
|
||||
@@ -255,8 +255,8 @@ $smarty->assign('contact_info', $info);
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
{*
|
||||
Sections k<EFBFBD>nnen unbegrenzt tief verschachtelt werden. Mit
|
||||
verschachtelten 'sections' k<EFBFBD>nnen Sie auf komplexe Datenstrukturen
|
||||
Sections können unbegrenzt tief verschachtelt werden. Mit
|
||||
verschachtelten 'sections' können Sie auf komplexe Datenstrukturen
|
||||
zugreifen (wie zum Beispiel multidimensionale Arrays). Im folgenden
|
||||
Beispiel ist $contact_type[customer] ein Array mit Kontakttypen des
|
||||
aktuellen Kunden.
|
||||
@@ -333,7 +333,7 @@ e-mail: {$contacts[customer].email}
|
||||
</p>
|
||||
{/section}
|
||||
|
||||
{* Anm. d. <EFBFBD>bersetzers: Oft ist die Anwendung von 'foreach' k<EFBFBD>rzer. *}
|
||||
{* Anm. d. übersetzers: Oft ist die Anwendung von 'foreach' kürzer. *}
|
||||
|
||||
{foreach item=customer from=$contacts}
|
||||
<p>
|
||||
@@ -400,8 +400,8 @@ keine Werte in $custid gefunden
|
||||
<para>
|
||||
Bermerkung: Seit Smarty 1.5.0 hat sich die Syntax der 'section'
|
||||
Eigenschaften von {%sectionname.varname%} zu
|
||||
{$smarty.section.sectionname.varname} ge<EFBFBD>ndert. Die alte Syntax
|
||||
wird noch immer unterst<EFBFBD>tzt, die Dokumentation erw<EFBFBD>hnt jedoch nur
|
||||
{$smarty.section.sectionname.varname} geändert. Die alte Syntax
|
||||
wird noch immer unterstützt, die Dokumentation erwähnt jedoch nur
|
||||
noch die neue Schreibweise.
|
||||
</para>
|
||||
</note>
|
||||
@@ -411,12 +411,12 @@ keine Werte in $custid gefunden
|
||||
'index' wird verwendet, um den aktuellen Schleifen-Index
|
||||
anzuzeigen. Er startet bei 0 (beziehungsweise der definierten
|
||||
Startposition) und inkrementiert in 1-er Schritten (beziehungsweise
|
||||
der definierten Schrittgr<EFBFBD>sse).
|
||||
der definierten Schrittgrösse).
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Wenn 'step' und 'start' nicht <EFBFBD>bergeben werden, verh<EFBFBD>lt sich der
|
||||
Wenn 'step' und 'start' nicht übergeben werden, verhält sich der
|
||||
Wert wie die 'section'-Eigenschaft 'iteration', ausser dass er bei
|
||||
0 anstatt 1 beginnt.
|
||||
</para>
|
||||
@@ -456,7 +456,7 @@ keine Werte in $custid gefunden
|
||||
{$smarty.section.customer.index} id: {$custid[customer]}<br>
|
||||
{* zur Information, $custid[customer.index] und $custid[customer] bedeuten das selbe *}
|
||||
{if $custid[customer.index_prev] ne $custid[customer.index]}
|
||||
Die Kundennummer hat sich ge<EFBFBD>ndert.<br>
|
||||
Die Kundennummer hat sich geändert.<br>
|
||||
{/if}
|
||||
{/section}
|
||||
]]>
|
||||
@@ -467,11 +467,11 @@ keine Werte in $custid gefunden
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
0 id: 1000<br>
|
||||
Die Kundennummer hat sich ge<EFBFBD>ndert.<br>
|
||||
Die Kundennummer hat sich geändert.<br>
|
||||
1 id: 1001<br>
|
||||
Die Kundennummer hat sich ge<EFBFBD>ndert.<br>
|
||||
Die Kundennummer hat sich geändert.<br>
|
||||
2 id: 1002<br>
|
||||
Die Kundennummer hat sich ge<EFBFBD>ndert.<br>
|
||||
Die Kundennummer hat sich geändert.<br>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
@@ -479,8 +479,8 @@ keine Werte in $custid gefunden
|
||||
<sect2 id="section.property.index.next">
|
||||
<title>index_next</title>
|
||||
<para>
|
||||
'index_next' wird verwendet um den n<EFBFBD>chsten 'loop'-Index
|
||||
auszugeben. Bei der letzten Iteration ist dieser Wert um 1 gr<EFBFBD>sser
|
||||
'index_next' wird verwendet um den nächsten 'loop'-Index
|
||||
auszugeben. Bei der letzten Iteration ist dieser Wert um 1 grösser
|
||||
als der aktuelle 'loop'-Index (inklusive dem definierten 'step'
|
||||
Wert).
|
||||
</para>
|
||||
@@ -492,7 +492,7 @@ keine Werte in $custid gefunden
|
||||
{$smarty.section.customer.index} id: {$custid[customer]}<br>
|
||||
{* zur Information, $custid[customer.index] und $custid[customer] bedeuten das selbe *}
|
||||
{if $custid[customer.index_next] ne $custid[customer.index]}
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
{/if}
|
||||
{/section}
|
||||
]]>
|
||||
@@ -503,12 +503,12 @@ keine Werte in $custid gefunden
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
0 id: 1000<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
1 id: 1001<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
2 id: 1002<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
]]<EFBFBD>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
]]Š
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
@@ -521,7 +521,7 @@ keine Werte in $custid gefunden
|
||||
Bemerkung: Die Eigenschaften 'start', 'step' und 'max'
|
||||
beeinflussen 'iteration' nicht, die Eigenschaft 'index' jedoch
|
||||
schon. 'iteration' startet im gegensatz zu 'index' bei 1. 'rownum'
|
||||
ist ein Alias f<EFBFBD>r 'iteration' und arbeitet identisch.
|
||||
ist ein Alias für 'iteration' und arbeitet identisch.
|
||||
</para>
|
||||
<example>
|
||||
<title>'section'-Eigenschaft 'iteration'</title>
|
||||
@@ -532,7 +532,7 @@ aktuelle loop iteration: {$smarty.section.customer.iteration}<br>
|
||||
{$smarty.section.customer.index} id: {$custid[customer]}<br>
|
||||
{* zur Information, $custid[customer.index] und $custid[customer] bedeuten das gleiche *}
|
||||
{if $custid[customer.index_next] ne $custid[customer.index]}
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
{/if}
|
||||
{/section}
|
||||
]]>
|
||||
@@ -544,13 +544,13 @@ aktuelle loop iteration: {$smarty.section.customer.iteration}<br>
|
||||
<![CDATA[
|
||||
aktuelle loop iteration: 1
|
||||
5 id: 1000<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
aktuelle loop iteration: 2
|
||||
7 id: 1001<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
aktuelle loop iteration: 3
|
||||
9 id: 1002<br>
|
||||
Die Kundennummer wird sich <EFBFBD>ndern.<br>
|
||||
Die Kundennummer wird sich ändern.<br>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
@@ -635,7 +635,7 @@ aktuelle loop iteration: 3
|
||||
<title>rownum</title>
|
||||
<para>
|
||||
'rownum' wird verwendet um die aktuelle Iteration (startend bei 1)
|
||||
auszugeben. 'rownum' ist ein Alias f<EFBFBD>r 'iteration' und arbeitet
|
||||
auszugeben. 'rownum' ist ein Alias für 'iteration' und arbeitet
|
||||
identisch.
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -5,21 +5,21 @@
|
||||
<title>strip</title>
|
||||
<para>
|
||||
Webdesigner haben oft das Problem, dass Leerzeichen und
|
||||
Zeilenumbr<EFBFBD>che die Ausgabe des erzeugten HTML im Browser
|
||||
Zeilenumbrüche die Ausgabe des erzeugten HTML im Browser
|
||||
beeinflussen. Oft werden deshalb alle Tags aufeinanderfolgend im
|
||||
Template notiert, was aber zu einer schlechten Lesbarkeit f<EFBFBD>hrt.
|
||||
Template notiert, was aber zu einer schlechten Lesbarkeit führt.
|
||||
</para>
|
||||
<para>
|
||||
Aus dem Inhalt zwischen den {strip}{/strip}-Tags werden alle
|
||||
Leerzeichen und Zeilenumbr<EFBFBD>che entfernt. So k<EFBFBD>nnen Sie Ihre
|
||||
Leerzeichen und Zeilenumbrüche entfernt. So können Sie Ihre
|
||||
Templates lesbar halten, ohne sich Sorgen um die Leerzeichen zu
|
||||
machen.
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
{strip}{/strip} <EFBFBD>ndert nicht den Inhalt einer Template-Variablen.
|
||||
Daf<EFBFBD>r gibt es den <link linkend="language.modifier.strip">strip
|
||||
{strip}{/strip} ändert nicht den Inhalt einer Template-Variablen.
|
||||
Dafür gibt es den <link linkend="language.modifier.strip">strip
|
||||
Modifikator</link>.
|
||||
</para>
|
||||
</note>
|
||||
@@ -54,7 +54,7 @@
|
||||
Achtung: im obigen Beispiel beginnen und enden alle Zeilen mit
|
||||
HTML-Tags. Falls Sie Abschnitte haben, die nur Text enthalten,
|
||||
werden diese ebenfalls zusammengeschlossen. Das kann zu
|
||||
unerw<EFBFBD>nschten Resultaten f<EFBFBD>hren.
|
||||
unerwünschten Resultaten führen.
|
||||
</para>
|
||||
<para>
|
||||
Siehe auch <link linkend="language.modifier.strip">strip-Modifikator
|
||||
|
@@ -4,10 +4,10 @@
|
||||
<chapter id="language.combining.modifiers">
|
||||
<title>Kombinieren von Modifikatoren</title>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen auf eine Variable so viele Modifikatoren anwenden
|
||||
wie Sie m<EFBFBD>chten. Die Modifkatoren werden in der Reihenfolge
|
||||
Sie können auf eine Variable so viele Modifikatoren anwenden
|
||||
wie Sie möchten. Die Modifkatoren werden in der Reihenfolge
|
||||
angewandt, in der sie notiert wurden - von links nach rechts.
|
||||
Kombinierte Modifikatoren m<EFBFBD>ssen mit einem
|
||||
Kombinierte Modifikatoren müssen mit einem
|
||||
<literal>|</literal>-Zeichen (pipe) getrennt werden.
|
||||
</para>
|
||||
<example>
|
||||
@@ -18,15 +18,15 @@
|
||||
|
||||
$smarty->assign('articleTitle',
|
||||
'Einem Stadtrat in Salem in Pennsylvania (USA) droht eine
|
||||
zweij<EFBFBD>hrige Haftstrafe, da eine von ihm gehaltene Rede sechs
|
||||
Minuten l<EFBFBD>nger dauerte, als erlaubt. Die Redezeit ist auf maximal
|
||||
f<EFBFBD>nf Minuten begrenzt.');
|
||||
zweijährige Haftstrafe, da eine von ihm gehaltene Rede sechs
|
||||
Minuten länger dauerte, als erlaubt. Die Redezeit ist auf maximal
|
||||
fünf Minuten begrenzt.');
|
||||
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
Wobei das Template dann folgendes ent<EFBFBD>lt:
|
||||
Wobei das Template dann folgendes entält:
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
|
@@ -65,8 +65,8 @@ Der Wert von $name ist Bob.</programlisting>
|
||||
<para>
|
||||
Um auf zugewiesene Variablen von php aus zuzugreifen nimmt man
|
||||
<link linkend="api.get.template.vars">get_template_vars()</link>.
|
||||
Die zugewiesenen variablen sind jedoch nur w<EFBFBD>rhend bzw. nach der
|
||||
Ausgabe des Template verf<EFBFBD>gbar.
|
||||
Die zugewiesenen variablen sind jedoch nur wärhend bzw. nach der
|
||||
Ausgabe des Template verfügbar.
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
@@ -84,7 +84,7 @@ echo $smarty->get_template_vars('foo');
|
||||
// das Template in eine ungenutzte Variable ausgeben
|
||||
$nix = $smarty->fetch('index.tpl');
|
||||
|
||||
// Gibt 'smarty' aus, da die {assign} anweisung im Template ausgef<EFBFBD>hrt
|
||||
// Gibt 'smarty' aus, da die {assign} anweisung im Template ausgeführt
|
||||
// wurde
|
||||
echo $smarty->get_template_vars('foo');
|
||||
|
||||
|
@@ -2,18 +2,18 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.5 Maintainer: andreas Status: ready -->
|
||||
<sect1 id="language.function.counter">
|
||||
<title>{counter} (Z<EFBFBD>hler)</title>
|
||||
<title>{counter} (Zähler)</title>
|
||||
<para>
|
||||
{counter} wird verwendet um eine Zahlenreihe auszugeben. Sie k<EFBFBD>nnen
|
||||
den Initialwert bestimmen, den Z<EFBFBD>hlinterval, die Richtung in der
|
||||
gez<EFBFBD>hlt werden soll und ob der Wert ausgegeben wird. Sie k<EFBFBD>nnen
|
||||
mehrere Z<EFBFBD>hler gleichzeitig laufen lassen, in dem Sie ihnen
|
||||
einmalige Namen geben. Wenn Sie keinen Wert f<EFBFBD>r 'name' <EFBFBD>bergeben,
|
||||
{counter} wird verwendet um eine Zahlenreihe auszugeben. Sie können
|
||||
den Initialwert bestimmen, den Zählinterval, die Richtung in der
|
||||
gezählt werden soll und ob der Wert ausgegeben wird. Sie können
|
||||
mehrere Zähler gleichzeitig laufen lassen, in dem Sie ihnen
|
||||
einmalige Namen geben. Wenn Sie keinen Wert für 'name' übergeben,
|
||||
wird 'default' verwendet.
|
||||
</para>
|
||||
<para>
|
||||
Wenn Sie das spezielle 'assign'-Attribut verwenden, wird die Ausgabe
|
||||
des Z<EFBFBD>hlers dieser Template-Variable zugewiesen anstatt ausgegeben
|
||||
des Zählers dieser Template-Variable zugewiesen anstatt ausgegeben
|
||||
zu werden.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
@@ -38,7 +38,7 @@
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>default</emphasis></entry>
|
||||
<entry>Der Name des Z<EFBFBD>hlers.</entry>
|
||||
<entry>Der Name des Zählers.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>start</entry>
|
||||
@@ -79,10 +79,10 @@
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<example>
|
||||
<title>{counter} (Z<EFBFBD>hler)</title>
|
||||
<title>{counter} (Zähler)</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
{* z<EFBFBD>hler initialisieren *}
|
||||
{* zähler initialisieren *}
|
||||
{counter start=0 skip=2}<br />
|
||||
{counter}<br />
|
||||
{counter}<br />
|
||||
|
@@ -55,7 +55,7 @@
|
||||
<entry>boolean</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>true</emphasis></entry>
|
||||
<entry>Definiert ob der n<EFBFBD>chste Wert automatisch angesprungen
|
||||
<entry>Definiert ob der nächste Wert automatisch angesprungen
|
||||
werden soll.</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -78,27 +78,27 @@
|
||||
<entry>boolean</entry>
|
||||
<entry>No</entry>
|
||||
<entry><emphasis>false</emphasis></entry>
|
||||
<entry>Der Zyklus wird auf den ersten Wert zur<EFBFBD>ckgesetzt.</entry>
|
||||
<entry>Der Zyklus wird auf den ersten Wert zurückgesetzt.</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen durch mehrere Sets gleichzeitig iterieren, indem Sie den
|
||||
Sie können durch mehrere Sets gleichzeitig iterieren, indem Sie den
|
||||
Sets einmalige Namen geben.
|
||||
</para>
|
||||
<para>
|
||||
Um den aktuellen Wert nicht auszugeben, kann das 'print' Attribut
|
||||
auf 'false' gesetzt werden. Dies k<EFBFBD>nnte sinnvoll sein, wenn man
|
||||
einen einzelnen Wert <EFBFBD>berspringen m<EFBFBD>chte.
|
||||
auf 'false' gesetzt werden. Dies könnte sinnvoll sein, wenn man
|
||||
einen einzelnen Wert überspringen möchte.
|
||||
</para>
|
||||
<para>
|
||||
Das 'advance'-Attribut wird verwendet um einen Wert zu wiederholen.
|
||||
Wenn auf 'false' gesetzt, wird bei der n<EFBFBD>chsten Iteration der selbe
|
||||
Wenn auf 'false' gesetzt, wird bei der nächsten Iteration der selbe
|
||||
Wert erneut ausgegeben.
|
||||
</para>
|
||||
<para>
|
||||
Wenn sie das spezielle 'assign'-Attribut <EFBFBD>bergeben, wird die Ausgabe
|
||||
Wenn sie das spezielle 'assign'-Attribut übergeben, wird die Ausgabe
|
||||
der {cycle}-Funktion in dieser Template-Variable abgelegt, anstatt
|
||||
ausgegeben zu werden.
|
||||
</para>
|
||||
|
@@ -33,7 +33,7 @@
|
||||
<para>
|
||||
{debug} zeigt die 'debugging'-Konsole auf der Seite an. <link
|
||||
linkend="chapter.debugging.console">$debug</link> hat darauf keinen
|
||||
Einfluss. Da die Ausgabe zur Laufzeit geschieht, k<EFBFBD>nnen die
|
||||
Einfluss. Da die Ausgabe zur Laufzeit geschieht, können die
|
||||
Template-Namen hier nicht ausgegeben werden. Sie erhalten jedoch
|
||||
eine Liste aller mit <link linkend="api.assign">assigned</link>
|
||||
zugewiesenen Variablen und deren Werten.
|
||||
|
@@ -43,7 +43,7 @@
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<para>
|
||||
Wenn Sie das spezielle 'assign'-Attribut <EFBFBD>bergeben, wird die Ausgabe
|
||||
Wenn Sie das spezielle 'assign'-Attribut übergeben, wird die Ausgabe
|
||||
von 'eval' in dieser Template-Variable gespeichert und nicht
|
||||
ausgegeben.
|
||||
</para>
|
||||
|
@@ -5,11 +5,11 @@
|
||||
<title>{fetch}</title>
|
||||
<para>
|
||||
{fetch} wird verwendet um lokale oder via HTTP beziehungsweise FTP
|
||||
verf<EFBFBD>gbare Inhalte auszugeben. Wenn der Dateiname mit 'http://'
|
||||
anf<EFBFBD>ngt, wird die angegebene Webseite geladen und angezeigt. Wenn
|
||||
der Dateiname mit 'ftp://' anf<EFBFBD>ngt wird die Datei vom FTP-Server
|
||||
geladen und angezeigt. F<EFBFBD>r lokale Dateien muss der absolute Pfad,
|
||||
oder ein Pfad relativ zum ausgef<EFBFBD>hrten Skript <EFBFBD>bergeben werden.
|
||||
verfügbare Inhalte auszugeben. Wenn der Dateiname mit 'http://'
|
||||
anfängt, wird die angegebene Webseite geladen und angezeigt. Wenn
|
||||
der Dateiname mit 'ftp://' anfängt wird die Datei vom FTP-Server
|
||||
geladen und angezeigt. Für lokale Dateien muss der absolute Pfad,
|
||||
oder ein Pfad relativ zum ausgeführten Skript übergeben werden.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
<tgroup cols="5">
|
||||
@@ -46,15 +46,15 @@
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<para>
|
||||
Wenn Sie das spezielle 'assign'-Attribut <EFBFBD>bergeben, wird die Ausgabe
|
||||
Wenn Sie das spezielle 'assign'-Attribut übergeben, wird die Ausgabe
|
||||
der {fetch}-Funktion dieser Template-Variable zugewiesen, anstatt
|
||||
ausgegeben zu werden (seit Smarty 1.5.0).
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
HTTP-Redirects werden nicht unterst<EFBFBD>tzt, stellen Sie sicher, dass
|
||||
die aufgerufene URL falls n<EFBFBD>tig durch ein '/'-Zeichen (slash)
|
||||
HTTP-Redirects werden nicht unterstützt, stellen Sie sicher, dass
|
||||
die aufgerufene URL falls nötig durch ein '/'-Zeichen (slash)
|
||||
beendet wird.
|
||||
</para>
|
||||
</note>
|
||||
@@ -62,7 +62,7 @@
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Wenn Sicherheit eingeschaltet ist, und Dateien vom lokalen System
|
||||
geladen werden sollen, ist dies nur f<EFBFBD>r Dateien erlaubt welche sich
|
||||
geladen werden sollen, ist dies nur für Dateien erlaubt welche sich
|
||||
in einem definierten sicheren Verzeichnis befinden.
|
||||
(<link linkend="variable.secure.dir">$secure_dir</link>)
|
||||
</para>
|
||||
|
@@ -32,21 +32,21 @@
|
||||
<entry>array</entry>
|
||||
<entry>ja, ausser wenn das option Attribut verwendet wird</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>ein Array mit Werten f<EFBFBD>r die checkboxes</entry>
|
||||
<entry>ein Array mit Werten für die checkboxes</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>output</entry>
|
||||
<entry>array</entry>
|
||||
<entry>ja, ausser wenn das option Attribut verwendet wird</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>ein Array mit Werten f<EFBFBD>r checkbox Kn<EFBFBD>pfe</entry>
|
||||
<entry>ein Array mit Werten für checkbox Knöpfe</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>selected</entry>
|
||||
<entry>string/array</entry>
|
||||
<entry>No</entry>
|
||||
<entry><emphasis>empty</emphasis></entry>
|
||||
<entry>das/die ausgew<EFBFBD>hlten checkbox Elemente</entry>
|
||||
<entry>das/die ausgewählten checkbox Elemente</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>options</entry>
|
||||
@@ -60,14 +60,14 @@
|
||||
<entry>string</entry>
|
||||
<entry>No</entry>
|
||||
<entry><emphasis>empty</emphasis></entry>
|
||||
<entry>Zeichenkette die zwischen den checkbox Elementen eingef<EFBFBD>gt werden soll</entry>
|
||||
<entry>Zeichenkette die zwischen den checkbox Elementen eingefügt werden soll</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>labels</entry>
|
||||
<entry>boolean</entry>
|
||||
<entry>No</entry>
|
||||
<entry><emphasis>true</emphasis></entry>
|
||||
<entry>f<EFBFBD>gt der Ausgabe <label>-Tags hinzu</entry>
|
||||
<entry>fügt der Ausgabe <label>-Tags hinzu</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
@@ -75,12 +75,12 @@
|
||||
<para>
|
||||
html_checkboxes ist eine <link
|
||||
linkend="language.custom.functions">Funktion</link> die aus den
|
||||
<EFBFBD>bergebenen Daten html checkbox Elemente erstellt und k<EFBFBD>mmert sich
|
||||
darum welche Elemente ausgew<EFBFBD>hlt sind. Erforderliche Attribute sind
|
||||
übergebenen Daten html checkbox Elemente erstellt und kümmert sich
|
||||
darum welche Elemente ausgewählt sind. Erforderliche Attribute sind
|
||||
Wert/Ausgabe oder Options. Die Ausgabe ist XHTML kompatibel
|
||||
</para>
|
||||
<para>
|
||||
Alle Parameter die nicht in der Liste erw<EFBFBD>hnt werden, werden ausgegeben.
|
||||
Alle Parameter die nicht in der Liste erwähnt werden, werden ausgegeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>{html_checkboxes}</title>
|
||||
|
@@ -6,9 +6,9 @@
|
||||
<para>
|
||||
{html_image} ist eine <link
|
||||
linkend="language.custom.functions">eigene Funktion</link> die ein
|
||||
HTML Tag f<EFBFBD>r ein Bild erzeugt. Die H<EFBFBD>he und Breite der Ausgabe wird
|
||||
HTML Tag für ein Bild erzeugt. Die Höhe und Breite der Ausgabe wird
|
||||
automatisch aus der Bilddatei berechnet wenn die Werte nicht
|
||||
<EFBFBD>bergeben werden.
|
||||
übergeben werden.
|
||||
</para>
|
||||
|
||||
<informaltable frame="all">
|
||||
@@ -39,8 +39,8 @@
|
||||
<entry>height</entry>
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>Normale H<EFBFBD>he des Bildes</emphasis></entry>
|
||||
<entry>H<EFBFBD>he des Bildes</entry>
|
||||
<entry><emphasis>Normale Höhe des Bildes</emphasis></entry>
|
||||
<entry>Höhe des Bildes</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>width</entry>
|
||||
@@ -54,7 +54,7 @@
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>DOCUMENT_ROOT</emphasis></entry>
|
||||
<entry>Basisverzeichnis f<EFBFBD>r relative Pfadangaben</entry>
|
||||
<entry>Basisverzeichnis für relative Pfadangaben</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>alt</entry>
|
||||
@@ -68,35 +68,35 @@
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Link f<EFBFBD>r das Bild</entry>
|
||||
<entry>Link für das Bild</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>path_prefix</entry>
|
||||
<entry>string</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Pr<EFBFBD>fix f<EFBFBD>r den Pfad zum Bild</entry>
|
||||
<entry>Präfix für den Pfad zum Bild</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
|
||||
<para>
|
||||
basedir ist der Basispfad der f<EFBFBD>r die Verlinkung verwendet werden
|
||||
soll. Wenn kein Wert <EFBFBD>bergeben wird, wird die <link
|
||||
basedir ist der Basispfad der für die Verlinkung verwendet werden
|
||||
soll. Wenn kein Wert übergeben wird, wird die <link
|
||||
linkend="language.variables.smarty">Umgebungsvariable</link>
|
||||
DOCUMENT_ROOT verwendet. Wenn <link
|
||||
linkend="variable.security">Sicherheit</link> eingeschaltet ist,
|
||||
muss das Bild in einem sicheren Verzeichnis liegen.
|
||||
</para>
|
||||
<para>
|
||||
<parameter>href</parameter> ist das href Attribut f<EFBFBD>r das
|
||||
Image-Tag. Wenn dieser Wert <EFBFBD>bergeben wird, wird um das Bild ein
|
||||
<parameter>href</parameter> ist das href Attribut für das
|
||||
Image-Tag. Wenn dieser Wert übergeben wird, wird um das Bild ein
|
||||
<a href="LINKVALUE"><a> Tag erzeugt.
|
||||
</para>
|
||||
<para>
|
||||
<parameter>path_prefix</parameter> ist ein optionaler Pr<EFBFBD>fix der dem
|
||||
Bildpfad vorangestellt wird. Die ist n<EFBFBD>tzlich wenn zum Beispiel f<EFBFBD>r
|
||||
<parameter>path_prefix</parameter> ist ein optionaler Präfix der dem
|
||||
Bildpfad vorangestellt wird. Die ist nützlich wenn zum Beispiel für
|
||||
den Bildpfad ein anderer Servername verwendet werden soll.
|
||||
</para>
|
||||
<para>
|
||||
@@ -106,10 +106,10 @@
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
{html_image} greift auf das Dateisystem zu um H<EFBFBD>he und Breite zu
|
||||
{html_image} greift auf das Dateisystem zu um Höhe und Breite zu
|
||||
errechnen. Wenn Sie <link linkend="caching">caching</link> nicht
|
||||
verwenden sollten Sie normalerweise auf diese Funktion aus
|
||||
performance Gr<EFBFBD>nden verzichten.
|
||||
performance Gründen verzichten.
|
||||
</para>
|
||||
</note>
|
||||
<example>
|
||||
@@ -124,7 +124,7 @@ Wobei index.tpl wie folgt aussieht:
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
M<EFBFBD>gliche Ausgabe:
|
||||
Mögliche Ausgabe:
|
||||
</para>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
|
@@ -5,9 +5,9 @@
|
||||
<title>html_options (Ausgabe von HTML-Options)</title>
|
||||
<para>
|
||||
{html_options} wird verwendet um HTML-Options Listen mit den
|
||||
<EFBFBD>bergebenen Daten zu erzeugen. Die <link
|
||||
linkend="language.custom.functions">Funktion</link> k<EFBFBD>mmert sich
|
||||
ebenfalls um das setzen des ausgew<EFBFBD>hlten Standardwertes. Die
|
||||
übergebenen Daten zu erzeugen. Die <link
|
||||
linkend="language.custom.functions">Funktion</link> kümmert sich
|
||||
ebenfalls um das setzen des ausgewählten Standardwertes. Die
|
||||
Attribute 'values' und 'output' sind erforderlich, ausser man
|
||||
verwendet das Attribut 'options'.
|
||||
</para>
|
||||
@@ -34,21 +34,21 @@
|
||||
<entry>array</entry>
|
||||
<entry>Ja, ausser 'options'-Attribut wird verwendet.</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Array mit Werten f<EFBFBD>r die dropdown-Liste.</entry>
|
||||
<entry>Array mit Werten für die dropdown-Liste.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>output</entry>
|
||||
<entry>array</entry>
|
||||
<entry>Ja, ausser 'options'-Attribut wird verwendet.</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>Arrays mit Namen f<EFBFBD>r die dropdown-Liste.</entry>
|
||||
<entry>Arrays mit Namen für die dropdown-Liste.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>selected</entry>
|
||||
<entry>string/array</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry><emphasis>empty</emphasis></entry>
|
||||
<entry>Das ausgew<EFBFBD>hlte Array Element.</entry>
|
||||
<entry>Das ausgewählte Array Element.</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>options</entry>
|
||||
@@ -64,7 +64,7 @@
|
||||
<para>
|
||||
Wenn ein Wert als Array erkannt wird, wird er als HTML-OPTGROUP
|
||||
ausgegeben und die Werte werden in Gruppen dargestellt. Rekursion
|
||||
wird unterst<EFBFBD>tzt. Die Ausgabe ist XHTML kompatibel.
|
||||
wird unterstützt. Die Ausgabe ist XHTML kompatibel.
|
||||
</para>
|
||||
<para>
|
||||
Wenn das (optionale) Attribute <emphasis>name</emphasis> angegeben
|
||||
@@ -74,7 +74,7 @@
|
||||
<para>
|
||||
Alle Parameter die deren Namen nicht in der obigen Liste genannt
|
||||
wurde, werden dem <select>-Tag als Name/Wert-Paare
|
||||
hinzugef<EFBFBD>gt. Die Parameter werden ignoriert, wenn kein
|
||||
hinzugefügt. Die Parameter werden ignoriert, wenn kein
|
||||
<emphasis>name</emphasis>-Attribute angegeben wurde.
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -92,7 +92,7 @@
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Javascript ist wahrscheinlich die beste Methode, die Daten f<EFBFBD>r WebSpider unzugänglich zu machen.
|
||||
Javascript ist wahrscheinlich die beste Methode, die Daten für WebSpider unzugänglich zu machen.
|
||||
</para>
|
||||
</note>
|
||||
<example>
|
||||
|
@@ -4,12 +4,12 @@
|
||||
<chapter id="language.modifiers">
|
||||
<title>Variablen-Modifikatoren</title>
|
||||
<para>
|
||||
Variablen-Modifikatoren k<EFBFBD>nnen auf alle Variablen angewendet
|
||||
werden, um deren Inhalt zu ver<EFBFBD>ndern. Dazu h<EFBFBD>ngen sie einfach
|
||||
Variablen-Modifikatoren können auf alle Variablen angewendet
|
||||
werden, um deren Inhalt zu verändern. Dazu hängen sie einfach
|
||||
ein <literal>|</literal> (Pipe-Zeichen) und den Modifikatornamen an
|
||||
die entsprechende Variable an. Ein Modifikator <EFBFBD>ber Parameter in
|
||||
die entsprechende Variable an. Ein Modifikator über Parameter in
|
||||
seiner Arbeitsweise beinflusst werden. Diese Parameter werden dem
|
||||
Modifikatorname angeh<EFBFBD>ngt und mit <literal>:</literal> getrennt.
|
||||
Modifikatorname angehängt und mit <literal>:</literal> getrennt.
|
||||
</para>
|
||||
<example>
|
||||
<title>Modifikator Beispiel</title>
|
||||
@@ -45,7 +45,7 @@
|
||||
des Arrays $artikelTitel aus.)
|
||||
</para>
|
||||
<para>
|
||||
Modifikatoren k<EFBFBD>nnen aus Ihrem <link
|
||||
Modifikatoren können aus Ihrem <link
|
||||
linkend="variable.plugins.dir">$plugins_dir</link> automatisch
|
||||
geladen (sehen Sie dazu auch <link
|
||||
linkend="plugins.naming.conventions">Naming Conventions</link>) oder
|
||||
@@ -53,17 +53,17 @@
|
||||
linkend="api.register.modifier">register_modifier</link>).
|
||||
</para>
|
||||
<para>
|
||||
Zudem k<EFBFBD>nnen alle PHP-Funktionen implizit als Modifikatoren
|
||||
Zudem können alle PHP-Funktionen implizit als Modifikatoren
|
||||
verwendet werden. (Das Beispiel mit dem <literal>@count</literal>
|
||||
Modifier verwendet die Funktion 'count()' von PHP und keinen Smarty
|
||||
Modifikator) PHP Funktionen zu verwenden er<EFBFBD>ffnet zwei Probleme:
|
||||
Modifikator) PHP Funktionen zu verwenden eröffnet zwei Probleme:
|
||||
erstens: manchmal ist die Parameter Reiehnfolge nicht
|
||||
erw<EFBFBD>nscht. (<literal>{"%2.f"|sprintf:$float}</literal> funktioniert
|
||||
erwünscht. (<literal>{"%2.f"|sprintf:$float}</literal> funktioniert
|
||||
zwar, sieht aber als
|
||||
<literal>{$float|string_format:"%2.f"}</literal> das durch Smarty
|
||||
geliefert wird, besser aus. Zweitens: wenn <link
|
||||
linkend="variable.security">$security</link> auf TRUE gesetzt ist,
|
||||
m<EFBFBD>ssen alle verwendeten PHP Funktionen im <link
|
||||
müssen alle verwendeten PHP Funktionen im <link
|
||||
linkend="variable.security.settings">
|
||||
$security_settings['MODIFIER_FUNCS']</link>-Array enthalten sein.
|
||||
</para>
|
||||
|
@@ -4,7 +4,7 @@
|
||||
<sect1 id="language.modifier.capitalize">
|
||||
<title>capitalize (in Grossbuchstaben schreiben)</title>
|
||||
<para>
|
||||
Wird verwendet um den Anfangsbuchstaben aller W<EFBFBD>rter in der
|
||||
Wird verwendet um den Anfangsbuchstaben aller Wörter in der
|
||||
Variable gross (upper case) zu schreiben.
|
||||
</para>
|
||||
<informaltable frame="all">
|
||||
@@ -18,7 +18,7 @@
|
||||
<row>
|
||||
<entry>Parameter Position</entry>
|
||||
<entry>Typ</entry>
|
||||
<entry>Ben<EFBFBD>tigt</entry>
|
||||
<entry>Benötigt</entry>
|
||||
<entry>Standardwert</entry>
|
||||
<entry>Beschreibung</entry>
|
||||
</row>
|
||||
@@ -29,8 +29,8 @@
|
||||
<entry>boolean</entry>
|
||||
<entry>Nein</entry>
|
||||
<entry>false</entry>
|
||||
<entry>Bestimmt ob W<EFBFBD>rter die Ziffern enthalten auch in
|
||||
Gro<EFBFBD>schreibung gewandelt werden</entry>
|
||||
<entry>Bestimmt ob Wörter die Ziffern enthalten auch in
|
||||
Großschreibung gewandelt werden</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
|
@@ -78,7 +78,7 @@ Tuesday, February 6, 2001
|
||||
|
||||
%D - so wie %m/%d/%y
|
||||
|
||||
%e - Tag des Monats als Dezimal-Wert, einstelligen Werten wird ein Leerzeichen voran gestellt (Wertebereich <EFBFBD> 0<EFBFBD> bis <EFBFBD>31<EFBFBD>)
|
||||
%e - Tag des Monats als Dezimal-Wert, einstelligen Werten wird ein Leerzeichen voran gestellt (Wertebereich Ž 0Ž bis Ž31Ž)
|
||||
|
||||
%g - wie %G, aber ohne Jahrhundert.
|
||||
|
||||
|
@@ -5,7 +5,7 @@
|
||||
<title>Aus einem PHP-Skript zugewiesene Variablen</title>
|
||||
<para>
|
||||
Variablen die in einem PHP Skript <link
|
||||
linkend="api.assign">assigned</link> mit zugewiesen wurden, m<EFBFBD>ssen
|
||||
linkend="api.assign">assigned</link> mit zugewiesen wurden, müssen
|
||||
mit eine Dollar Zeichen <literal>$</literal> versehen werden. Auf
|
||||
die gleiche Art werden Variablen ausgegeben, die im Template mit <link
|
||||
linkend="language.function.assign">{assign}</link> zugewiesen
|
||||
@@ -34,7 +34,7 @@ $smarty->display('index.tpl');
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
Hallo {$vorname} {$nachname}, sch<EFBFBD>n, dass Du es einrichten kannst.
|
||||
Hallo {$vorname} {$nachname}, schön, dass Du es einrichten kannst.
|
||||
<br />
|
||||
{*
|
||||
das hier funktioniert nicht, da bei Variablennamen auf
|
||||
@@ -51,7 +51,7 @@ Diese Woche findet das Treffen in {$treffpunkt} statt.
|
||||
</para>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Hallo Andreas Halter, sch<EFBFBD>n, dass Du es einrichten kannst.
|
||||
Hallo Andreas Halter, schön, dass Du es einrichten kannst.
|
||||
<br />
|
||||
Diese Woche findet das Treffen in statt.
|
||||
Diese Woche findet das Treffen in New York statt.
|
||||
@@ -61,8 +61,8 @@ Diese Woche findet das Treffen in New York statt.
|
||||
<sect2 id="language.variables.assoc.arrays">
|
||||
<title>Assoziative Arrays</title>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen auch auf die Werte eines in PHP zugewiesenen
|
||||
assoziativen Arrays zugreifen, indem Sie den Schl<EFBFBD>ssel (Indexwert)
|
||||
Sie können auch auf die Werte eines in PHP zugewiesenen
|
||||
assoziativen Arrays zugreifen, indem Sie den Schlüssel (Indexwert)
|
||||
nach einem '.'-Zeichen (Punkt) notieren.
|
||||
</para>
|
||||
<example>
|
||||
@@ -88,7 +88,7 @@ $smarty->display('index.tpl');
|
||||
<![CDATA[
|
||||
{$kontakte.fax}<br />
|
||||
{$kontakte.email}<br />
|
||||
{* auch multidimensionale Arrays k<EFBFBD>nnen so angesprochen werden *}
|
||||
{* auch multidimensionale Arrays können so angesprochen werden *}
|
||||
{$kontakte.telefon.privat}<br />
|
||||
{$kontakte.telefon.mobil}<br />
|
||||
]]>
|
||||
@@ -109,11 +109,11 @@ zaphod@slartibartfast.example.com<br />
|
||||
<sect2 id="language.variables.array.indexes">
|
||||
<title>Array Index</title>
|
||||
<para>
|
||||
Arrays k<EFBFBD>nnen - <EFBFBD>hnlich der PHP-Syntax - auch <EFBFBD>ber ihren Index
|
||||
Arrays können - ähnlich der PHP-Syntax - auch über ihren Index
|
||||
angesprochen werden.
|
||||
</para>
|
||||
<example>
|
||||
<title>Zugriff <EFBFBD>ber den Array Index</title>
|
||||
<title>Zugriff über den Array Index</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -134,7 +134,7 @@ $smarty->display('index.tpl');
|
||||
<![CDATA[
|
||||
{$kontakte[0]}<br />
|
||||
{$kontakte[1]}<br />
|
||||
{* auch hier sind multidimensionale Arrays m<EFBFBD>glich *}
|
||||
{* auch hier sind multidimensionale Arrays möglich *}
|
||||
{$kontakte[0][0]}<br />
|
||||
{$kontakte[0][1]}<br />
|
||||
]]>
|
||||
@@ -156,7 +156,7 @@ zaphod@slartibartfast.example.com<br />
|
||||
<sect2 id="language.variables.objects">
|
||||
<title>Objekte</title>
|
||||
<para>
|
||||
Attribute von aus PHP zugewiesenen Objekten k<EFBFBD>nnen <EFBFBD>ber
|
||||
Attribute von aus PHP zugewiesenen Objekten können über
|
||||
das '->'-Symbol erreicht werden.
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -47,7 +47,7 @@
|
||||
</example>
|
||||
<note>
|
||||
<para>
|
||||
Aus historischen Gr<EFBFBD>nden kann {$SCRIPT_NAME} verwendet werden,
|
||||
Aus historischen Gründen kann {$SCRIPT_NAME} verwendet werden,
|
||||
allerdings ist {$smarty.server.SCRIPT_NAME} die empfohlene
|
||||
Variante.
|
||||
</para>
|
||||
@@ -56,12 +56,12 @@
|
||||
<sect2 id="language.variables.smarty.now">
|
||||
<title>{$smarty.now}</title>
|
||||
<para>
|
||||
Die momentane Unix-Timestamp kann <EFBFBD>ber {$smarty.now} angefragt
|
||||
Die momentane Unix-Timestamp kann über {$smarty.now} angefragt
|
||||
werden. Diese Zahl ist die Summe der verstrichenen Sekunden seit
|
||||
Beginn der UNIX-Epoche (1. Januar 1970) und kann zur Anzeige
|
||||
direkt dem <link
|
||||
linkend="language.modifier.date.format">'date_format'-Modifikator
|
||||
</link> <EFBFBD>bergeben werden.
|
||||
</link> übergeben werden.
|
||||
</para>
|
||||
<example>
|
||||
<title>Verwendung von {$smarty.now}</title>
|
||||
@@ -139,7 +139,7 @@
|
||||
<title>{$smarty.ldelim}, {$smarty.rdelim}</title>
|
||||
<para>
|
||||
Diese Variablen dienen dazu den linken und rechten Trennzeichen
|
||||
wortw<EFBFBD>rtlich auszugeben. Siehe auch <link
|
||||
wortwörtlich auszugeben. Siehe auch <link
|
||||
linkend="language.function.ldelim">{ldelim},{rdelim}</link>.
|
||||
</para>
|
||||
<para>
|
||||
|
@@ -22,14 +22,14 @@
|
||||
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<EFBFBD>nnen der Programmierer die
|
||||
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<EFBFBD>lich für die Ausgabe verwendet wird, kann sie auch
|
||||
ausschließ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
|
||||
@@ -82,7 +82,7 @@
|
||||
</listitem>
|
||||
<listitem>
|
||||
<para>
|
||||
Konfigurierbare Syntax f<EFBFBD>r <link
|
||||
Konfigurierbare Syntax für <link
|
||||
linkend="variable.left.delimiter">Template-Tags</link>: Sie
|
||||
können {}, {{}}, <!--{}-->, etc. verwenden.
|
||||
</para>
|
||||
@@ -92,7 +92,7 @@
|
||||
<link
|
||||
linkend="language.function.if">'if/elseif/else/endif'-Konstrukte</link>
|
||||
werden direkt dem PHP-Parser übergeben. Somit können {if
|
||||
...} Ausdr<EFBFBD>cke sowohl sehr einfach als auch sehr komplex sein.
|
||||
...} Ausdrücke sowohl sehr einfach als auch sehr komplex sein.
|
||||
</para>
|
||||
</listitem>
|
||||
<listitem>
|
||||
@@ -184,7 +184,7 @@
|
||||
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<EFBFBD>r diesen Zwecke eine
|
||||
Smarty zu konfigurieren! Benutzen Sie für diesen Zwecke eine
|
||||
Instanz der Smarty-Klasse.
|
||||
</para>
|
||||
</note>
|
||||
@@ -192,7 +192,7 @@
|
||||
Folgende Library Dateien werden mit Smarty geliefert und werden benötigt:
|
||||
</para>
|
||||
<example>
|
||||
<title>Ben<EFBFBD>tigte Smarty-Library Dateien</title>
|
||||
<title>Benötigte Smarty-Library Dateien</title>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Smarty.class.php
|
||||
@@ -420,7 +420,7 @@ ini_set('include_path', ini_get('include_path').PATH_SEPARATOR.'c:/webroot/lib/S
|
||||
'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<EFBFBD>hnlich in '/usr/local/apache/conf/')
|
||||
der httpd.conf (gewöhnlich in '/usr/local/apache/conf/')
|
||||
nachsehen, unter welchem Benutzer Ihr Server läuft.
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -12,7 +12,7 @@
|
||||
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<EFBFBD>sung.
|
||||
Template-Lösung.
|
||||
</para>
|
||||
<para>
|
||||
Als Beispiel: In unserer Firma funktioniert die Entwicklung einer
|
||||
@@ -76,7 +76,7 @@
|
||||
vereinfachen?
|
||||
</para>
|
||||
<para>
|
||||
Dann kam uns die Idee, aus der schlie<EFBFBD>lich Smarty wurde. Wir wussten
|
||||
Dann kam uns die Idee, aus der schließ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
|
||||
|
@@ -6,7 +6,7 @@
|
||||
<para>
|
||||
Smarty erlaubt es, auf <ulink
|
||||
url="&url.php-manual;object">PHP-Objekte</ulink> durch das Template
|
||||
zuzugreifen. Daf<EFBFBD>r gibt es zwei Wege. Der erste ist, Objekte zu
|
||||
zuzugreifen. Dafür gibt es zwei Wege. Der erste ist, Objekte zu
|
||||
<link linkend="api.register.object">registrieren</link> und wie auf
|
||||
eine <link linkend="language.custom.functions">eigene
|
||||
Funktion</link> zuzugreifen. Der andere Weg ist, das Objekt dem
|
||||
@@ -14,40 +14,40 @@
|
||||
und darauf wie auf andere Variablen zuzugreifen. Die erste Methode
|
||||
hat eine nettere Template Syntax und ist sicherer da der Zugriff auf
|
||||
ein registriertes Objekt mit Sicherheitseinstellungen kontrolliert
|
||||
werden kann. Der Nachteil ist, dass <EFBFBD>ber registrierte Objekte nicht
|
||||
in einer Schlaufe gelaufen werden kann und, dass es nicht m<EFBFBD>glich
|
||||
werden kann. Der Nachteil ist, dass über registrierte Objekte nicht
|
||||
in einer Schlaufe gelaufen werden kann und, dass es nicht möglich
|
||||
ist, Arrays registrierten Objekten anzulegen. Welchen Weg Sie
|
||||
einschlagen wird von Ihren Bed<EFBFBD>rfnissen definiert, die erste Methode
|
||||
einschlagen wird von Ihren Bedürfnissen definiert, die erste Methode
|
||||
ist jedoch zu bevorzugen.
|
||||
</para>
|
||||
<para>
|
||||
Wenn die <link
|
||||
linkend="variable.security">Sicherheitsfunktionen</link>
|
||||
eingeschaltet sind, k<EFBFBD>nnen keine private Methoden (solche die einen
|
||||
eingeschaltet sind, können keine private Methoden (solche die einen
|
||||
'_'-Prefix tragen) aufgerufen werden. Wenn eine Methode und eine
|
||||
Eigeschaft mit dem gleichen Namen existieren wird die Methode
|
||||
verwendet.
|
||||
</para>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen den Zugriff auf Methoden und Eigenschaften
|
||||
einschr<EFBFBD>nken indem Sie sie als Array als dritten
|
||||
Registrationsparameter <EFBFBD>bergeben.
|
||||
Sie können den Zugriff auf Methoden und Eigenschaften
|
||||
einschränken indem Sie sie als Array als dritten
|
||||
Registrationsparameter übergeben.
|
||||
</para>
|
||||
<para>
|
||||
Normalerweise werden Parameter welche einem Objekt via Template
|
||||
<EFBFBD>bergeben werden genau so <EFBFBD>bergeben wie dies bei normalen <link
|
||||
übergeben werden genau so übergeben wie dies bei normalen <link
|
||||
linkend="language.custom.functions">eigenen Funktionen</link> der
|
||||
Fall ist. Das erste Objekt ist ein assoziatives Array und das
|
||||
zweite das Smarty Objekt selbst. Wenn Sie die Parameter einzeln
|
||||
erhalten m<EFBFBD>chten k<EFBFBD>nnen Sie den vierten Parameter auf
|
||||
erhalten möchten können Sie den vierten Parameter auf
|
||||
<literal>false</literal> setzen.
|
||||
</para>
|
||||
<para>
|
||||
Der optionale f<EFBFBD>nfte Parameter hat nur einen Effekt wenn
|
||||
Der optionale fünfte Parameter hat nur einen Effekt wenn
|
||||
<parameter>format</parameter> = <literal>true</literal> ist und eine
|
||||
Liste von Methoden enth<EFBFBD>lt die als Block verarbeitet werden sollen.
|
||||
Liste von Methoden enthält die als Block verarbeitet werden sollen.
|
||||
Das bedeutet, dass solche Methoden ein schliessendes Tag im Template
|
||||
enthalten m<EFBFBD>ssen
|
||||
enthalten müssen
|
||||
(<literal>{foobar->meth2}...{/foobar->meth2}</literal>) und die
|
||||
Parameter zu den Funktionen die selbe Syntax haben wie
|
||||
block-function-plugins: sie erhalten also die 4 Parameter
|
||||
@@ -73,12 +73,12 @@ class My_Object {
|
||||
$myobj = new My_Object;
|
||||
// Objekt registrieren (referenz)
|
||||
$smarty->register_object("foobar",$myobj);
|
||||
// Zugriff auf Methoden und Eigeschaften einschr<EFBFBD>nken
|
||||
// Zugriff auf Methoden und Eigeschaften einschränken
|
||||
$smarty->register_object("foobar",$myobj,array('meth1','meth2','prop1'));
|
||||
// wenn wir das traditionelle Parameterformat verwenden wollen, <EFBFBD>bergeben wir false f<EFBFBD>r den Parameter format
|
||||
// wenn wir das traditionelle Parameterformat verwenden wollen, übergeben wir false für den Parameter format
|
||||
$smarty->register_object("foobar",$myobj,null,false);
|
||||
|
||||
// Objekte zuweisen (auch via Referenz m<EFBFBD>glich)
|
||||
// Objekte zuweisen (auch via Referenz möglich)
|
||||
$smarty->assign_by_ref("myobj", $myobj);
|
||||
|
||||
$smarty->display('index.tpl');
|
||||
@@ -86,7 +86,7 @@ $smarty->display('index.tpl');
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
Und hier das dazugeh<EFBFBD>rige index.tpl:
|
||||
Und hier das dazugehörige index.tpl:
|
||||
</para>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
|
@@ -25,7 +25,7 @@
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// f<EFBFBD>gen Sie folgende Zeilen in Ihre Applikation ein
|
||||
// fügen Sie folgende Zeilen in Ihre Applikation ein
|
||||
function protect_email($tpl_output, &$smarty)
|
||||
{
|
||||
$tpl_output = preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
|
||||
|
@@ -5,12 +5,12 @@
|
||||
<title>Postfilter</title>
|
||||
<para>
|
||||
Template Postfilter sind Filter, welche auf das Template nach dessen Kompilierung
|
||||
angewendet werden. Postfilter k<EFBFBD>nnen auf verschiedene Arten
|
||||
angewendet werden. Postfilter können auf verschiedene Arten
|
||||
geladen werden. Man kann sie <link linkend="api.register.prefilter">registrieren</link>,
|
||||
aus dem Plugin-Verzeichnis mit <link linkend="api.load.filter">load_filter()</link> laden
|
||||
oder <link linkend="variable.autoload.filters">$autoload_filters</link> verwenden.
|
||||
Smarty <EFBFBD>bergibt der Funktion als ersten Parameter den Template-Quellcode und erwartet
|
||||
als R<EFBFBD>ckgabewert den bearbeiteten Quellcode.
|
||||
Smarty übergibt der Funktion als ersten Parameter den Template-Quellcode und erwartet
|
||||
als Rückgabewert den bearbeiteten Quellcode.
|
||||
</para>
|
||||
<example>
|
||||
<title>Template Postfilter verwenden</title>
|
||||
@@ -18,7 +18,7 @@
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// f<EFBFBD>gen Sie folgende Zeilen in Ihre Applikation ein
|
||||
// fügen Sie folgende Zeilen in Ihre Applikation ein
|
||||
function add_header_comment($tpl_source, &$smarty)
|
||||
{
|
||||
return "<?php echo \"<!-- Created by Smarty! -->\n\" ?>\n".$tpl_source;
|
||||
|
@@ -5,13 +5,13 @@
|
||||
<title>Prefilter</title>
|
||||
<para>
|
||||
Template Prefilter sind Filter, welche auf das Template vor dessen Kompilierung
|
||||
angewendet werden. Dies ist n<EFBFBD>tzlich, um zum Beispiel Kommentare zu entfernen
|
||||
oder um den Inhalt des Templates zu analysieren. Prefilter k<EFBFBD>nnen auf verschiedene
|
||||
angewendet werden. Dies ist nützlich, um zum Beispiel Kommentare zu entfernen
|
||||
oder um den Inhalt des Templates zu analysieren. Prefilter können auf verschiedene
|
||||
Arten geladen werden. Man kann sie <link linkend="api.register.prefilter">registrieren</link>,
|
||||
aus dem Plugin-Verzeichnis mit <link linkend="api.load.filter">load_filter()</link> laden
|
||||
oder <link linkend="variable.autoload.filters">$autoload_filters</link> verwenden.
|
||||
Smarty <EFBFBD>bergibt der Funktion als ersten Parameter den Template-Quellcode und erwartet
|
||||
als R<EFBFBD>ckgabewert den bearbeiteten Quellcode.
|
||||
Smarty übergibt der Funktion als ersten Parameter den Template-Quellcode und erwartet
|
||||
als Rückgabewert den bearbeiteten Quellcode.
|
||||
</para>
|
||||
<example>
|
||||
<title>Template Prefilter verwenden</title>
|
||||
@@ -22,7 +22,7 @@
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// f<EFBFBD>gen Sie folgende Zeilen in Ihre Applikation ein
|
||||
// fügen Sie folgende Zeilen in Ihre Applikation ein
|
||||
function remove_dw_comments($tpl_source, &$smarty)
|
||||
{
|
||||
return preg_replace("/<!--#.*-->/U",'',$tpl_source);
|
||||
|
@@ -4,8 +4,8 @@
|
||||
<sect1 id="section.template.cache.handler.func">
|
||||
<title>Cache Handler Funktion</title>
|
||||
<para>
|
||||
Als Alternative zum normalen dateibasierten Caching-Mechanismus k<EFBFBD>nnen Sie
|
||||
eine eigene Cache-Handler Funktion zum lesen, schreiben und l<EFBFBD>schen von
|
||||
Als Alternative zum normalen dateibasierten Caching-Mechanismus können Sie
|
||||
eine eigene Cache-Handler Funktion zum lesen, schreiben und löschen von
|
||||
Cache-Dateien definieren.
|
||||
</para>
|
||||
<para>
|
||||
@@ -14,17 +14,17 @@
|
||||
<link linkend="variable.cache.handler.func">$cache_handler_func</link> zu.
|
||||
Smarty wird von da an Ihre Funktion zur Bearbeitung des Caches verwenden.
|
||||
Als erster Parameter wird die 'action' mit einem der folgendende Werte
|
||||
<EFBFBD>bergeben: 'read', 'write' und 'clear'. Als zweiter Parameter
|
||||
wird das Smarty-Objekt <EFBFBD>bergeben, als dritter der gecachte Inhalt. Bei einem
|
||||
'write' <EFBFBD>bergibt Smarty den gecachten Inhalt, bei 'read' <EFBFBD>bergibt Smarty die
|
||||
übergeben: 'read', 'write' und 'clear'. Als zweiter Parameter
|
||||
wird das Smarty-Objekt übergeben, als dritter der gecachte Inhalt. Bei einem
|
||||
'write' übergibt Smarty den gecachten Inhalt, bei 'read' übergibt Smarty die
|
||||
Variable als Referenz und erwartet, dass Ihre Funktion die Inhalte zuweist.
|
||||
Bei 'clear' k<EFBFBD>nnen Sie eine dummy-Variable <EFBFBD>bergeben. Als vierter Parameter
|
||||
wird der Template-Name <EFBFBD>bergeben (verwendet bei 'write'/'read'), als f<EFBFBD>nfter
|
||||
Bei 'clear' können Sie eine dummy-Variable übergeben. Als vierter Parameter
|
||||
wird der Template-Name übergeben (verwendet bei 'write'/'read'), als fünfter
|
||||
Parameter die 'cache_id' (optional) und als sechster die 'compile_id' (auch optional).
|
||||
</para>
|
||||
<para>
|
||||
Der letzte Parameter (<parameter>$exp_time</parameter>) wurde in
|
||||
Smarty-2.6.0 hinzugef<EFBFBD>gt.
|
||||
Smarty-2.6.0 hinzugefügt.
|
||||
</para>
|
||||
<example>
|
||||
<title>Beispiel mit einer MySQL Datenbank als Datenquelle</title>
|
||||
@@ -112,10 +112,10 @@ function mysql_cache_handler($action, &$smarty_obj, &$cache_content, $tp
|
||||
break;
|
||||
case 'clear':
|
||||
|
||||
// Cache Informationen l<EFBFBD>schen
|
||||
// Cache Informationen löschen
|
||||
if(empty($cache_id) && empty($compile_id) && empty($tpl_file)) {
|
||||
|
||||
// alle l<EFBFBD>schen
|
||||
// alle löschen
|
||||
$results = mysql_query("delete from CACHE_PAGES");
|
||||
} else {
|
||||
$results = mysql_query("delete from CACHE_PAGES where CacheID='$CacheID'");
|
||||
|
@@ -5,7 +5,7 @@
|
||||
<title>Die Ausgabe von cachebaren Plugins Kontrollieren</title>
|
||||
<para>
|
||||
Seit Smarty-2.6.0 kann bei der Registrierung angegeben werden ob ein
|
||||
Plugin cached werden soll. Der dritte Parameter f<EFBFBD>r <link
|
||||
Plugin cached werden soll. Der dritte Parameter für <link
|
||||
linkend="api.register.block">register_block</link>, <link
|
||||
linkend="api.register.compiler.function">register_compiler_function</link>
|
||||
und <link linkend="api.register.function">register_function</link>
|
||||
@@ -16,7 +16,7 @@
|
||||
Wenn ein Plugin mit <parameter>$cacheable=false</parameter>
|
||||
registriert wird, wird er bei jedem Besuch der Seite aufgerufen,
|
||||
selbst wenn die Site aus dem Cache stammt. Die Pluginfunktion
|
||||
verh<EFBFBD>lt sich ein wenig wie <link
|
||||
verhält sich ein wenig wie <link
|
||||
linkend="plugins.inserts">{insert}</link>.
|
||||
</para>
|
||||
<para>
|
||||
@@ -72,7 +72,7 @@ Verbleibende Zeit: {remain endtime=$obj->endtime}
|
||||
</para>
|
||||
</example>
|
||||
<example>
|
||||
<title>Verhindern dass Template Bl<EFBFBD>cke gecached werden</title>
|
||||
<title>Verhindern dass Template Blöcke gecached werden</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
index.php:
|
||||
|
@@ -4,39 +4,39 @@
|
||||
<sect1 id="caching.groups">
|
||||
<title>Cache-Gruppen</title>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen auch eine feinere Gruppierung vornehmen, indem Sie
|
||||
Sie können auch eine feinere Gruppierung vornehmen, indem Sie
|
||||
'cache_id'-Gruppen erzeugen. Dies erreichen Sie, indem Sie jede Cache-Untergruppe
|
||||
durch ein '|'-Zeichen (pipe) in der 'cache_id' abtrennen. Sie k<EFBFBD>nnen so viele
|
||||
Untergruppen erstellen, wie Sie m<EFBFBD>chten.
|
||||
durch ein '|'-Zeichen (pipe) in der 'cache_id' abtrennen. Sie können so viele
|
||||
Untergruppen erstellen, wie Sie möchten.
|
||||
</para>
|
||||
<para>
|
||||
|
||||
Man kann Cache-Gruppen wie eine Verzeichnishierarchie
|
||||
betrachten. Zum Beispiel kann man sich die Cache-Gruppe "a|b|c" als
|
||||
eine Verzeichnisstruktur "/a/b/c" angesehen weden. clear_cache(null,
|
||||
'a|b|c') w<EFBFBD>rde die Dateien '/a/b/c/*' l<EFBFBD>schen, clear_cache(null,
|
||||
'a|b') w<EFBFBD>re das L<EFBFBD>schen der Dateien '/a/b/*'. Wenn eine Compile-Id
|
||||
'a|b|c') würde die Dateien '/a/b/c/*' löschen, clear_cache(null,
|
||||
'a|b') wäre das Löschen der Dateien '/a/b/*'. Wenn eine Compile-Id
|
||||
angegeben wurde, wie clear_cache(null, 'a|b', 'foo'), dann wird die
|
||||
Compile-Id so behandelt, als sei sie an die Cache-Gruppe angeh<EFBFBD>ngt,
|
||||
Compile-Id so behandelt, als sei sie an die Cache-Gruppe angehängt,
|
||||
also wie die Cache-Gruppe '/a/b/foo'. Wenn ein Templatename
|
||||
angegeben wurde, also wie bei clear_cache('foo.tpl', 'a|b|c'), dann
|
||||
wir Smarty auch nur '/a/b/c/foo.tpl' l<EFBFBD>schen. Es ist NICHT m<EFBFBD>glich,
|
||||
wir Smarty auch nur '/a/b/c/foo.tpl' löschen. Es ist NICHT möglich,
|
||||
ein Template unterhalb mehrerer Cache-Gruppen (also
|
||||
'/a/b/*/foo.tpl') zu l<EFBFBD>schen. Das Gruppieren der Cache-Gruppen
|
||||
'/a/b/*/foo.tpl') zu löschen. Das Gruppieren der Cache-Gruppen
|
||||
funktioniert nur von links nach rechts. Man muss die Templates, die
|
||||
man als eine Gruppe l<EFBFBD>schen m<EFBFBD>chte alle unterhalb einer einzigen
|
||||
Gruppenhierarchy anordnen, um sie als eine Gruppe l<EFBFBD>schen zu k<EFBFBD>nnen.
|
||||
man als eine Gruppe löschen möchte alle unterhalb einer einzigen
|
||||
Gruppenhierarchy anordnen, um sie als eine Gruppe löschen zu können.
|
||||
</para>
|
||||
<para>
|
||||
|
||||
Cache-Gruppen d<EFBFBD>rfen nicht mit der Hierarchie des
|
||||
Cache-Gruppen dürfen nicht mit der Hierarchie des
|
||||
Template-Verzeichnisses verwechselt werden. Die Cache-Gruppen wissen
|
||||
nicht, wie die Templatehierarchie strukturiert ist. Wenn man
|
||||
z. B. eine Templatestruktur wir "themes/blue/index.tpl" hat und man
|
||||
m<EFBFBD>chte alle Dateien f<EFBFBD>r des "blue"-Theme l<EFBFBD>schen, dann muss man
|
||||
h<EFBFBD>ndisch eine Cache-Gruppe wie display("themes/blue/index.tpl",
|
||||
möchte alle Dateien für des "blue"-Theme löschen, dann muss man
|
||||
händisch eine Cache-Gruppe wie display("themes/blue/index.tpl",
|
||||
"themes|blue") und kann diese dann mit
|
||||
clear_cache(null,"themes|blue") l<EFBFBD>schen.
|
||||
clear_cache(null,"themes|blue") löschen.
|
||||
|
||||
</para>
|
||||
<example>
|
||||
|
@@ -2,18 +2,18 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.3 Maintainer: andreas Status: ready -->
|
||||
<sect1 id="caching.multiple.caches">
|
||||
<title>Multiple Caches f<EFBFBD>r eine Seite</title>
|
||||
<title>Multiple Caches für eine Seite</title>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen f<EFBFBD>r Aufrufe von <link
|
||||
Sie können für Aufrufe von <link
|
||||
linkend="api.display">display()</link> oder <link
|
||||
linkend="api.fetch">fetch()</link> auch mehrere Caches erzeugen.
|
||||
Nehmen wir zum Beispiel an, der Aufruf von display('index.tpl')
|
||||
erzeuge f<EFBFBD>r verschieden F<EFBFBD>lle unterschiedliche Inhalte und Sie
|
||||
erzeuge für verschieden Fälle unterschiedliche Inhalte und Sie
|
||||
wollen jeden dieser Inhalte separat cachen. Um dies zu erreichen,
|
||||
k<EFBFBD>nnen Sie eine 'cache_id' beim Funktionsaufruf <EFBFBD>bergeben.
|
||||
können Sie eine 'cache_id' beim Funktionsaufruf übergeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>'display()' eine 'cache_id' <EFBFBD>bergeben</title>
|
||||
<title>'display()' eine 'cache_id' übergeben</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -30,33 +30,33 @@ $smarty->display('index.tpl',$my_cache_id);
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Im oberen Beispiel <EFBFBD>bergeben wir die Variable
|
||||
Im oberen Beispiel übergeben wir die Variable
|
||||
<parameter>$my_cache_id</parameter> als 'cache_id' an d<link
|
||||
linkend="api.display">isplay()</link>. F<EFBFBD>r jede einmalige
|
||||
linkend="api.display">isplay()</link>. Für jede einmalige
|
||||
<parameter>cache_id</parameter> wird ein eigener Cache von 'index.tpl'
|
||||
erzeugt. In diesem Beispiel wurde 'article_id' per URL <EFBFBD>bergeben und
|
||||
erzeugt. In diesem Beispiel wurde 'article_id' per URL übergeben und
|
||||
als 'cache_id' verwendet.
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Seien Sie vorsichtig, wenn Sie Smarty (oder jeder anderen PHP-Applikation)
|
||||
Werte direkt vom Client (Webbrowser) <EFBFBD>bergeben. Obwohl das Beispiel oben
|
||||
Werte direkt vom Client (Webbrowser) übergeben. Obwohl das Beispiel oben
|
||||
praktisch aussehen mag, kann es schwerwiegende Konsequenzen haben. Die 'cache_id'
|
||||
wird verwendet, um im Dateisystem ein Verzeichnis zu erstellen. Wenn ein Benutzer
|
||||
also <EFBFBD>berlange Werte <EFBFBD>bergibt oder ein Skript benutzt, das in hohem
|
||||
Tempo neue 'article_ids' <EFBFBD>bermittelt, kann dies auf dem Server zu Problemen
|
||||
f<EFBFBD>hren. Stellen Sie daher sicher, dass Sie alle empfangenen Werte auf
|
||||
ihre G<EFBFBD>ltigkeit <EFBFBD>berpr<EFBFBD>fen und unerlaubte Sequenzen entfernen.
|
||||
Sie wissen m<EFBFBD>glicherweise, dass ihre 'article_id' nur 10 Zeichen lang sein kann, nur
|
||||
also überlange Werte übergibt oder ein Skript benutzt, das in hohem
|
||||
Tempo neue 'article_ids' übermittelt, kann dies auf dem Server zu Problemen
|
||||
führen. Stellen Sie daher sicher, dass Sie alle empfangenen Werte auf
|
||||
ihre Gültigkeit überprüfen und unerlaubte Sequenzen entfernen.
|
||||
Sie wissen möglicherweise, dass ihre 'article_id' nur 10 Zeichen lang sein kann, nur
|
||||
aus alphanumerischen Zeichen bestehen darf und in der Datenbank eingetragen
|
||||
sein muss. <EFBFBD>berp<EFBFBD>fen sie das!
|
||||
sein muss. Überpüfen sie das!
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
Denken Sie daran, Aufrufen von <link linkend="api.is.cached">is_cached()</link>
|
||||
und <link linkend="api.clear.cache">clear_cache()</link> als zweiten Parameter
|
||||
die 'cache_id' zu <EFBFBD>bergeben.
|
||||
die 'cache_id' zu übergeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>'is_cached()' mit 'cache_id' aufrufen</title>
|
||||
@@ -82,9 +82,9 @@ $smarty->display('index.tpl',$my_cache_id);
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Sie k<EFBFBD>nnen mit <link linkend="api.clear.cache">clear_cache()</link>
|
||||
den gesamten Cache einer bestimmten 'cache_id' auf einmal l<EFBFBD>schen,
|
||||
wenn Sie als Parameter die 'cache_id' <EFBFBD>bergeben.
|
||||
Sie können mit <link linkend="api.clear.cache">clear_cache()</link>
|
||||
den gesamten Cache einer bestimmten 'cache_id' auf einmal löschen,
|
||||
wenn Sie als Parameter die 'cache_id' übergeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>Cache einer bestimmten 'cache_id' leeren</title>
|
||||
@@ -96,7 +96,7 @@ $smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
|
||||
// Cache mit 'sports' als 'cache_id' l<EFBFBD>schen
|
||||
// Cache mit 'sports' als 'cache_id' löschen
|
||||
$smarty->clear_cache(null,"sports");
|
||||
|
||||
$smarty->display('index.tpl',"sports");
|
||||
@@ -105,7 +105,7 @@ $smarty->display('index.tpl',"sports");
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Indem Sie allen dieselbe 'cache_id' <EFBFBD>bergeben, lassen sich Caches gruppieren.
|
||||
Indem Sie allen dieselbe 'cache_id' übergeben, lassen sich Caches gruppieren.
|
||||
</para>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
@@ -26,28 +26,28 @@ $smarty->display('index.tpl');
|
||||
Wenn Caching eingeschaltet ist, wird der Funktionsaufruf display('index.tpl')
|
||||
das Template normal rendern, zur selben Zeit jedoch auch eine Datei mit
|
||||
dem Inhalt in das <link linkend="variable.cache.dir">$cache_dir</link> schreiben
|
||||
(als gecachte Kopie). Beim n<EFBFBD>chsten Aufruf von display('index.tpl') wird die
|
||||
(als gecachte Kopie). Beim nächsten Aufruf von display('index.tpl') wird die
|
||||
gecachte Kopie verwendet.
|
||||
</para>
|
||||
<note>
|
||||
<title>Technische Bemerkung</title>
|
||||
<para>
|
||||
Die im <link linkend="variable.cache.dir">$cache_dir</link>
|
||||
abgelegen Dateien haben einen <EFBFBD>hnlichen Namen wie das Template,
|
||||
abgelegen Dateien haben einen ähnlichen Namen wie das Template,
|
||||
mit dem sie erzeugt wurden. Obwohl sie eine '.php'-Endung
|
||||
aufweisen, sind sie keine ausf<EFBFBD>hrbaren PHP-Skripte.
|
||||
aufweisen, sind sie keine ausführbaren PHP-Skripte.
|
||||
Editieren Sie diese Dateien NICHT!
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
Jede gecachte Seite hat eine Lebensdauer, die von <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> bestimmt
|
||||
wird. Normalerweise betr<EFBFBD>gt der Wert 3600 Sekunden (= 1
|
||||
wird. Normalerweise beträgt der Wert 3600 Sekunden (= 1
|
||||
Stunde). Nach Ablauf dieser Lebensdauer wird der Cache neu
|
||||
generiert. Sie k<EFBFBD>nnen die Lebensdauer pro Cache bestimmen indem
|
||||
generiert. Sie können die Lebensdauer pro Cache bestimmen indem
|
||||
Sie <link linkend="variable.caching">$caching</link> auf 2
|
||||
setzen. Konsultieren Sie den Abschnitt <EFBFBD>ber <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> f<EFBFBD>r
|
||||
setzen. Konsultieren Sie den Abschnitt über <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> für
|
||||
weitere Informationen.
|
||||
</para>
|
||||
<example>
|
||||
@@ -60,16 +60,16 @@ $smarty = new Smarty;
|
||||
|
||||
$smarty->caching = 2; // Lebensdauer ist pro Cache
|
||||
|
||||
// Standardwert f<EFBFBD>r '$cache_lifetime' auf 5 Minuten setzen
|
||||
// Standardwert für '$cache_lifetime' auf 5 Minuten setzen
|
||||
$smarty->cache_lifetime = 300;
|
||||
$smarty->display('index.tpl');
|
||||
|
||||
// '$cache_lifetime' f<EFBFBD>r 'home.tpl' auf 1 Stunde setzen
|
||||
// '$cache_lifetime' für 'home.tpl' auf 1 Stunde setzen
|
||||
$smarty->cache_lifetime = 3600;
|
||||
$smarty->display('home.tpl');
|
||||
|
||||
// ACHTUNG: die folgende Zuweisung an '$cache_lifetime' wird nicht funktionieren,
|
||||
// wenn '$caching' auf 2 gestellt ist. Wenn die '$cache_lifetime' f<EFBFBD>r 'home.tpl' bereits
|
||||
// wenn '$caching' auf 2 gestellt ist. Wenn die '$cache_lifetime' für 'home.tpl' bereits
|
||||
// auf 1 Stunde gesetzt wurde, werden neue Werte ignoriert.
|
||||
// 'home.tpl' wird nach dieser Zuweisung immer noch eine '$cache_lifetime' von 1 Stunde haben
|
||||
$smarty->cache_lifetime = 30; // 30 seconds
|
||||
@@ -82,9 +82,9 @@ $smarty->display('home.tpl');
|
||||
Wenn <link linkend="variable.compile.check">$compile_check</link>
|
||||
eingeschaltet ist, werden alle in den Cache eingeflossenen
|
||||
Templates und Konfigurationsdateien hinsichtlich ihrer letzten
|
||||
<EFBFBD>nderung <EFBFBD>berpr<EFBFBD>ft. Falls eine der Dateien seit der Erzeugung des
|
||||
Cache ge<EFBFBD>ndert wurde, wird der Cache unverz<EFBFBD>glich neu
|
||||
generiert. Dadurch ergibt sich ein geringer Mehraufwand. F<EFBFBD>r
|
||||
Änderung überprüft. Falls eine der Dateien seit der Erzeugung des
|
||||
Cache geändert wurde, wird der Cache unverzüglich neu
|
||||
generiert. Dadurch ergibt sich ein geringer Mehraufwand. Für
|
||||
optimale Performance sollte <link
|
||||
linkend="variable.compile.check">$compile_check</link> deshalb auf
|
||||
'false' gesetzt werden.
|
||||
@@ -108,15 +108,15 @@ $smarty->display('index.tpl');
|
||||
<para>
|
||||
Wenn <link linkend="variable.force.compile">$force_compile</link> eingeschaltet ist,
|
||||
werden die Cache-Dateien immer neu generiert und das Caching damit wirkungslos gemacht.
|
||||
<link linkend="variable.force.compile">$force_compile</link> wird normalerweise nur f<EFBFBD>r die Fehlersuche verwendet.
|
||||
Ein effizienterer Weg das Caching auszuschalten w<EFBFBD>re,
|
||||
<link linkend="variable.force.compile">$force_compile</link> wird normalerweise nur für die Fehlersuche verwendet.
|
||||
Ein effizienterer Weg das Caching auszuschalten wäre,
|
||||
<link linkend="variable.caching">$caching</link> auf 'false' (oder 0) zu setzen.
|
||||
</para>
|
||||
<para>
|
||||
Mit der Funktion <link linkend="api.is.cached">is_cached()</link> kann <EFBFBD>berpr<EFBFBD>ft
|
||||
Mit der Funktion <link linkend="api.is.cached">is_cached()</link> kann überprüft
|
||||
werden, ob von einem Template eine gecachte Version vorliegt.
|
||||
In einem Template, das zum Beispiel Daten aus einer Datenbank bezieht,
|
||||
k<EFBFBD>nnen Sie diese Funktion verwenden, um den Prozess zu <EFBFBD>berspringen.
|
||||
können Sie diese Funktion verwenden, um den Prozess zu überspringen.
|
||||
</para>
|
||||
<example>
|
||||
<title>is_cached() verwenden</title>
|
||||
@@ -140,15 +140,15 @@ $smarty->display('index.tpl');
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Mit der <link linkend="language.function.insert">{insert}</link> Funktion k<EFBFBD>nnen Sie
|
||||
Mit der <link linkend="language.function.insert">{insert}</link> Funktion können Sie
|
||||
Teile einer Seite dynamisch halten. Wenn zum Beispiel ein Banner in einer gecachten Seite
|
||||
nicht gecached werden soll, kann dessen Aufruf mit <link linkend="language.function.insert">{insert}</link> dynamisch gehalten werden.
|
||||
Konsultieren Sie den Abschnitt <EFBFBD>ber <link linkend="language.function.insert">insert</link>
|
||||
f<EFBFBD>r weitere Informationen und Beispiele.
|
||||
Konsultieren Sie den Abschnitt über <link linkend="language.function.insert">insert</link>
|
||||
für weitere Informationen und Beispiele.
|
||||
</para>
|
||||
<para>
|
||||
Mit der Funktion <link linkend="api.clear.all.cache">clear_all_cache()</link> k<EFBFBD>nnen
|
||||
Sie den gesamten Template-Cache l<EFBFBD>schen. Mit <link linkend="api.clear.cache">clear_cache()</link>
|
||||
Mit der Funktion <link linkend="api.clear.all.cache">clear_all_cache()</link> können
|
||||
Sie den gesamten Template-Cache löschen. Mit <link linkend="api.clear.cache">clear_cache()</link>
|
||||
einzelne Templates oder <link linkend="caching.groups">Cache-Gruppen</link>.
|
||||
</para>
|
||||
<example>
|
||||
@@ -161,10 +161,10 @@ $smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
|
||||
// alle Cache-Dateien l<EFBFBD>schen
|
||||
// alle Cache-Dateien löschen
|
||||
$smarty->clear_all_cache();
|
||||
|
||||
// nur Cache von 'index.tpl' l<EFBFBD>schen
|
||||
// nur Cache von 'index.tpl' löschen
|
||||
$smarty->clear_cache('index.tpl');
|
||||
|
||||
$smarty->display('index.tpl');
|
||||
|
@@ -24,7 +24,7 @@ define('SMARTY_DIR', '/usr/local/lib/php/Smarty/libs/');
|
||||
// Pfad zum Smarty Verzeichnis setzen (unter Windows)
|
||||
define('SMARTY_DIR', 'c:/usr/local/lib/php/Smarty/libs/');
|
||||
|
||||
// Smarty einbinden (der Dateiname beginnt mit gro<EFBFBD>em 'S')
|
||||
// Smarty einbinden (der Dateiname beginnt mit großem 'S')
|
||||
require_once(SMARTY_DIR . 'Smarty.class.php');
|
||||
?>
|
||||
]]>
|
||||
|
Reference in New Issue
Block a user