mirror of
https://github.com/Piwigo/Piwigo.git
synced 2026-07-06 01:42:29 +02:00
issue #1845 update Smarty from 4.1.0 to 4.3.1 (compat PHP 8.2)
This commit is contained in:
plegall
@@ -0,0 +1,33 @@
|
||||
# Basic Syntax
|
||||
|
||||
A simple Smarty template could look like this:
|
||||
```smarty
|
||||
<h1>{$title|escape}</h1>
|
||||
<ul>
|
||||
{foreach $cities as $city}
|
||||
<li>{$city.name|escape} ({$city.population})</li>
|
||||
{foreachelse}
|
||||
<li>no cities found</li>
|
||||
{/foreach}
|
||||
</ul>
|
||||
```
|
||||
|
||||
All Smarty template tags are enclosed within delimiters. By default
|
||||
these are `{` and `}`, but they can be
|
||||
[changed](../../programmers/api-variables/variable-left-delimiter.md).
|
||||
|
||||
For the examples in this manual, we will assume that you are using the
|
||||
default delimiters. In Smarty, all content outside of delimiters is
|
||||
displayed as static content, or unchanged. When Smarty encounters
|
||||
template tags, it attempts to interpret them, and displays the
|
||||
appropriate output in their place.
|
||||
|
||||
The basis components of the Smarty syntax are:
|
||||
|
||||
- [Comments](language-syntax-comments.md)
|
||||
- [Variables](language-syntax-variables.md)
|
||||
- [Functions](language-syntax-functions.md)
|
||||
- [Attributes](language-syntax-attributes.md)
|
||||
- [Quotes](language-syntax-quotes.md)
|
||||
- [Math](language-math.md)
|
||||
- [Escaping](language-escaping.md)
|
||||
@@ -1,11 +1,10 @@
|
||||
Escaping Smarty Parsing {#language.escaping}
|
||||
=======================
|
||||
# Escaping Smarty parsing
|
||||
|
||||
It is sometimes desirable or even necessary to have Smarty ignore
|
||||
sections it would otherwise parse. A classic example is embedding
|
||||
Javascript or CSS code in a template. The problem arises as those
|
||||
languages use the { and } characters which are also the default
|
||||
[delimiters](#language.function.ldelim) for Smarty.
|
||||
[delimiters](../language-builtin-functions/language-function-ldelim.md) for Smarty.
|
||||
|
||||
> **Note**
|
||||
>
|
||||
@@ -17,37 +16,37 @@ languages use the { and } characters which are also the default
|
||||
|
||||
In Smarty templates, the { and } braces will be ignored so long as they
|
||||
are surrounded by white space. This behavior can be disabled by setting
|
||||
the Smarty class variable [`$auto_literal`](#variable.auto.literal) to
|
||||
the Smarty class variable [`$auto_literal`](../../programmers/api-variables/variable-auto-literal.md) to
|
||||
false.
|
||||
|
||||
## Examples
|
||||
|
||||
<script>
|
||||
// the following braces are ignored by Smarty
|
||||
// since they are surrounded by whitespace
|
||||
function foobar {
|
||||
alert('foobar!');
|
||||
}
|
||||
// this one will need literal escapement
|
||||
{literal}
|
||||
function bazzy {alert('foobar!');}
|
||||
{/literal}
|
||||
</script>
|
||||
|
||||
```smarty
|
||||
<script>
|
||||
// the following braces are ignored by Smarty
|
||||
// since they are surrounded by whitespace
|
||||
function foobar {
|
||||
alert('foobar!');
|
||||
}
|
||||
// this one will need literal escapement
|
||||
{literal}
|
||||
function bazzy {alert('foobar!');}
|
||||
{/literal}
|
||||
</script>
|
||||
```
|
||||
|
||||
|
||||
[`{literal}..{/literal}`](#language.function.literal) blocks are used
|
||||
[`{literal}..{/literal}`](../language-builtin-functions/language-function-literal.md) blocks are used
|
||||
for escaping blocks of template logic. You can also escape the braces
|
||||
individually with
|
||||
[`{ldelim}`](#language.function.ldelim),[`{rdelim}`](#language.function.ldelim)
|
||||
tags or
|
||||
[`{$smarty.ldelim}`,`{$smarty.rdelim}`](#language.variables.smarty.ldelim)
|
||||
[`{ldelim}`, `{rdelim}`](../language-builtin-functions/language-function-ldelim.md) tags or
|
||||
[`{$smarty.ldelim}`,`{$smarty.rdelim}`](../language-variables/language-variables-smarty.md#smartyldelim-smartyrdelim-languagevariablessmartyldelim)
|
||||
variables.
|
||||
|
||||
Smarty\'s default delimiters { and } cleanly represent presentational
|
||||
content. However if another set of delimiters suit your needs better,
|
||||
you can change them with Smarty\'s
|
||||
[`$left_delimiter`](#variable.left.delimiter) and
|
||||
[`$right_delimiter`](#variable.right.delimiter) values.
|
||||
Smarty's default delimiters { and } cleanly represent presentational
|
||||
content. However, if another set of delimiters suit your needs better,
|
||||
you can change them with Smarty's
|
||||
[`$left_delimiter`](../../programmers/api-variables/variable-left-delimiter.md) and
|
||||
[`$right_delimiter`](../../programmers/api-variables/variable-right-delimiter.md) values.
|
||||
|
||||
> **Note**
|
||||
>
|
||||
@@ -55,30 +54,26 @@ you can change them with Smarty\'s
|
||||
> sure to clear out cache and compiled files if you decide to change
|
||||
> them.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
<?php
|
||||
$smarty->left_delimiter = '<!--{';
|
||||
$smarty->right_delimiter = '}-->';
|
||||
|
||||
$smarty->left_delimiter = '<!--{';
|
||||
$smarty->right_delimiter = '}-->';
|
||||
|
||||
$smarty->assign('foo', 'bar');
|
||||
$smarty->assign('name', 'Albert');
|
||||
$smarty->display('example.tpl');
|
||||
|
||||
?>
|
||||
|
||||
|
||||
$smarty->assign('foo', 'bar');
|
||||
$smarty->assign('name', 'Albert');
|
||||
$smarty->display('example.tpl');
|
||||
```
|
||||
|
||||
Where the template is:
|
||||
|
||||
|
||||
Welcome <!--{$name}--> to Smarty
|
||||
<script language="javascript">
|
||||
var foo = <!--{$foo}-->;
|
||||
function dosomething() {
|
||||
alert("foo is " + foo);
|
||||
}
|
||||
dosomething();
|
||||
</script>
|
||||
|
||||
|
||||
```smarty
|
||||
Welcome <!--{$name}--> to Smarty
|
||||
<script language="javascript">
|
||||
var foo = <!--{$foo}-->;
|
||||
function dosomething() {
|
||||
alert("foo is " + foo);
|
||||
}
|
||||
dosomething();
|
||||
</script>
|
||||
```
|
||||
|
||||
@@ -1,25 +1,24 @@
|
||||
Math {#language.math}
|
||||
====
|
||||
# Math
|
||||
|
||||
Math can be applied directly to variable values.
|
||||
|
||||
## Examples
|
||||
```smarty
|
||||
{$foo+1}
|
||||
|
||||
{$foo+1}
|
||||
{$foo*$bar}
|
||||
|
||||
{$foo*$bar}
|
||||
{* some more complicated examples *}
|
||||
|
||||
{* some more complicated examples *}
|
||||
{$foo->bar-$bar[1]*$baz->foo->bar()-3*7}
|
||||
|
||||
{$foo->bar-$bar[1]*$baz->foo->bar()-3*7}
|
||||
{if ($foo+$bar.test%$baz*134232+10+$b+10)}
|
||||
|
||||
{if ($foo+$bar.test%$baz*134232+10+$b+10)}
|
||||
|
||||
{$foo|truncate:"`$fooTruncCount/$barTruncFactor-1`"}
|
||||
|
||||
{assign var="foo" value="`$foo+$bar`"}
|
||||
{$foo|truncate:"`$fooTruncCount/$barTruncFactor-1`"}
|
||||
|
||||
{assign var="foo" value="`$foo+$bar`"}
|
||||
```
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
Attributes {#language.syntax.attributes}
|
||||
==========
|
||||
# Attributes
|
||||
|
||||
Most of the [functions](#language.syntax.functions) take attributes that
|
||||
Most of the [functions](./language-syntax-functions.md) take attributes that
|
||||
specify or modify their behavior. Attributes to Smarty functions are
|
||||
much like HTML attributes. Static values don\'t have to be enclosed in
|
||||
much like HTML attributes. Static values don't have to be enclosed in
|
||||
quotes, but it is required for literal strings. Variables with or
|
||||
without modifiers may also be used, and should not be in quotes. You can
|
||||
even use PHP function results, plugin results and complex expressions.
|
||||
@@ -12,35 +11,35 @@ Some attributes require boolean values (TRUE or FALSE). These can be
|
||||
specified as `true` and `false`. If an attribute has no value assigned
|
||||
it gets the default boolean value of true.
|
||||
|
||||
## Examples
|
||||
```smarty
|
||||
{include file="header.tpl"}
|
||||
|
||||
{include file="header.tpl"}
|
||||
{include file="header.tpl" nocache} // is equivalent to nocache=true
|
||||
|
||||
{include file="header.tpl" nocache} // is equivalent to nocache=true
|
||||
{include file="header.tpl" attrib_name="attrib value"}
|
||||
|
||||
{include file="header.tpl" attrib_name="attrib value"}
|
||||
{include file=$includeFile}
|
||||
|
||||
{include file=$includeFile}
|
||||
{include file=#includeFile# title="My Title"}
|
||||
|
||||
{include file=#includeFile# title="My Title"}
|
||||
{assign var=foo value={counter}} // plugin result
|
||||
|
||||
{assign var=foo value={counter}} // plugin result
|
||||
{assign var=foo value=substr($bar,2,5)} // PHP function result
|
||||
|
||||
{assign var=foo value=substr($bar,2,5)} // PHP function result
|
||||
{assign var=foo value=$bar|strlen} // using modifier
|
||||
|
||||
{assign var=foo value=$bar|strlen} // using modifier
|
||||
{assign var=foo value=$buh+$bar|strlen} // more complex expression
|
||||
|
||||
{assign var=foo value=$buh+$bar|strlen} // more complex expression
|
||||
{html_select_date display_days=true}
|
||||
|
||||
{html_select_date display_days=true}
|
||||
|
||||
{mailto address="smarty@example.com"}
|
||||
|
||||
<select name="company_id">
|
||||
{html_options options=$companies selected=$company_id}
|
||||
</select>
|
||||
{mailto address="smarty@example.com"}
|
||||
|
||||
<select name="company_id">
|
||||
{html_options options=$companies selected=$company_id}
|
||||
</select>
|
||||
```
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
|
||||
@@ -1,27 +1,25 @@
|
||||
Comments {#language.syntax.comments}
|
||||
========
|
||||
# Comments
|
||||
|
||||
Template comments are surrounded by asterisks, and that is surrounded by
|
||||
the [delimiter](#variable.left.delimiter) tags like so:
|
||||
the [delimiter](../../programmers/api-variables/variable-left-delimiter.md) tags like so:
|
||||
|
||||
::: {.informalexample}
|
||||
## Examples
|
||||
|
||||
{* this is a comment *}
|
||||
|
||||
|
||||
:::
|
||||
```smarty
|
||||
{* this is a comment *}
|
||||
```
|
||||
|
||||
Smarty comments are NOT displayed in the final output of the template,
|
||||
unlike `<!-- HTML comments -->`. These are useful for making internal
|
||||
notes in the templates which no one will see ;-)
|
||||
|
||||
|
||||
{* I am a Smarty comment, I don't exist in the compiled output *}
|
||||
<html>
|
||||
```smarty
|
||||
{* I am a Smarty comment, I don't exist in the compiled output *}
|
||||
<html>
|
||||
<head>
|
||||
<title>{$title}</title>
|
||||
<title>{$title}</title>
|
||||
</head>
|
||||
<body>
|
||||
<body>
|
||||
|
||||
{* another single line smarty comment *}
|
||||
<!-- HTML comment that is sent to the browser -->
|
||||
@@ -66,6 +64,6 @@ notes in the templates which no one will see ;-)
|
||||
*}
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
</html>
|
||||
```
|
||||
|
||||
|
||||
@@ -1,40 +1,40 @@
|
||||
Functions {#language.syntax.functions}
|
||||
=========
|
||||
# Functions
|
||||
|
||||
Every Smarty tag either prints a [variable](#language.variables) or
|
||||
Every Smarty tag either prints a [variable](./language-syntax-variables.md) or
|
||||
invokes some sort of function. These are processed and displayed by
|
||||
enclosing the function and its [attributes](#language.syntax.attributes)
|
||||
enclosing the function and its [attributes](./language-syntax-attributes.md)
|
||||
within delimiters like so: `{funcname attr1="val1" attr2="val2"}`.
|
||||
|
||||
## Examples
|
||||
|
||||
{config_load file="colors.conf"}
|
||||
```smarty
|
||||
{config_load file="colors.conf"}
|
||||
|
||||
{include file="header.tpl"}
|
||||
{insert file="banner_ads.tpl" title="My Site"}
|
||||
{include file="header.tpl"}
|
||||
{insert file="banner_ads.tpl" title="My Site"}
|
||||
|
||||
{if $logged_in}
|
||||
Welcome, <span style="color:{#fontColor#}">{$name}!</span>
|
||||
{else}
|
||||
hi, {$name}
|
||||
{/if}
|
||||
|
||||
{include file="footer.tpl"}
|
||||
{if $logged_in}
|
||||
Welcome, <span style="color:{#fontColor#}">{$name}!</span>
|
||||
{else}
|
||||
hi, {$name}
|
||||
{/if}
|
||||
|
||||
{include file="footer.tpl"}
|
||||
```
|
||||
|
||||
|
||||
- Both [built-in functions](#language.builtin.functions) and [custom
|
||||
functions](#language.custom.functions) have the same syntax within
|
||||
- Both [built-in functions](../language-builtin-functions/index.md) and [custom
|
||||
functions](../language-custom-functions/index.md) have the same syntax within
|
||||
templates.
|
||||
|
||||
- Built-in functions are the **inner** workings of Smarty, such as
|
||||
[`{if}`](#language.function.if),
|
||||
[`{section}`](#language.function.section) and
|
||||
[`{strip}`](#language.function.strip). There should be no need to
|
||||
[`{if}`](../language-builtin-functions/language-function-if.md),
|
||||
[`{section}`](../language-builtin-functions/language-function-section.md) and
|
||||
[`{strip}`](../language-builtin-functions/language-function-strip.md). There should be no need to
|
||||
change or modify them.
|
||||
|
||||
- Custom functions are **additional** functions implemented via
|
||||
[plugins](#plugins). They can be modified to your liking, or you can
|
||||
create new ones. [`{html_options}`](#language.function.html.options)
|
||||
[plugins](../../programmers/plugins.md). They can be modified to your liking, or you can
|
||||
create new ones. [`{html_options}`](../language-custom-functions/language-function-html-options.md)
|
||||
is an example of a custom function.
|
||||
|
||||
See also [`registerPlugin()`](#api.register.plugin)
|
||||
See also [`registerPlugin()`](../../programmers/api-functions/api-register-plugin.md)
|
||||
|
||||
@@ -1,55 +1,48 @@
|
||||
Embedding Vars in Double Quotes {#language.syntax.quotes}
|
||||
===============================
|
||||
# Embedding Vars in Double Quotes
|
||||
|
||||
- Smarty will recognize [assigned](#api.assign)
|
||||
[variables](#language.syntax.variables) embedded in \"double
|
||||
quotes\" so long as the variable name contains only numbers, letters
|
||||
and under\_scores. See [naming](&url.php-manual;language.variables)
|
||||
- Smarty will recognize [assigned](../../programmers/api-functions/api-assign.md)
|
||||
[variables](./language-syntax-variables.md) embedded in "double
|
||||
quotes" so long as the variable name contains only numbers, letters
|
||||
and under_scores. See [naming](https://www.php.net/language.variables)
|
||||
for more detail.
|
||||
|
||||
- With any other characters, for example a period(.) or
|
||||
`$object->reference`, then the variable must be surrounded by
|
||||
`` `backticks` ``.
|
||||
`$object->reference`, then the variable must be surrounded by `` `backticks` ``.
|
||||
|
||||
- In addition Smarty3 does allow embedded Smarty tags in double quoted
|
||||
- In addition, Smarty does allow embedded Smarty tags in double-quoted
|
||||
strings. This is useful if you want to include variables with
|
||||
modifiers, plugin or PHP function results.
|
||||
|
||||
<!-- -->
|
||||
## Examples
|
||||
```smarty
|
||||
{func var="test $foo test"} // sees $foo
|
||||
{func var="test $foo_bar test"} // sees $foo_bar
|
||||
{func var="test `$foo[0]` test"} // sees $foo[0]
|
||||
{func var="test `$foo[bar]` test"} // sees $foo[bar]
|
||||
{func var="test $foo.bar test"} // sees $foo (not $foo.bar)
|
||||
{func var="test `$foo.bar` test"} // sees $foo.bar
|
||||
{func var="test `$foo.bar` test"|escape} // modifiers outside quotes!
|
||||
{func var="test {$foo|escape} test"} // modifiers inside quotes!
|
||||
{func var="test {time()} test"} // PHP function result
|
||||
{func var="test {counter} test"} // plugin result
|
||||
{func var="variable foo is {if !$foo}not {/if} defined"} // Smarty block function
|
||||
|
||||
{* will replace $tpl_name with value *}
|
||||
{include file="subdir/$tpl_name.tpl"}
|
||||
|
||||
{func var="test $foo test"} // sees $foo
|
||||
{func var="test $foo_bar test"} // sees $foo_bar
|
||||
{func var="test `$foo[0]` test"} // sees $foo[0]
|
||||
{func var="test `$foo[bar]` test"} // sees $foo[bar]
|
||||
{func var="test $foo.bar test"} // sees $foo (not $foo.bar)
|
||||
{func var="test `$foo.bar` test"} // sees $foo.bar
|
||||
{func var="test `$foo.bar` test"|escape} // modifiers outside quotes!
|
||||
{func var="test {$foo|escape} test"} // modifiers inside quotes!
|
||||
{func var="test {time()} test"} // PHP function result
|
||||
{func var="test {counter} test"} // plugin result
|
||||
{func var="variable foo is {if !$foo}not {/if} defined"} // Smarty block function
|
||||
{* does NOT replace $tpl_name *}
|
||||
{include file='subdir/$tpl_name.tpl'} // vars require double quotes!
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{cycle values="one,two,`$smarty.config.myval`"}
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{include file="`$module.contact`.tpl"}
|
||||
|
||||
{* can use variable with dot syntax *}
|
||||
{include file="`$module.$view`.tpl"}
|
||||
```
|
||||
|
||||
|
||||
|
||||
{* will replace $tpl_name with value *}
|
||||
{include file="subdir/$tpl_name.tpl"}
|
||||
|
||||
{* does NOT replace $tpl_name *}
|
||||
{include file='subdir/$tpl_name.tpl'} // vars require double quotes!
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{cycle values="one,two,`$smarty.config.myval`"}
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{include file="`$module.contact`.tpl"}
|
||||
|
||||
{* can use variable with dot syntax *}
|
||||
{include file="`$module.$view`.tpl"}
|
||||
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
@@ -58,4 +51,4 @@ Embedding Vars in Double Quotes {#language.syntax.quotes}
|
||||
> complex, it may be a good idea to move the bits that do not deal
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
|
||||
See also [`escape`](#language.modifier.escape).
|
||||
See also [`escape`](../language-modifiers/language-modifier-escape.md).
|
||||
|
||||
@@ -1,99 +1,97 @@
|
||||
Variables {#language.syntax.variables}
|
||||
=========
|
||||
# Variables
|
||||
|
||||
Template variables start with the \$dollar sign. They can contain
|
||||
Template variables start with the $dollar sign. They can contain
|
||||
numbers, letters and underscores, much like a [PHP
|
||||
variable](&url.php-manual;language.variables). You can reference arrays
|
||||
variable](https://www.php.net/language.variables). You can reference arrays
|
||||
by index numerically or non-numerically. Also reference object
|
||||
properties and methods.
|
||||
|
||||
[Config file variables](#language.config.variables) are an exception to
|
||||
[Config file variables](../language-variables/language-config-variables.md) are an exception to
|
||||
the \$dollar syntax and are instead referenced with surrounding
|
||||
\#hashmarks\#, or via the
|
||||
[`$smarty.config`](#language.variables.smarty.config) variable.
|
||||
\#hashmarks\#, or via the [`$smarty.config`](../language-variables/language-variables-smarty.md#smartyconfig-languagevariablessmartyconfig) variable.
|
||||
|
||||
## Examples
|
||||
|
||||
{$foo} <-- displaying a simple variable (non array/object)
|
||||
{$foo[4]} <-- display the 5th element of a zero-indexed array
|
||||
{$foo.bar} <-- display the "bar" key value of an array, similar to PHP $foo['bar']
|
||||
{$foo.$bar} <-- display variable key value of an array, similar to PHP $foo[$bar]
|
||||
{$foo->bar} <-- display the object property "bar"
|
||||
{$foo->bar()} <-- display the return value of object method "bar"
|
||||
{#foo#} <-- display the config file variable "foo"
|
||||
{$smarty.config.foo} <-- synonym for {#foo#}
|
||||
{$foo[bar]} <-- syntax only valid in a section loop, see {section}
|
||||
{assign var=foo value='baa'}{$foo} <-- displays "baa", see {assign}
|
||||
```smarty
|
||||
{$foo} <-- displaying a simple variable (non array/object)
|
||||
{$foo[4]} <-- display the 5th element of a zero-indexed array
|
||||
{$foo.bar} <-- display the "bar" key value of an array, similar to PHP $foo['bar']
|
||||
{$foo.$bar} <-- display variable key value of an array, similar to PHP $foo[$bar]
|
||||
{$foo->bar} <-- display the object property "bar"
|
||||
{$foo->bar()} <-- display the return value of object method "bar"
|
||||
{#foo#} <-- display the config file variable "foo"
|
||||
{$smarty.config.foo} <-- synonym for {#foo#}
|
||||
{$foo[bar]} <-- syntax only valid in a section loop, see {section}
|
||||
{assign var=foo value='baa'}{$foo} <-- displays "baa", see {assign}
|
||||
|
||||
Many other combinations are allowed
|
||||
Many other combinations are allowed
|
||||
|
||||
{$foo.bar.baz}
|
||||
{$foo.$bar.$baz}
|
||||
{$foo[4].baz}
|
||||
{$foo[4].$baz}
|
||||
{$foo.bar.baz[4]}
|
||||
{$foo->bar($baz,2,$bar)} <-- passing parameters
|
||||
{"foo"} <-- static values are allowed
|
||||
{$foo.bar.baz}
|
||||
{$foo.$bar.$baz}
|
||||
{$foo[4].baz}
|
||||
{$foo[4].$baz}
|
||||
{$foo.bar.baz[4]}
|
||||
{$foo->bar($baz,2,$bar)} <-- passing parameters
|
||||
{"foo"} <-- static values are allowed
|
||||
|
||||
{* display the server variable "SERVER_NAME" ($_SERVER['SERVER_NAME'])*}
|
||||
{$smarty.server.SERVER_NAME}
|
||||
{* display the server variable "SERVER_NAME" ($_SERVER['SERVER_NAME'])*}
|
||||
{$smarty.server.SERVER_NAME}
|
||||
|
||||
Math and embedding tags:
|
||||
Math and embedding tags:
|
||||
|
||||
{$x+$y} // will output the sum of x and y.
|
||||
{assign var=foo value=$x+$y} // in attributes
|
||||
{$foo[$x+3]} // as array index
|
||||
{$foo={counter}+3} // tags within tags
|
||||
{$foo="this is message {counter}"} // tags within double quoted strings
|
||||
{$x+$y} // will output the sum of x and y.
|
||||
{assign var=foo value=$x+$y} // in attributes
|
||||
{$foo[$x+3]} // as array index
|
||||
{$foo={counter}+3} // tags within tags
|
||||
{$foo="this is message {counter}"} // tags within double quoted strings
|
||||
|
||||
Defining Arrays:
|
||||
Defining Arrays:
|
||||
|
||||
{assign var=foo value=[1,2,3]}
|
||||
{assign var=foo value=['y'=>'yellow','b'=>'blue']}
|
||||
{assign var=foo value=[1,[9,8],3]} // can be nested
|
||||
{assign var=foo value=[1,2,3]}
|
||||
{assign var=foo value=['y'=>'yellow','b'=>'blue']}
|
||||
{assign var=foo value=[1,[9,8],3]} // can be nested
|
||||
|
||||
Short variable assignment:
|
||||
Short variable assignment:
|
||||
|
||||
{$foo=$bar+2}
|
||||
{$foo = strlen($bar)} // function in assignment
|
||||
{$foo = myfunct( ($x+$y)*3 )} // as function parameter
|
||||
{$foo.bar=1} // assign to specific array element
|
||||
{$foo.bar.baz=1}
|
||||
{$foo[]=1} // appending to an array
|
||||
{$foo=$bar+2}
|
||||
{$foo = strlen($bar)} // function in assignment
|
||||
{$foo = myfunct( ($x+$y)*3 )} // as function parameter
|
||||
{$foo.bar=1} // assign to specific array element
|
||||
{$foo.bar.baz=1}
|
||||
{$foo[]=1} // appending to an array
|
||||
|
||||
Smarty "dot" syntax (note: embedded {} are used to address ambiguities):
|
||||
Smarty "dot" syntax (note: embedded {} are used to address ambiguities):
|
||||
|
||||
{$foo.a.b.c} => $foo['a']['b']['c']
|
||||
{$foo.a.$b.c} => $foo['a'][$b]['c'] // with variable index
|
||||
{$foo.a.{$b+4}.c} => $foo['a'][$b+4]['c'] // with expression as index
|
||||
{$foo.a.{$b.c}} => $foo['a'][$b['c']] // with nested index
|
||||
{$foo.a.b.c} => $foo['a']['b']['c']
|
||||
{$foo.a.$b.c} => $foo['a'][$b]['c'] // with variable index
|
||||
{$foo.a.{$b+4}.c} => $foo['a'][$b+4]['c'] // with expression as index
|
||||
{$foo.a.{$b.c}} => $foo['a'][$b['c']] // with nested index
|
||||
|
||||
PHP-like syntax, alternative to "dot" syntax:
|
||||
PHP-like syntax, alternative to "dot" syntax:
|
||||
|
||||
{$foo[1]} // normal access
|
||||
{$foo['bar']}
|
||||
{$foo['bar'][1]}
|
||||
{$foo[$x+$x]} // index may contain any expression
|
||||
{$foo[$bar[1]]} // nested index
|
||||
{$foo[section_name]} // smarty {section} access, not array access!
|
||||
{$foo[1]} // normal access
|
||||
{$foo['bar']}
|
||||
{$foo['bar'][1]}
|
||||
{$foo[$x+$x]} // index may contain any expression
|
||||
{$foo[$bar[1]]} // nested index
|
||||
{$foo[section_name]} // smarty {section} access, not array access!
|
||||
|
||||
Variable variables:
|
||||
Variable variables:
|
||||
|
||||
$foo // normal variable
|
||||
$foo_{$bar} // variable name containing other variable
|
||||
$foo_{$x+$y} // variable name containing expressions
|
||||
$foo_{$bar}_buh_{$blar} // variable name with multiple segments
|
||||
{$foo_{$x}} // will output the variable $foo_1 if $x has a value of 1.
|
||||
$foo // normal variable
|
||||
$foo_{$bar} // variable name containing other variable
|
||||
$foo_{$x+$y} // variable name containing expressions
|
||||
$foo_{$bar}_buh_{$blar} // variable name with multiple segments
|
||||
{$foo_{$x}} // will output the variable $foo_1 if $x has a value of 1.
|
||||
|
||||
Object chaining:
|
||||
Object chaining:
|
||||
|
||||
{$object->method1($x)->method2($y)}
|
||||
{$object->method1($x)->method2($y)}
|
||||
|
||||
Direct PHP function access:
|
||||
Direct PHP function access:
|
||||
|
||||
{time()}
|
||||
|
||||
|
||||
|
||||
{time()}
|
||||
```
|
||||
|
||||
> **Note**
|
||||
>
|
||||
@@ -104,8 +102,8 @@ the \$dollar syntax and are instead referenced with surrounding
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
|
||||
Request variables such as `$_GET`, `$_SESSION`, etc are available via
|
||||
the reserved [`$smarty`](#language.variables.smarty) variable.
|
||||
the reserved [`$smarty`](../language-variables/language-variables-smarty.md) variable.
|
||||
|
||||
See also [`$smarty`](#language.variables.smarty), [config
|
||||
variables](#language.config.variables)
|
||||
[`{assign}`](#language.function.assign) and [`assign()`](#api.assign).
|
||||
See also [`$smarty`](../language-variables/language-variables-smarty.md), [config
|
||||
variables](../language-variables/language-config-variables.md)
|
||||
[`{assign}`](../language-builtin-functions/language-function-assign.md) and [`assign()`](../../programmers/api-functions/api-assign.md).
|
||||
|
||||
Reference in New Issue
Block a user