Shulou(Shulou.com)06/03 Report--

This article mainly introduces "the advantages, disadvantages and functions of PHP template engine smarty". In daily operation, I believe many people have doubts about the advantages, disadvantages and functions of PHP template engine smarty. Xiaobian consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "the advantages, disadvantages and functions of PHP template engine smarty". Next, please follow the editor to study!

What is smarty?

Smarty is a template PHP template engine written in PHP, which provides the separation of logic from external content.

The purpose is to use the PHP programmer to separate from the artist, the programmer who changes the logic content of the program will not affect the page design of the artist, and the designer will not affect the program logic of the program, which is particularly important in the multi-person cooperation project.

2. Advantages of smarty:

1. Speed: programs written in smarty can achieve maximum speed improvement, which is relative to other template engine technologies.

two。 Compiled: programs written in smarty are compiled into a non-template PHP file at run time, which uses a mixture of PHP and HTML to convert WEB requests directly into this file the next time the template is accessed, without template recompilation (without changes to the source program)

3. Caching technology: a caching technology chosen by smarty, which can cache the HTML file that the user finally sees into a static HTML page. When the cache attribute of smarty is set to true, the user's WEB request will be directly converted to this static HTML file within the cachetime period set by smarty, which is equivalent to calling a static HTML file.

4. Plug-in technology: smarty can customize plug-ins. Plug-ins are actually custom functions.

5. If/elseif/else/endif can be used in templates. It is very convenient to rearrange the template format by using the judgment statement in the template file.

Third, where it is not suitable to use smarty:

1. Content that needs to be updated in real time. For example, stocks show that it needs to update the data frequently, and this type of program uses smarty to slow down template processing.

two。 Small project. Small projects because the project is simple and both artists and programmers are one-person projects, the use of smarty will lose the advantage of rapid php development.

IV. Smarty directory structure and version

Open smarty's official website, www.smarty.net/download.php. Download Smarty 3.1.12. Tar.gz and zip are available for linux and windows versions, respectively.

After downloading the Smarty-stable-3.1.12, you will get a Smarty-3.1.12 folder with two main folders, demo and libs.

The demo folder is the sample folder, which contains the default folder structure, and is the main folder where we are going to write program code. The name of the folder in demo is the default directory structure name of smarty. You can change the name of the folder to the name we want by changing the corresponding attribute value of smarty.

Libs is the source folder of smarty code, which is generally unchanged.

/ libs/Smarty.class.php # master file

/ libs/sysplugins/ # Internal plugin

/ libs / plugins/ # external plugin, which can be expanded freely

/ demo/cahce/ # place cache files

/ demo/configs / # place configuration files that can be loaded

/ demo/templates/ # place template file

/ demo/templates_c/ # place the compiled file for the template

You can change the name of the extracted Smarty-3.1.12 folder to the name of the project we want, or demo can change it to the name of the folder where you want to store the code.

2. Debug Smarty-3.1.12

Create your own file and create an index.php under the demo folder.

Create a template index.tpl in the templates directory

(it can be an extension for almost any text file, commonly known as tpl,php,html, and the latter two are not recommended because they are accessible directly from the browser and are not secure. You can set the httpd.conf of apache to prohibit direct access to .tpl files. Or place the templats directory outside the site document tree. )

, /

/ / index.php code

Require ('.. / libs/Smarty.class.php')

$smarty = new Smarty

/ / you can output the value zhang of name through {$name} in the called template. {} is the smarty delimiter here.

$smarty- > assign ('name','zhang')

/ / the PHP statement block cannot be executed in the call template tpl file.

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

/ *

Index.tpl page content

Hello, {$name}

, /

/ *

The process of Smarty compilation time is source php file-> template file (which may be called multiple or more times)-> source php file.

In other words, it does not affect the other processing and output of the original php file. So the smarty template file can be a complete html or a part of it.

Smarty process

Smarty compiles the php source file into an intermediate file (also php). If caching is enabled, and then the cache file (also php) is generated from the compiled file, all the parts that need to be cached are hard-coded.

Each subsequent access accesses the compiled file (if the compiled file already exists), multiple calls to compile at a time (either multiple times of a single file or multiple files), and if caching is enabled and the cache file is not expired, the cache file is accessed directly, skipping the compiled file.

Once the compiled file is generated, it is not automatically updated unless the template file or configuration file is changed. Changes to the source php file do not cause recompilation. Once the compiled file is regenerated, the cache file must also be regenerated.

, /

/ / Smarty allows two special compilation settings to exist:

/ / 1. Do not recompile automatically at any time (launch phase): it is generated only when there is no compiled file for this file, and changes to the template file or configuration file will not cause recompilation.

$smarty- > setCompile_check (false); / / the default true,false means that no compiled file is generated at any time when the file changes, except that there is no compiled file.

$smarty- > getCompile_check (); / / get the settings for the current compilation check

/ / 2. Recompile at any time (debug phase): recompile at any time.

$smarty- > setForce_compile (true); / / defaulting to false,true means recompiling every time (if caching is enabled, recaching every time)

$smarty- > getForce_compile (); / / get the current settings for forced compilation

/ / enable caching

$smarty- > setCaching (true)

$smarty- > getCaching (); / / get the current cache status, which is disabled by false by default

$smarty- > setcache_lifetime (60); / / set cache time in seconds

/ / {* template file *}

/ / {nocache}

/ / {$name}

/ / {/ nocache}

/ / {* variables placed in the nocache tag will not be cached if caching is enabled, and each time the value of the PHP source file is read *}

/ *

Smarty delimiter

In template files, ordinary html code and smarty code are distinguished by delimiters. The default is {}, but it may conflict with js and css. Changes can be made.

Template tags will not support spaces in 3. 0, such as {$abc} can be recognized in Smarty2, but not in 3. 0, it must be {$abc}, in order to better support javascript and css.

, /

$smarty- > left_delimiter = "{"; / / left delimiter, 2.0 attribute, 3.0 is used

$smarty- > right_delimiter = "}"

/ *

The delimiter is equivalent to the echo of PHP, and all values in the delimiter will be output unless assignment and other operations

The content between the two * * in the delimiter in the smarty tpl file is commented as shown in

Tpl file:

{* this is the template comment content *}

, /

/ / set cache directory path without default "cache"

$smarty- > setCacheDir ("cache")

/ / get the cache directory path

$smarty- > getCacheDir ()

/ / set the configuration directory path without setting the default "configs"

$smarty- > setConfigDir ("configs")

/ / add configuration directory paths, all paths will be saved as an array, and files will be found in all paths when the file is called

$smarty- > addConfigDir ("configs/test")

/ / get an array of configuration directory paths

$smarty- > getConfigDir ()

/ / set the plugin directory path without setting the default "plugins"

$smarty- > setPluginsDir ("plugins")

/ / add plug-in directory paths, all paths will be saved as arrays, and all paths will be found in all paths when files are called. What is placed in the plugins folder is the storage file of functions that can be called in the foreground or background according to different rules. The names of file names and function names have different writing requirements according to different calling rules.

$smarty- > addPluginsDir ("plugins/test")

/ / get an array of plug-in directory paths

$smarty- > getPluginsDir ()

/ / set the template directory path without setting the default "templates"

$smarty- > setTemplateDir ("templates")

/ / add template directory paths, all paths will be saved as an array, and files will be found in all paths when the file is called.

$smarty- > addTemplateDir ("templates/test")

/ / get an array of template directory paths

$smarty- > getTemplateDir ()

/ / set the compilation directory path without setting the default "templates_c"

$smarty- > setCompileDir ("templates_c")

/ / get the compilation directory path

$smarty- > getCompileDir ()

/ *

We can create different php source folders and put the written php files into different folders according to certain categories.

Then create a custom config file in each folder and a new $smarty = new Smarty object in the config file

Then set the cache, configuration files, plug-ins, templates, and compilation directories of php files of all different folders to the same cache, configuration files, plug-ins, templates, compilation directory

Let all PHP source files in this folder refer to the configuration file to get the same configuration.

, /

/ / template variable

$arr = array (array ("zhang", "li"), 'array = > array ("liu", "wang"), array ("ming", "yi"))

$smarty- > assign ("testArr", $arr)

/ / set the template variable to provide a variable for the template to be called. In the template to be called next, you can access specific array elements through {$testArr} or {$testArr ['a'] [0]} or {$testArr.a.0}

/ / in the template, you can directly change the value of the template variable passed through {$testArr = "testValue" scope= "global"} (create and set the template variable in the template if it does not exist). The scope attribute is not written to mark the scope of the template variable.

/ / change or create another array in the template {$testArr = [1 testArr 2]}} or {$testArr [] = 4} or other similar way to create an array in a template.

/ / the php source file can obtain the specified template variable through $smarty- > getTemplateVars ("testArr"). If you want to obtain the template variable changed or created in the template, you must add the scope attribute and set the value to scope= "global" or scope= "parent" when creating or changing its value in the template.

Class A {

Function aa ($nam) {

Echo $nam

}

}

$smarty- > assign ("obj", new A)

/ / when the template variable is an object, it can be called as follows on the template page, and the address is also passed when the class object is passed to the template.

/ / {$obj- > aa ('my name is y')}

/ / Smarty can identify template variables embedded in double quotes, as long as the variable contains only numbers, letters, and underscores. But it only seems to support template variables that can be directly converted to strings.

$smarty- > assign ("testStr", "this is testStr")

/ / the template can be accessed through {"$testStr OK!"}

/ *

Tpl templates contain templates

Template file:

{include file= "header.tpl"}

Header.tpl content:

This is the top content! welcome, {$name}

Templates containing templates can also be in this format

{include file= "header.tpl" testVar= "this is the top content!"}

On the other hand, header.tpl can use the template variables passed when the calling page is included through {$testVar}

Header.tpl content:

{$testVar}, welcome, {$name}

, /

/ *

You can specify a series of variables to correspond to values in advance, put them in the configuration file and load them when you use them.

The configuration file is placed in the configs folder by default, and you can customize and modify the folder name.

, /

/ *

# template test.conf file:

The value corresponding to the # key can be enclosed without quotation marks

Title = Welcome to smartphones!

Cutoff_size = 40

[china]

Language = chinese

[england]

Language = english

# [china], [england] is the tag. If the key value of the tag is global, it can be used in the template as long as the configuration file is called. The key value of the label can be used only if the corresponding tag is specified when the configuration file is called.

# call the configuration file statement $smarty- > configLoad ('test.conf', $sections =' england') in the PHP source file; only the template called under this statement can use this configuration file and specify the key and value under which tag to use through the $sections attribute

The # $sections parameter can be left unwritten. If the default value is null,$smarty- > configLoad ('test.conf'), only the global key value is used, not the key value under the label.

# invoke the configuration file under the template through {config_load file= "test.conf" section= "china" scope= "global"} statement

# section attribute may not be written. By default, the null,scope attribute must write {config_load file= "test.conf" scope= "global"}.

# section attribute can be assigned three values

# local can only use this profile for the current template

# parent can only use the keys in the configuration file in the templates that are included in the current template after the profile statement is introduced, or in the templates called by the smarty object in the php source file after the configuration file is called

# global test effect is the same as parent

# use key values in templates through {# language#}, or access configuration file key values through {$smarty.config.language}

In # PHP source files, you can use $smarty- > getConfigVars ('language') or $smarty- > getConfigVariable (' language') to get the key value, and $smarty- > getConfigVars ('language') may also get an array

, /

/ *

Common functions in tpl file

Tpl file:

{capture name= "testCapture"}

{include file= "f1.tpl"}

{/ capture}

{if true}

{$smarty.capture.testCapture}

{/ if}

{if $name = = "wang"}

Welcome wang.

{elseif $name = = "zhang"}

Welcome zhang.

{else}

Welcome, whatever you are.

{/ if}

The {* operator can be = =, > =, etc., or it can be eq,ne etc. *}

{for $xchang0; $x

{foreach name= "testForeach" from=$testArr key=arId item=arVal}

The corresponding value of {$arId} is: {$arVal}

{$smarty.foreach.testForeach.index}

$testArr is null

{/ foreach} $n}

{$key}

{/ foreach}

{$sectionArr = [0 = > "a", 4 = > "b", "c", "d", "e", 6, 7, 9, 10, 11, 13, 14, 15]}

{section name= "testSection" loop=$sectionArr start=0 step=4 max=6 show=true}

{$smarty.section.testSection.index}-

{$sectionArr [testSection]}-

{$smarty.section.testSection.iteration}-

{sectionelse}

$sectionArr is null

{/ section}

, /

/ *

Tpl template file:

{literal}

Function a () {

Alert ("this is script")

}

A ()

{/ literal}

{*

The data in the literal tag area is treated as html text of the web page, and the template ignores and does not analyze all the character information inside it.

This feature is used to display js and css that may contain character information such as curly braces. When this information is in the {literal} {/ literal} tag, the template engine will display it without analyzing it.

*}

, /

/ / PHP file:

/ / $smarty- > setDebugging (true); / / debug the template for subsequent calls.

/ / $smarty- > getDebugging (); / / get whether to debug or not. Default false

/ / or write {debug} in the template to be debugged

/ *

Template file:

Smarty3.0 supports template inheritance systems, such as

F1.tpl:

{block name='top'} f1.header {/ block}

{block name='middle'} f1.middle {/ block}

{block name='buttom'} f1.buttom {/ block}

F2.tpl:

{extends file= "f1.tpl"}

{block name='top'} f2.header {/ block}

{block name='other'} it can`t be show {/ block}

{*

If there is no block tag in f2.tpl, or if there is no block tag in f2.tpl with the same name as in f1.tpl, f2.tpl fully introduces the content that displays everything in f1.tpl, including the block tag, while everything in f2.tpl is ignored

If there is a block tag with the same name as in f1.tpl in f2.tpl, the content of the block tag in f2.tpl will overwrite the content of the block tag of the same name in f1.tpl when the f2.tpl is displayed, and the content will still be displayed in the format location set by f1.tpl when the f2.tpl page is displayed, and all other text in f2.tpl, including the block tag with the same name and its content, will be ignored and not displayed.

The content of the block tag will only overwrite the content of the block tag of the same name in the parent template, or display in the child template. If there is no call to the parent template or the block tag of the same name to be overwritten in the parent template, the block tag content will not be displayed on this page.

This kind of inheritance supports multiple files and multiple inheritance, which means that it can be inherited indefinitely.

*}

{fetch file= "http://www.126.com" assign=" testAssign "}

{$testAssign}

{fetch file= "http://www.126.com"}

{* fetch can refer to the page of external http,ftp. If you specify the value of assign, the referenced content will be stored in the variable with the specified name, otherwise where the fetch is displayed *}

, /

/ / php page:

/ / call template can also use this method to do some processing before output

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

/ / do something with $output here processes the content to be output

/ / echo $output;// and then output the template

/ *

Submit the form in the template

The action attribute can be written directly to the name of the php file to be submitted, or if the action= "" is left empty, it can be submitted to the php file that calls the template.

, /

/ / Connect to the database

Mysql_connect ("localhost", "root", "root")

Mysql_select_db ("test")

$smarty- > assign ('webDir',$_SERVER [' DOCUMENT_ROOT']); / / $_ SERVER ['DOCUMENT_ROOT'] is the absolute path to the current project folder

/ / to configure the src path of JQuery, it is best to write the absolute path or write to run the file to find the relative path of the JQuery because the compiled file is compiled into a compiled file, and the compiled file is different from the original path environment.

? >

At this point, the study on "the advantages, disadvantages and functions of PHP template engine smarty" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.