Smarty

时间 2019-12-01

标签 smarty 繁體版

原文原文链接

Smarty官网:http://www.smarty.netjavascript

1、什么是smarty?php

smarty是一个使用PHP写出来的模板PHP模板引擎，它提供了逻辑与外在内容的分离，简单的讲，
目的就是要使用PHP程序员同美工分离,使用的程序员改变程序的逻辑内容不会影响到美工的页面设计，
美工从新修改页面不会影响到程序的程序逻辑，这在多人合做的项目中显的尤其重要。css

2、smarty优势：html

1. 速度：采用smarty编写的程序能够得到最大速度的提升，这一点是相对于其它的模板引擎技术而言的。java

2. 编译型：采用smarty编写的程序在运行时要编译成一个非模板技术的PHP文件，
这个文件采用了PHP与HTML混合的方式，在下一次访问模板时将WEB请求直接转换到这个文件中，
而再也不进行模板从新编译（在源程序没有改动的状况下） mysql

3. 缓存技术：smarty选用的一种缓存技术，它能够将用户最终看到的HTML文件缓存成一个静态的HTML页，
当设定smarty的cache属性为true时，
在smarty设定的cachetime期内将用户的WEB请求直接转换到这个静态的HTML文件中来，
这至关于调用一个静态的HTML文件。linux

4. 插件技术：smarty能够自定义插件。插件实际就是一些自定义的函数。ios

5. 模板中可使用if/elseif/else/endif。在模板文件使用判断语句能够很是方便的对模板进行格式重排。程序员

3、不适合使用smarty的地方：web

1. 须要实时更新的内容。例如像股票显示，它须要常常对数据进行更新，这类型的程序使用smarty会使模板处理速度变慢。

2. 小项目。小项目由于项目简单而美工与程序员兼于一人的项目，使用smarty会丧失php开发迅速的优势。

打开smarty的官方网站，www.smarty.net/download.php。下载Smarty 3.0rc4，
目前仍然是处于rc版本（Release.Candidate.就是发行候选版本，与beta版本相比，再也不有功能的增长，主要着重于除错!）。
有tar.gz和zip分别适用于linux和windows版本。

下载好后tar –zxvf Smarty 3.0rc4.tar.gz

目录中，demo文件夹为示例文件。Libs为程序文件。

/libs/Smarty.class.php #主文件

/libs/sysplugins/ #内部plugin

/libs /plugins/ #外部plugin,可自由扩充

/demo/cahce/ #放置缓存文件

/demo/configs / #放置能够载入的配置文件

/demo/templates/ #放置模板文件

/demo/templates_c/ #放置对模板编译后的文件

最好在须要进行smarty处理的文件的目录中建立与demo中的相同的文件夹（注意文件夹具备web用户写权限），
固然也能够更改文件夹名和路径，默认值为处于被smarty处理的文件的同级目录。Smarty3.0须要php5.0以上。

二、调试Smarty3.0

建立本身的文件，好比index.php。
在templates目录中建立模板index.tpl（几乎能够是任何文本文件的扩展名，
经常使用的是tpl,php,html，不建议使用后二者，由于能够从浏览器直接访问而不安全。
能够对apache的httpd.conf进行设置，禁止直接访问.tpl文件。或者将templats目录放在网站文档树以外。）

[Index.php]

require_once("../../Smarty-3.0rc4/libs/Smarty.class.php");

$smarty = new smarty();

$smarty->assign('name','韩灵稚');

$smarty->display('templates/index.tpl ');

[Index.tpl]的代码：

你好， {$name}

</body></html>

Smarty编译时的处理过程是源php文件->模板文件（可能屡次调用）->源php文件。。。
也就是说不影响原php文件的其余处理和输出。因此smarty模板文件能够是完整的html，也能够是其中一部分。

三、Smarty3.0基础

3.1 smarty处理过程

smarty将php源文件，首先编译成中间文件（也是php），若是启用缓存，
再根据编译文件生成缓存文件（也是php）,须要缓存的部分所有是硬编码。
以后的每次访问都会访问编译文件（若是编译文件已经存在），
一次编译屡次调用（能够是单文件的屡次，也能够是多文件的屡次），
若是启用缓存且有缓存文件并且没有过时，则直接访问缓存文件，跳过编译文件。

编译文件一经生成，就不会被自动更新，除非模板文件或者配置文件更改。
源php文件修改是不会引起从新编译的。
一旦编译文件从新生成，缓存文件也必然从新生成。

Smarty容许有两种特殊的编译设置存在：

一、任什么时候候都不自动从新编译(上线阶段)：只有没有该文件的编译文件时才生成，
模板文件或者配置文件的更改，不会引起从新编译。

$smarty->setCompile_check(false)
#默认为true,false表示任什么时候候都不在发生文件变动的状况下生成编译文件，除了无编译文件。

$smarty->getCompile_check() #得到当前编译检查的设置

二、任什么时候候都从新编译(调试阶段)：任什么时候候都从新编译。

$smarty->setForce_compile(true) #默认为false,true表示每次都从新编译（启用缓存的话，每次都从新缓存）

$smarty->getForce_compile() #得到当前强制编译的设置

3.2 分界符

在模板文件中，区分普通html代码和smarty代码靠的是分界符。默认状况下是“{ }“，可是与js和css相冲突。
能够进行变动。在3.0中模板标签将不支持空格，如{ $abc }在Smarty2中能够识别的，
可是3.0里头就不行了，必须这样{$abc}，这样是为了可以更好的支持javascript和css。

$smarty->left_delimiter = "<{"; #左分界符，2.0属性，3.0沿用

$smarty->right_delimiter = "}>"; #右分界符，2.0属性，3.0沿用

注意：将默认分界符修改后，在3.0模板中仍然不支持空格，好比<{ $abc }>，无效。

3.3 注释

{* smarty用*包含的文字为注释内容 *}

若是默认分界符修改成“<{}>“, <{* smarty用*包含的文字为注释内容 *}>。注释中的模板变量无效。

3.4 模板包含文件

格式 {include file="要包含的文件名称 "}

Head.tpl

这是顶部内容，欢迎你，{$name}<hr />

Index.tpl中加一下代码

{include file="head.tpl"}

输出结果：

这是顶部内容，欢迎你，韩灵稚。

您好，韩灵稚！

除了包含其余配置文件，还能够包含html、php(须要开启smarty支持php模板的选项，
最好使用include_php函数)。包含文件还可使用传参。

Head.tpl

{$nr}，欢迎你，{$name}<hr />

Index.tpl

{include file="head.tpl" nr=”这是顶部内容”}

输出结果同上。

3.5 载入配置文件

能够预先规定一系列的变量与值的对应，并放在配置文件中，在使用时载入。
配置文件通常放在configs文件夹中，能够自定义。

My.conf

gv = "my.conf中的全局变量" #全局配置变量，任什么时候候调用，都将被载入

#若是$sections，未设置，显示所有变量

[color] #局部配置变量

fontcolor = "red" #若是$sections，设置为red，只显示全局变量和[color]中的变量

[size] #局部配置变量

fontsize = "12px" #若是$sections，设置为size，只显示全局变量和[size]中的变量

调用配置文件有两种方法，一种是在源文件处，一种是在模板文件处。

源文件处：$smarty->configLoad($config_file, $sections = null)

模板文件处：{config_load file="载入的配置文件" section=”选取的局部变量(可选)”scope=“做用模板范围（可选）“}

若是使用源文件的方法，载入的配置文件变量的做用模板范围自动为global，
并且能够应用到多个模板中（smarty对象调用了多个模板）。

若是使用后者，灵活性更大。单个模板中config_load的scope参数的范围能够是local
（本模板，只能本模板使用这些变量）, parent（父模板或者文件）或
global（同一个smarty对象所调用的全部模板，其余模板不须要再载入该配置文件）

在模板文件中使用配置变量

{#配置变量#}或者{$smarty.config.变量名称}

【相关函数】

$smarty->getConfigVariable($variable) #返回某个模板变量，该变量必须是parent或者是global

$smarty->getConfigVars($varname = null) #返回模板变量数组，或者单个变量。
该变量或者变量组必须是parent或者是global

$smarty->clearConfig($varname = null) #清除全部配置变量或者指定的一个配置变量

$smarty->setConfig_overwrite(false) #若是设变量为真,则从配置文件中读取出来的变量（若是变量名称相同）
将会由最后一个值覆盖。反之，变量将会放到一个数组中。
不能用数组索引去访问，可使用cycle函数。该属性也有getConfig_overwrite函数。

$smarty->setConfig_booleanize(true); #设置为true的话，
配置文件中的on/true/yes/1 和 off/false/no/0值会自动转化为布尔值，
false将变为字符串（若是做为判断条件，永远为真）。
该属性也有getConfig_booleanize函数。

3.6 环境配置

Smary脚本中是能够动态设置编译、模板、缓存、配置路径。

$smarty->template_dir = "./templates"; #设置模板目录，2.0设置方法，3.0沿用但不推荐

$smarty->compile_dir = "./templates_c"; #设置编译目录，2.0设置方法，3.0沿用但不推荐

$smarty->config_dir = './configs/'; #设置配置目录，2.0设置方法，3.0沿用但不推荐

$smarty->cache_dir = './cache/'; #设置缓存目录，2.0设置方法，3.0沿用但不推荐

Smary在3.0中对属性进行了封装。可使用以下方法进行访问得到目录。

$smarty->getCacheDir(); #获得当前缓存目录路径

$smarty->getTemplateDir(); #获得当前模板目录路径的数组

$smarty->getConfigDir(); #获得当前配置目录路径

$smarty->getCompileDir(); #获得当前编译目录路径

$smarty->getPluginsDir() #获得当前插件目录路径数组

一样用下面的方法进行目录设置

$smarty->setTemplateDir("../smarty1/templates/"); #设置新的模板目录，
注意设置后模板目录的数组只有该值一个，无论原来有几个值。

$smarty->setCompileDir("../smarty1/templates_c/"); #设置新的编译目录

$smarty->setConfigDir("../smarty1/configs/"); #设置新的配置目录

$smarty->setCacheDir("../smarty1/cache/"); #设置新的缓存目录

$smarty->addTemplateDir("templates"); #引用的模板文件的路径必须在模板目录数值中，
不然报错，因为仍然用原来的模板文件，因此添加上原来模板路径，这样模板数组中有两个路径。

$smarty->addPluginsDir('myplugins'); #添加一个新的插件目录，若是用set将取消插件数组，变为单指

【相关函数】

$smarty->utility->compileAllTemplates($extention = '.tpl', $force_compile = false,
$time_limit = 0, $max_errors = null) #直接编译全部模板目录下全部模板文件，用处不大。

$smarty->utility->clearCompiledTemplate($resource_name = null,
$compile_id = null, $exp_time = null) #清除编译目录下的编译文件或者指定条件的编译文件。

$smarty-> setDefault_template_handler_func($fucname)
#该函数在模板不能从它的源目录下获取时会获得调用，没有太大的意义，能够设置异常处理。

四、Smarty语法基础篇

4.1 变量

模板中的变量主要来源有三种。

一、是由原php文件中分配过来的。

$smarty->assign('name','韩灵稚'); #在源php文件中分配

你好， {$name} #在模板文件中使用

二、是由配置文件中分配过来的。

$smarty->configLoad(“configs/my.conf”) #在源php文件中载入配置文件，也能够在模板中载入

这是{#gv#} #在模板文件中使用

三、是在模板文件中建立的。

{assign var="name" value="韩灵稚" nocache=”false”scope=”global”}
#在模板中定义的变量，若是以前定义了相同的变量，则以最后一次定义为准。

{$name="韩灵稚"} #给变量直接赋值，若是该变量原来不存在，自动建立，3.0新特性。

{assign var=foo value=[1,2,3]} #定义普通数组变量

{assign var=foo value=['y'=>'yellow','b'=>'blue']} #定义关联数组

{assign var=foo value=[1,[9,8],3]} #定义数组中的数组

{$foo[]=1} #增长变量数组$foo的一个元素

你好， {$name} #在模板文件中使用

【相关函数】

$smarty->getVariable($variable, $_ptr = null, $search_parents = true,
$error_enable = true) #得到变量，仅限于得到第一种方式的变量

$smarty->getTemplateVars($varname = null, $_ptr = null, $search_parents = true)
#得到变量，能够得到第一种和第三种方式的变量（第三种方式变量scope必须为global或者parent），
若是想得到配置变量参看3.4

4.2 Smarty保留变量

Smarty系统中保留了一些内置变量，能够快速访问相应的变量。可是不能再源php中得到这些变量。

一、请求访问变量（Request variables）

$smarty.get.变量 #显示经过get方式传过来的指定变量的值。

$smarty.post.变量 #显示经过post方式传过来的指定变量的值。

$smarty.cookies.变量 #显示经过cookie中指定变量的值。

$smarty.server.SERVER_NAME #显示server变量值，phpinfo()中$_SERVER系列变量

$smarty.env.PATH #显示系统环境变量值，phpinfo()中$_ENV系列变量

$smarty.session.变量 #显示session中指定变量的值

$smarty.request.变量 #显示经过post、get、cookie中指定变量的值。

二、时间访问变量

{$smarty.now} #显示unix系统时间戳，须要变量调节器格式化，参看4.2.4，也可使使用{time()}

三、常量访问变量

{$smarty.const._MY_CONST_VAL} #访问php中的常量包括自定义常量和系统常量

四、{$smarty.capture}

参看4.4.1

五、配置访问变量

{$smarty.config.配置变量} #访问配置变量，等同于 #配置变量# 方式

六、{$smarty.section}, {$smarty.foreach}

参看4.4.3和4.4.4

七、{$smarty.template} #显示模板路径和名称

4.3 变量操做

4.2.1赋值

{$name = 新值} 好比，{$name=”个人名字叫韩灵稚”} #新值将替代原值，若是原来无该变量，
则建立变量并赋值。配置变量没法从新赋值。

{$name = 表达式} 好比,{$name = 1+2+$foo['bar']} #$foo['bar']的值为1，变量值为4

{$foo['bar']=1} #给数组的一个元素赋值

{$foo['bar']['blar']=1} #给多维数组的一个元素赋值

{$foo = array(1,2,3,4,5)} #利用php函数建立变量$foo，并赋值。

4.2.2访问

最简单的访问方法是 {$var}，配置变量访问是{#configvar#}

数组变量的访问能够是{$array[1][1]}，也能够支持{$array.1.1}

对象的访问{$object->method1($x)}，也支持对象链，{$object->method1($x)->method2($y)}

字符串与变量的混合输出

{"你们好，我是$name "} #Smarty能够识别嵌入在双引号中的变量，
只要此变量只包含数字、字母、下划线。

{"你们好，我是`$name[$obj->a]` "} #中括号[]、句号. 对象相关 -> ,必须将变量用两个`符号括起。

4.2.3变量名变量

与php相同，都支持在变量名称中使用变量，smarty还支持使用表达式。

$foo #一个普通的变量

$foo_{$bar} #变量名中包含变量

$foo_{$x+$y} #变量名中能够支持表达式

$foo_{$bar}_buh_{$blar} #变量名包含多个变量

4.2.4变量调节器

变量调节器主要是对变量进行格式化。

{$var|capitalize} #将变量首字大写

{$var|count_characters:false} #计算变量里的字符数，false为不计算空格。
若变量为数值则为数字和小数点等其余运算符的总和

{$var| cat:var2} #将var2链接到var，若为数值以字符串处理。

{$var| count_paragraphs} #计算变量里的段落数量，已“\n“区分

{$var| count_sentences} #计算变量中句子的数量，很差使

{$var| count_words} #计算变量中单词的数量已非字母和数字的字符分割统计

{$var| date_format :"%H:%M:%S" } #格式化变量日起，具体参数看chm文档

{$var| default:"no title" } #当变量为空时，为变量提供一个默认值

{$var| escape:url} #对变量值进行转码，具体参数看chm文档

{$var| indent:10:"*"} #对变量指定具体字符进行缩进,若为空格在html中不会显示出来，具体参数看chm文档

{$var| lower} #将变量小写

{$var| nl2br } #将变量中的“\n“转换成” “

{$var| regex_replace:"/[\r\t\n]/":" "} #将变量中的符合正则的内容替换成指定内容

{$var| replace:"Garden":"Vineyard"} #将变量中要求的内容替换成指定内容

{$var| spacify:"^^"} #将变量字符与字符之间插入指定内容，包括空格

{$var|string_format:"%d"} #将变量中的内容格式化，格式化参数同printf

{$var| strip: "*"} #用一个空格或一个给定字符替换全部重复空格,换行和制表符

{$var| strip_tags} #删除变量中的html标记, 去除<和>标签,包括在<和>之间的任何内容

{$var| truncate:30:"...":true} #截取变量的到规定的长度，具体参数看chm文档

{$var| upper} #将变量大写

{$var| wordwrap:30:"\n":true} #规定指定的长度强制换行，具体参数看chm文档

修改器能够复合组合。

{$articleTitle|lower|spacify|truncate:30:". . ."}

设置默认变量调节器

$smarty->getDefault_modifiers() #默认为空数组

$smarty->setDefault_modifiers(array('spacify:"^^"','capitalize') #设置变量的默认调节器，必须用array

{name} #模板变量name自动加入上面两个调节器

同时也能够定义本身的调节器，详情请参考6.7.4和6.8.4

4.2.5变量做用域（未写）

4.4 内建函数

4.4.1 capture

capture函数的做用是捕获模板输出的数据并将其存储到一个变量里,而不是把它们输出到页面.
任何在 {capture name="foo"}和{/capture}之间的数据将被存储到变量$foo中。
这样能够根据实际状况，选择性的输出一些内容,输出的语法是$smarty.capture.变量。

{capture name="bottom"}

{include file="bottom.tpl" nr="这是底部的内容"}

{/Capture}

{if true } #进行条件判断，肯定是否输出

{$smarty.capture.bottom}

{/if}

4.4.2 config_load

参看3.4

4.4.3 foreach,foreachelse

foreach 适合于简单数组（元素类型相同）

{foreach name=名称 item=内容 key=键 from=数组} #2.0中的用法，3.0沿用

正常执行

{foreachelse}

From变量数组没有值时（0个元素）执行。

{/foreach}

例子：

{foreach name=for1 item=num from=$foo}

{$smarty.foreach.for1.index+1}个元素：{$num}

{if is_array($num)}

{foreach name=for2 item=num2 key=key2 from=$num}

{$str|cat:$smarty.foreach.for2.index+1|cat:"个元素："|cat:$num2|cat:" key是"|cat:$key2|indent:1:"."}

{/foreach}

{/if}

{foreachelse}

{$smarty.foreach.for1.index+1}个元素：没有值！

{/foreach}

foreach的内置变量

$smarty.foreach.foreachname.index #（循环内部使用）显示当前循环的索引,若是数组为空，返回-1

$smarty.foreach.foreachname. iteration #（循环内部使用）显示当前的循环次数

$smarty.foreach.foreachname.first #（循环内部使用）若是为第一次循环，返回true

$smarty.foreach.foreachname.last #（循环内部使用）若是为最后一次循环，返回true

$smarty.foreach.foreachname.total #（循环内外部使用）显示循环的总次数

foreach 在3.0中作必定的升级，语法更接近于php，内置变量也更简洁。

{foreach $myarray as $var}...{/foreach}

foreach的内置变量，都可在内外部使用

$var@key #输出元素的键值，简单为012，关联为具体键值。

$var@iteration #显示当前的循环次数，外部使用为最后一次

$var@index #显示当前循环的索引,若是数组为空，返回-1，外部使用为最后一次

$var@total #显示循环的总次数

$var@first #若是为第一次循环，返回true

$var@last #若是为最后一次循环，返回true

4.4.4 section,sectionelse

section适用于复杂的数组操做，不适合关联数组。可是在3.0中并为对他作什么升级和修改，
而是直接推出了for命令，for更接近于php语法。能够预见，section将在将来版本中淘汰。

{section name=名称 loop=循环数组(次数) start=开始(0) step=步阶(1) max=最大循环次数 show=是否显示(true)}
#2.0中的用法，3.0沿用

正常执行

{sectionelse}

loop数组没有值时（0个元素）执行。

{/section }

例子：

{section name=sec1 loop=$foo step=1 start=0 show=true}

第{$smarty.section.sec1.index+1}个元素：{$foo[sec1]} 循环次数是

{$smarty.section.sec1.iteration}

{if is_array($foo[sec1])}

{section name=sec2 loop=$foo[sec1] step=1 start=0 show=true}

第{$smarty.section.sec2.index+1}个元素：{$foo[sec1][sec2]}
循环次数是{$smarty.section.sec2.iteration}

{/section}

{/if}

{sectionelse}

{$smarty.section.sec1.index}个元素：没有值！

{/section}

Section的内置变量与foreach 相同。

4.4.5 include

{include file="包含文件" var=”自定义传入包含文件的变量”assign=” 指定一个变量保存待包含模板的输出”}

若是规定了assign ，则包含文件不会立刻输出，模板输出的数据将存储到assign指定的变量里,
这样能够根据实际状况，再输出包含文件的内容。原理相似于capture。

4.4.6 include_php

{include_php file="包含文件" once=”是否指包含一次(true)”assign=” 指定一个变量保存待包含的输出”}

包含php文件，包含的文件正常编译，并提供输出。若是规定了assign ，
则包含文件不会立刻输出，输出的数据将存储到assign指定的变量里,
这样能够根据实际状况，再输出包含文件的内容。

4.4.7 insert

Insert最大的特色是不缓存。他的参数可能会缓存。可是insert所调用的函数内部不缓存。

{insert name=”函数名称” script=”包含函数的脚本”var….=”函数参数” assign=” 指定一个变量保存调用的输出”}

Insert调用的函数有特别的规定，函数格式必须是“smarty_insert_函数名称($params,&$smarty)”，
从insert传入的参数，会统一放到数组变量中，参数名为该数组的键值。

例子：

{insert name="maxnum" script="s2.php" x=12 y=13 assign=nn} #模板文件，script为保存调用函数的脚本

{foreach $nn as $n}

{$n}

{/foreach}

function smarty_insert_maxnum($arr) #函数脚本文件

{

return $arr['x']>$arr['y']?$arr['x']:$arr['y'];

}

若是规定了assign ，则调用函数的记过不会立刻输出，输出的数据将存储到assign指定的变量里,
这样能够根据实际状况，再输出包含文件的内容。

Insert也能够定义成组件，写入组件库中，详情请参考6.8.5

4.4.8 if,elseif,else

{if $name eq "Fred"}

Welcome Sir.

{elseif $name eq "Wilma"}

Welcome Ma'am.

{else}

Welcome, whatever you are.

{/if}

这个没有什么太好说的。比较操做符能够是 “==、>=”等，也能够是”eq、ne”等，这个看手册吧。

4.4.9 ldelim,rdelim

这个也很简单，分别替换smarty当前规定的左边界符和右边界符。通常成对使用。

4.4.10 literal

Literal 标签区域内的数据将被看成文本处理，此时模板将忽略其内部的全部字符信息。
该特性用于显示有可能包含大括号等字符信息的 js、css 。当这些信息处于 {literal}{/literal} 标签中时，
模板引擎将不分析它们，而直接显示。

4.4.11 strip

Smarty 在显示前将除去任何位于 {strip}{/strip} 标记中数据的首尾空格和回车。

4.4.12 php

php 标签容许在模板中直接嵌入 php 脚本。 {php}标签默认是关闭的，能够经过以下方式打开

$smarty->setAllow_php_tag(true) #设置开启识别php的标签

$smarty->getAllow_php_tag() #得到当前对{php}的支持状态

4.4.13 for,while

这是3.0新增的函数。语法相似于php，这两个函数都不适合关联数组

{for $x=0, $y=count($foo); $x<$y; $x++} .... {/for}

{for $x=0 to count($foo)-1 step 1}

第二种方法，支持for的内置变量。第一种不支持。

$x@iteration #当前循环次数

$x@total #总循环次数

$x@first #循环第一次

$x@last #循环最后一次

{while true}….{/while}

While没有内置变量。

4.5 系统自定义函数

4.5.1 assign

{assign var="name" value="韩灵稚" nocache=”false”scope=”global”} #在模板中定义

$smarty->assign($tpl_var, $value = null, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
#在php文件中定义

nocache决定了是否须要不缓存该变量（前提是须要启动缓存）。

scope 决定了变量的做用范围，有global、parent、local

【相关函数】

$smarty->assignGlobal($varname, $value = null, $nocache = false) #直接分配一个全局的变量

$smarty->assignByRef($tpl_var, &$value, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
#分配一个引用变量，适合传递的变量较大，好比对象类型，能够防止内存拷贝。

$smarty->clearAssign($tpl_var) #清楚特定的变量

$smarty->clearAllAssign() #清除全部分配的变量

4.5.2 append

3.0新增的函数，向模板中分配的变量，该变量能够接受多个值，从而成为变量数组。

$smarty->append($tpl_var, $value = null, $merge = false, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
#php文件中

{append var="name" value="2"} #模板文件中

例子：

$smarty->assign('nh', 'var1); #分配一个变量模板，值为var1

$smarty->append('nh','var2'); #对同一个变量，在追加一个值。nh模板变量为数组。

{$nh[0]} #在模板文件中使用第一个值

$merge,应该是是否合并原值，目前版本测试的时候，不起任何做用。

【相关函数】

$smarty->appendByRef($tpl_var, &$value, $merge = false) #添加一个引用变量到模板变量中，$merge不起做用。

4.5.3 counter

计数器。当第一次出现{counter}时开始计数，每次出现{counter}按照规定的计数。

{counter start=开始(1) skip=步阶(1) direction=递增/递减(up/down) print=是否显示(true) assign=输出给模板变量}

counter除了start和assign ，其余属性的设置，会对一下次的counter起做用。若是规定了assign ，
则包含文件不会立刻输出，模板输出的数据将存储到assign指定的变量里, 这样能够根据实际状况，
再输出包含文件的内容。

4.5.4 cycle

用于轮转使用一组值。当第一次出现{cycle}时开始，每次出现{cycle}轮换每一个值。

{cycle name=名称 values=一组值 print=是否输出(true) advance=是否使用下一个值(true)
delimiter=一组值中的分隔符(,) assign=输出给模板变量}

4.5.5 debug

什么也不说了，一个字强大。用了你就知道了，在须要设断点的地方写入{debug}

若是使用fetch()，则debug失效。只能使用display()。

{debug output=输出的格式(javascript/html) } #模板声明调试,，能够选择输出的方式默认是js窗口。

$smarty->getDebugging() #获得当前是进行调试，默认false

$smarty->setDebugging(true) #对后续调用的模板进行调试。

$smarty->getDebug_tpl() #得到调试所须要的tpl模板，能够本身修改。

$smarty->setDebug_tpl('new_debug.tpl') #从新指定新的用于调试的模板

4.5.6 eval

eval 按处理模板的方式计算取得变量的值。我的感受用处不大，对缓存支持很差。

4.5.7 fetch

fetch 用于从本地文件系统、HTTP或FTP上取得文件并显示文件的内容。
若是文件名称以"http://"开头，将取得该网站页面并显示。
若是文件名称以"ftp://"开头，将从ftp服务器取得该文件并显示。

{fetch file="/export/httpd/www.domain.com/docs/navbar.js"}

{fetch file="ftp://user:password@ftp.domain.com/path/to/currentheadlines.txt"}

{fetch file="http://www.myweather.com/68502/" assign="weather"}

{if $weather ne ""}{$weather}{/if}

调用的文件内容，若是能被html解析，则会输出解析内容

【相关函数】

$smarty->fetch($template, $cache_id = null, $compile_id = null, $parent = null)
#将模板输出的内容放入变量中，供之后使用，若是规定了编译id，
好比3，则编译后的文件名称为“3^常规名称”，缓存id同理。

$output = $smarty->fetch("index.tpl");

// do something with $output here// 对将要输出的内容进行处理

echo $output;

4.5.8 math

math 容许模板设计者在模板中进行数学表达式运算.

{math equation=自定义公式 [var…]=变量值 format=结果格式化字符串 assign=输出给模板变量}

4.5.9 popup_init,popup

输出javascript窗口。

{popup_init src="/javascripts/overlib.js"} #popup_init载入js文件，必须的。

{popup text=”弹出信息”} #我的感受意义不大，参数不少，能够看chm

4.5.10 textformat

textformat 用于格式化文本。该函数主要清理空格和特殊字符，对段落按单词边界换行和行缩进等段落格式化处理。
与变量调节器相似，优势是能够调整段落，参数具体看文档。

{textformat [修改参数….]}

须要修改的段落

{/textformat}

4.5.11 html_checkboxes

根据函数生成checkboxes（多选）页面元素。

{html_checkboxes name=名称(checkbox) values=值数组 ouput=显示数组
selected=已显示的元素或者数组，数组值为values options=代替(value+output)可用关联数组
separator=分隔每一个复选按钮的字符串 label=是否为每一个复选按钮添加 <label> 标签(true)}

{assign var=cb_values value=[1,2,3,4,5,6] scope="global"}

{assign var=cb_content value=['北京','广州','天津','石家庄','太原','济南'] scope="global"}

{assign var=cb value=['1'=>'北京','3'=>'广州','2'=>'天津','4'=>'石家庄','5'=>'太原','6'=>'济南'] scope="global"}

{assign var=cb_selected value=[1,2]}

{html_checkboxes name="checkbox" values=$cb_values output=$cb_content selected=$cb_selected

separator="|"}

{html_checkboxes name="checkbox" options=$cb selected=$cb_selected separator="|"}

4.5.12 html_image

意义不大，直接写html可能会更好，不能生成img标签的id和name属性

{html_image file=图片路径和名称 border=边框 height=高度 width=宽度 alt=alt内容 href=图片url}

4.5.13 html_options

{html_options name=下拉菜单名称 values=值数组 ouput=显示数组 selected=已显示的元素
options=代替(value+output)可用关联数组}

注意，若是没有添加name属性，须要本身加入<select></select>标记。
若是selected是一个数组且不能多选，则选择数组的最后一个值做为以选择的。

4.5.14 html_radios

{html_radios name=名称(radio) values=值数组 ouput=显示数组
selected=已显示的元素options=代替(value+output)可用关联数组 separator=分隔每一个复选按钮的字符串}

4.5.15 html_select_date,html_select_time，html_table

意义不大，有局限性，不如手写。看手册吧。

4.5.16 mailto

{mailto address=发送邮箱 cc=抄送邮箱 bcc=暗送邮箱 subject=主题 text=连接内容 encode=编码形式(javascript/hex)}

具体看手册吧，测试中字符集格式转换有问题。

4.6 模板中自定义函数

3.0之后能够在模板内建立函数，而不须要必定先注册或者创建组件。

{function name=函数名 [var…]=默认值} #定义函数

函数体。。

{/function}

{call name=函数名 [var…]=传值} #调用函数，调用函数的代码必定要放在函数定义代码以后

{函数名 [var…]=传值} #也能够这样调用

五、缓存

5.1 开启缓存

smarty默认是不开启缓存的。须要进行设置才能开启缓存。缓存状态的设置须要在display或者fetch模板以前使用。
肯定缓存目录是否存在，是否具备足够的权限，设置缓存目录查看3.4。

$smarty->getCaching() #检查当前是否开启了缓存

$smarty->setCaching(true) #开启缓存

$smarty->isCached($template, $cache_id = null, $compile_id = null)
#检查指定条件的模板文件(名称/缓存id/编译id)是否被缓存(有缓存文件，且在缓存有效时间内)

$smarty->setcache_lifetime(60); #设置当前的缓存时间

$smarty->getcache_lifetime(); #得到当前的缓存时间，默认是3600（1个小时）

$smarty->display/fetch(模板名，缓存名=null，编译名=null，父模板名=null)

运行display/fetch就会在缓存目录中产生缓存文件。再次访问时，只要存在该缓存文件，
且在缓存文件的生命周期以内就会直接调用该缓存文件，而不须要从新编译。

$smarty->cache->clearAll($exp_time = null, $type = null) #清除全部缓存文件，
$exp_time指定一个以秒为单位的最小时间，超过这个时间的缓存都将被清除掉

$smarty->cache->clear($template_name, $cache_id = null, $compile_id = null, $exp_time = null, $type = null) #清除指定条件的缓存文件

能够单设某个条件或者组合多个条件删除多个缓存文件，好比

$smarty->cache->clear($template_name) #清除名称为template_name的全部缓存文件

$smarty->cache->clear(null, null, $compile_id) #清除编译id为compile_id的全部缓存文件

$smarty->cache->clear(null, $cache_id = null, $compile_id)
#清除缓存id为cache_id且编译id为compile_id的全部缓存文件

5.2 局部不缓存

缓存是一种高效访问的理想方式，可是对整个页面进行缓存的时候，
有时候局部的一些元素不但愿被缓存，好比时间、实时变化的信息等。

局部缓存有几种方法。

一、nocache属性

$smarty->assign/append($tpl_var, $value = null, $nocache = true …)
#中规定nocache = true，则模板中该变量各处均不缓存

{$foo nocache=true} #无论前面如何设置，则该处变量被缓存

{time() nocache} #函数也能够，nocache等同于nocache=true

模板中声明的变量和配置文件分配的变量不使用nocache,由于要改变他们的值，
须要编辑模板和配置文件，由于模板文件和配置文件修改就会从新生成缓存文件。

二、insert函数

Insert内部不受缓存影响，可是若是给insert传参，请确保参数不被缓存，详情查看4.4.7

三、{nocache}…..{/nocache}

代码块不缓存。代码块中能够放入变量和自定义模板函数，自定义函数的定义部分代码能够不放入，
可是调用代码必须放入，不然会缓存。insert函数不起做用。

5.3 单页面多缓存

有时候，咱们但愿单个页面有多个缓存页面。好比index?id=1和index?id=2可能页面内容不一样，
但愿分别保存在不一样的缓存文件中，因此这里咱们须要设定cache_id。

例子：Index.php

if(empty($_GET['id']))$_GET['id'] = null;

$smarty->assign('name','韩灵稚1'.$_GET['id']);

$smarty->display('templates/t3.tpl',$_GET['id'],$_GET['id']);

这样为每一个由id值建立的网页都生成对应缓存文件，当id无值时(index.php)，
直接生成一个缓存文件(名称)，当id=1时(index.php?id=1)，将生成另外一个缓存文件(1^名称)。

5.4 缓存集合

其实是多个值的不一样组合换来的不一样页面，好比index.php?id=2&sid=3，没种组合可能产生不一样的页面结果。

最开始可使用链接字符串使id和sid的值链接，理论上将也不会出现重复，
可是会出现这种状况index.php?id=23，是否是和上面的值同样呢。为了不这种状况，可使用缓存集合。

if(empty($_GET['id']))$_GET['id'] = null;

if(empty($_GET['sid']))$_GET['sid'] = null;

$smarty->assign('name','韩灵稚1'.$_GET['id']);

$smarty->display('templates/t3.tpl',$_GET['id'].'|'.$_GET['sid']); #两个变量之间用"|"隔开，
共同组成cache_id.有几个变量最终文件名就有几个"^"，若是变量为空，则只有一个"^"

从php的安全考虑，对于传过来的值要进行校验，去掉危险的字符。

5.5 缓存处理函数

smarty容许本身定义缓存读、写和清除的方法，
好比不想用文件的形式进行缓存处理能够写一个有mysql进行缓存读、写和清除的方法。

$smarty->Cache_handler_func=‘自定义函数名称’

在3.0中好像不太好用了。

六、smarty语法高级篇

6.1 模板过滤器

6.1.1 预过滤器pre

预滤器用来在编译以前直接处理模板源文件。预滤器函数的第一个参数是模板源文件，
该文件可能被其余一些预滤器修正过。此预滤器插件将返回修正过的源文件。
请记住此源文件仅用来编译，它不会在任何地方被保存。

有两种方式：

第一种是临时注册

$smarty->register->preFilter('mypre'); #注册一个预编译器函数

$smarty->unregister->preFilter ('mypre'); #删除一个预编译器函数

function mypre($tpl_source, &$smarty)
#在PHP文件中定义一个预编译器函数，参数格式固定，不可变，返回编译数据

{

return "mypre ".$tpl_source;

}

第二种是载入组件

在smarty程序目录中有libs/plugins目录，在这里咱们能够建立本身的过滤器组件。

建立php文件，prefilter.函数名.php(本例中是prefilter.mypre.php) #也能够用其余组件的php文件

function smarty_prefilter_mypre($source, $smarty)
#在smarty组件文件中定义一个预编译器函数组件，函数名称和参数严格不变

{

return "mypre_plus ".$source;

}

$smarty->autoload_filters = array('pre'=>array('mypre')); #在php文件中调用组件过滤器

$smarty->autoload_filters = array() #取消调入的组件过滤器

过滤器能够载入多个，

$smarty->register->preFilter('mypre'); #第一种方法，就是罗列一下，在上面先执行谁

$smarty->register->preFilter('mypre1');

$smarty->autoload_filters = array('pre'=>array('mypre','mypre1')); #第二种方法，就是创建数组就行，在前面的先执行。

6.1.2 后过滤器post

后滤器用来在编译以后直接处理模板的编译输出（PHP代码），
但须在编译以后的模板被保存到文件系统以前就进行操做。
预滤器函数的第一个参数是编译以后的模板代码，该代码可能被其余一些后滤器修正过。
此后滤器插件将返回修正过的代码文件。

有两种方式：

第一种是临时注册

$smarty->register->postFilter('mypre'); #注册一个后编译器函数

$smarty->unregister->postFilter ('mypre'); #删除一个后编译器函数

function mypost($tpl_source, &$smarty) #在php文件中定义一个后编译器函数，
参数格式固定，不可变，返回编译数据

{

return "mypost ".$tpl_source;

}

第二种是载入组件

在smarty程序目录中有libs/plugins目录，在这里咱们能够建立本身的过滤器组件。

建立php文件，postfilter.函数名.php(本例中是postfilter.mypost.php) #也能够用其余组件的php文件

function smarty_postfilter_mypost($source, $smarty)
#在smarty组件文件中定义一个预编译器函数组件，函数名称和参数严格不变

{

return "mypost_plus ".$source;

}

$smarty->autoload_filters = array('post'=>array('mypost')); #在php文件中调用组件过滤器

$smarty->autoload_filters = array('post'=>array()) #取消调入的组件过滤器

过滤器能够载入多个，

$smarty->register->postFilter('mypost'); #第一种方法，就是罗列一下，在上面先执行谁

$smarty->register->postFilter('mypost1');

$smarty->autoload_filters = array('post'=>array('mypost','mypost1'));
#第二种方法，就是创建数组就行，在前面的先执行。

6.1.3 输出过滤器output

输出过滤器插件的做用是，在装载并执行完一个模板以后显示模板以前，操做该模板的输出。

pre和post都会将过滤器加工后的结果硬编码写入编译文件，
也就意味着pre和post始终会被缓存（即便php不缓存）。
output不会，将不会写入编译文件以及以后的缓存文件，因此他是不被缓存的。

pre和post对于模板中调用的模板，好比include file，均需执行一遍。
而output只对编译后的文件执行一次（也就是总共执行一次）

有两种方式：

第一种是临时注册

$smarty->register->outputFilter('myoutput'); #注册一个后编译器函数

$smarty->unregister->outputFilter ('mypre'); #删除一个后编译器函数

function myoutput($tpl_source, &$smarty)
#在php文件中定义一个后编译器函数，参数格式固定，不可变，返回编译数据

{

return "myoutput ".$tpl_source;

}

第二种是载入组件

在smarty程序目录中有libs/plugins目录，在这里咱们能够建立本身的过滤器组件。

建立php文件，outputfilter.函数名.php(本例中是outputfilter.myoutput.php) #也能够用其余组件的php文件

function smarty_outputfilter_myoutput($source, $smarty)
#在smarty组件文件中定义一个预编译器函数组件，函数名称和参数严格不变

{

return "myoutput_plus ".$source;

}

$smarty->autoload_filters = array('output'=>array('myoutput')); #在php文件中调用组件过滤器

$smarty->autoload_filters['output'] = array() #取消调入的组件过滤器

过滤器能够载入多个，

$smarty->register->outputFilter('myoutput'); #第一种方法，就是罗列一下，在上面先执行谁

$smarty->register->outputFilter('myoutput1');

$smarty->autoload_filters = array('output'=>array('myoutput','myoutput1'));
#第二种方法，就是创建数组就行，在前面的先执行。

6.2 错误和异常

6.2.1 触发错误 trigger_error

php中也有trigger_error函数

Void trigger_error(string error_msg, [int level]) #int level就是错误级别，也能够用常量代替，E_USER_NOTICE, E_USER_WARNING等。set_error_handler()函数进行捕获处理。

$smarty->trigger_error($error_msg, $error_type = E_USER_WARNING)
#格式与PHP中的同名函数同样，只能抛出$smarty的异常

6.2.2 错误处理函数

$smarty->setExceptionHandler(handlerfuncname)
# 设置异常处理的函数，只能够处理有smarty引起的错误，
不能解决trigger_error。set_error_handler()函数只能解决php的，而不能解决smarty抛出的错误。

function handlerfuncname($errstr)

{

echo $errstr;

}

6.3 数据对象

3.0推出一个新的数据对象。能够从$smarty中建立一个或者多个数据对象，集中赋值，
而后有选择性选取某个或者多个数据对象，生成模板。

$smarty->createData($parent = null) #建立数据对象，能够选择父对象，子对象将继承父对象的赋值。

例子：

$mydata = $smarty->createData(); #建立一个数据对象，没有父对象

$mydata1 = $smarty->createData($mydata); #建立一个数据对象，父对象是$mydata

$mydata->assignByRef('assign_obj',&$han);

$mydata->assign('name','abcd');

$mydata1-> assign('name','bcds'); #mydata1自动继承了mydata的数据，若是相同，则新值覆盖旧值

$smarty->display('templates/t4.tpl',null,null,$mydata1);
#显示模板，最后一个参数必须有，指定模板使用哪一个数据对象。也可使用模板对象调用，参看6.4

6.4 模板对象

3.0同时推出一个新的模板对象。能够从$smarty中建立一个或者多个模板对象，
模板对象能够本身分配变量，同时能够调用数据对象（父对象）来生成文件。

$smarty->createTemplate($template, $cache_id = null, $compile_id = null, $parent = null)
#建立模板对象，能够选择父对象，编译id和缓存id。

例子：

$mytemplate = $smarty->createTemplate('templates/t4.tpl'); #建立一个模板对象，没有父对象，默认为$smarty

$mytemplate1 = $smarty->createTemplate('templates/t4.tpl',null,null,$mydata); #建立一个模板对象，父对象为mydata，mydata中的数据自动加载进来。

$mytemplate->assignByRef('assign_obj',&$han); #定义变量

$mytemplate->assign('name','abcd');

$mytemplate->display(); #生成文件。

若是一个模板是经过include方式调用的，则子模板的父对象将指向引用它的模板对象。

全部当前模板变量和父对象的模板对象都是能够获取的，可是若是是经过{assign}或者{$foo=…}
这样的方法建立或者修改变量则它的做用域将只停留在当前模板对象。

6.5 模板继承

模板继承，能够在模板中写{block} … {/block}快，而且这些块能够在子模板中进行覆盖。例子：

Parent.tpl

-----------------------------------------------------

<html>

<body>

{block name='top'} Parent.tpl的头部 {/block}<hr />

{block name='middle'} Parent.tpl的中部 {/block}<hr />

{block name='buttom'} Parent.tpl的尾部 {/block}

</body>

</html>

child.tpl

{extends file='parent.tpl'} #继承父模板

{block name='top'}{$smarty.block.parent}{"`$smarty.template`的头部"} {/block}
#child模板更新了top块。其余按照默认继承。

能够经过extends标签来指定被继承的模板，并在子模板中经过重写父模板的同名block块，达到覆盖的目的。
同时，能够经过{$smarty.block.parent}获取到父block的内容。
在子模板中，全部在{block} … {/block}以外的内容都将被忽略，这种继承支持多文件，多重继承，
意味着能够无限的继承下去。还可经过{block}的append和prepend属性来插入父模板结构中

6.6 资源相关内容（未写）

6.7 动态注册组件

注册能够理解为是动态的注册组件，与写死到文件中的组件相似，参考6.8

6.7.1 注册对象

SMARTY容许经过模板访问PHP对象。有两种方式来访问它们。

一种是注册对象到模板，而后经过相似于用户自定义函数的形式来访问它。

$smarty->register->templateObject($object_name, $object_impl, $allowed = array(),
$smarty_args = true, $block_methods = array())
#向模板注册一个对象，allowed是容许接受的方法。

$smarty->register->templateObject('reg_obj',$han,array('show','show1'));

{reg_obj->show var=2 var1=3} #在模板中访问，注意！接受的参数是数组，跟insert相似

$smarty->unregister->templateObject($object_name) #注销对象

第一种方法有一个很好的模板语法，同时它做为一个注册对象被限制为几个固定的方法和目标，
这样是比较安全的，可是他只可以调用对象方法，并且不支持数据对象和模板对象。

另外一种方法给模板分配对象，而后经过访问其它赋值变量相似的方法进行访问。

$mysmarty->assignByRef('assign_obj',&$han); #建议使用引用分配，对象通常都很大，节省内存

{$assign_obj->方法或者属性} #在模板中访问

这种方法能够调用对象的属性。并且能够用数据对象和模板对象注册

6.7.2 注册块

$smarty->register->block($block_tag, $block_impl, $cacheable = true, $cache_attr = array())

用来动态注册/定义块函数插件。前两个参数指定块函数名称和执行函数的名称。
执行函数的名称格式能够是一个包含函数名称的字符串；
也能够是一个array(&$object, $method)数组形式，其中&$object是一个对象的引用，而$method是它的一个方法；
还能够是一个array(&$ class, $method)数组形式，其中$class是一个类的名称，$method是类

中的一个方法。

$cacheable，若是启用页面缓存，块级函数是否缓存，默认是true。

$cacheattr，若是$cacheale为false，也就是块级函数不缓存，能够设置块级函数中的部分属性缓存，已数组定义。

例子：

$hanobj = new han();

$smarty->setcaching(true);

$smarty->register->block('hhh', array(&$hanobj,'myf'),false,array('fn')); #动态注册块

class han{

。。。。。。

public function myf($params,$content,&$smarty,&$repeat){ #定义块引用的函数

return "这是".$params['fn'].$params['un']."注释说明！ \r\n".$content;

}

{hhh fn=$name un=$name1} #在模板中调用，块级内容没有被缓存，属性fn被缓存

aaaaaaa

{time()}

{/hhh}

$smarty->unregister->block($block_tag) #注销块

6.7.3 注册函数

$smarty->register->compilerFunction($compiler_tag, $compiler_impl, $cacheable = true)
#注册编译函数，编译函数不能指定缓存属性

$smarty->register->templateFunction($function_tag, $function_impl, $cacheable = true, $cache_attr = array())
#注册模板函数，3.0后能够直接在模板中定义函数了，不须要注册

动态注册模板函数插件，前两个参数是模板函数名称和执行函数名称。
执行函数的格式能够是一个包含函数名称的字符串；也能够是一个array(&$object, $method)数组形式，
其中&$object是一个对象的引用，而$method是它的一个方法；
还能够是一个array(&$ class, $method)数组形式，
其中$class是一个类的名称，$method是类中的一个方法。

例子：

$hanobj = new han();

$smarty->setcaching(true);

$smarty->register->templateFunction('hhh', array(&$hanobj,'myf'),false,array('fn'));

class han{

…………….

public function myf($params,&$smarty,&$repeat){ #注册的函数只有3个参数

return time()."这是".$params['fn'].$params['un']."注释说明！ \r\n";

}

{hhh fn=$name un=$name1} #在模板中调用，函数没有被缓存，属性fn被缓存

$smarty->unregister->compilerFunction($compiler_tag) #注销注册函数

$smarty->unregister->templateFunction($function_tag)

6.7.4 注册变量调节器

$smarty->register->modifier($modifier_name, $modifier_impl)

动态注册调节器函数插件，前两个参数是模板调节器名称和执行函数名称。
执行函数的格式能够是一个包含函数名称的字符串；
也能够是一个array(&$object, $method)数组形式，其中&$object是一个对象的引用，
而$method是它的一个方法；还能够是一个array(&$ class, $method)数组形式，
其中$class是一个类的名称，$method是类中的一个方法。

例子：

$hanobj = new han();

$smarty->setcaching(true);

$smarty->register->modifier('hhh',array(&$hanobj,'myf')); #注册调节器

class han{

。。。。。。

public function myf($string) {

return time().$string;

}

{$name|hhh nocache=true} # 在模板中调用，nocache为true,表示该变量不缓存

$smarty->unregister->modifier($modifier) #注销变量调节器

6.8 组件相关内容

6.8.1 创建过滤器组件

请参考6.1.1 预过滤器pre

请参考6.1.2 后过滤器 post

请参考6.13 输出过滤器 output

6.8.2 创建块组件

在libs/plugins中建立块组件文件block.块名.php

function smarty_block_hhhh($params,$content,&$smarty,&$repeat) #函数名称格式要固定

{

return "这是".$params['fn'].$params['un']."注释说明！ \r\n".$content;

}

{hhhh fn=$name un=$name1} #在模板中调用

aaaaaaa

{time()}

{/hhhh}

与动态注册相比，不能规定块缓存

6.8.3 创建函数组件

在libs/plugins中建立函数组件文件function.函数名.php

function smarty_function_hhhh($params,&$smarty,&$repeat){ #在组建文件中创建函数

return time()."这是".$params['fn'].$params['un']."注释说明！ \r\n";

}

{nocache}

{hhhh fn=$name un=$name1} #在模板中调用，若是想不缓存，能够用{nocache}括住

{/nocache}

6.8.4 创建变量调节器组件

在libs/plugins中建立调节器组件文件modifier.调节器名.php

function smarty_modifier_hhhh($string) #在组建文件中创建调节器函数

{

return time().$string;

}

{$name|hhhh nocache=true} #在模板中调用

6.8.5 创建insert函数组

在libs/plugins中建立调节器组件文件insert.函数名.php

function smarty_insert_hhhh($params,&$smarty){ #在组件文件中创建insert函数

return time()."这是".$params['fn']."|".$params['un']."注释说明！ \r\n";

}

{insert name="hhhh" fn=$name un=$name1} #在模板中调用函数内部不缓存，可是传递的参数会缓存。