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} #在模板中調用函數內部不緩存，可是傳遞的參數會緩存。

相關標籤/搜索

smarty

php+smarty

smarty項目源碼

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。