Smarty is a template engine for PHP. More specifically, it facilitates a
manageable way to separate application logic and content from its
presentation. This is best described in a situation where the application
programmer and the template designer play different roles, or in most cases
are not the same person. For example, let's say you are creating a web page
that is displaying a newspaper article. The article headline, tagline,
author and body are content elements, they contain no information about how
they will be presented. They are passed into Smarty by the application,
then the template designer edits the templates and uses a combination of
HTML tags and template tags to format the presentation of these elements
(HTML tables, background colors, font sizes, style sheets, etc.) One day
the programmer needs to change the way the article content is retrieved (a
change in application logic.) This change does not affect the template
designer, the content will still arrive in the template exactly the same.
Likewise, if the template designer wants to completely redesign the
templates, this requires no changes to the application logic. Therefore,
the programmer can make changes to the application logic without the need
to restructure templates, and the template designer can make changes to
templates without breaking application logic.
Now for a short word on what Smarty does NOT do. Smarty does not attempt to
completely separate logic from the templates. There is no problem with
logic in your templates under the condition that this logic is strictly for
presentation. A word of advice: keep application logic out of the
templates, and presentation logic out of the application. This will most
definately keep things manageable and scalable for the foreseeable future.
One of the unique aspects about Smarty is the template compling. This means
Smarty reads the template files and creates PHP scripts from them. Once
they are created, they are executed from then on. Therefore there is no
costly template file parsing for each request, and each template can take
full advantage of PHP compiler cache solutions such as Zend Accelerator
(http://www.zend.com) or PHP Accelerator
(http://www.php-accelerator.co.uk).
Some of Smarty's features:
It is extremely fast.
It is efficient since the PHP parser does the
dirty work.
No template parsing overhead, only compiles once.
It is smart about recompiling only the template
files that have changed.
You can make custom
functions and custom variable
modifiers, so the template language is extremely extensible.
Configurable template delimiter tag syntax, so you can use
{}, {{}}, <!--{}-->, etc.
The if/elseif/else/endif constructs are passed to the
PHP parser, so the {if ...} expression syntax can be as simple or as complex
as you like.
Unlimited nesting of sections, ifs, etc. allowed.
It is possible to embed PHP code right in your template files,
although this may not be needed (nor recommended)
since the engine is so customizable.
Built-in caching support
Arbitrary template sources
Custom cache handling functions
Plugin architecture