Samuel Jonas Marcilio

R.A. 0200057

USO DE TEMPLATES COM ÊNFASE NA FERRAMENTA

“SMARTY TEMPLATE ENGINE” E A LINGUAGEM PHP

PARA DESENVOLVIMENTO DE PÁGINAS DA INTERNET

Jaguariúna

2005
 2

Samuel Jonas Marcilio

R.A. 0200057

USO DE TEMPLATES COM ÊNFASE NA FERRAMENTA

“SMARTY TEMPLATE ENGINE” E A LINGUAGEM PHP

PARA DESENVOLVIMENTO DE PÁGINAS DA INTERNET

Monografia apresentada à disciplina

Trabalho de Graduação, do curso de
Ciência da Computação da Faculdade
de Jaguariúna, sob a orientação do
Prof. Ademário Araújo Junior, como
exigência parcial para a obtenção de
média semestral.

Jaguariúna

2005
 3

MARCILIO, Samuel Jonas. Uso de templates com ênfase na ferramenta “Smarty

Template Engine” e a linguagem PHP para desenvolvimento de páginas da
Internet. Monografia defendida e aprovada na FAJ – Faculdade de Jaguariúna em
16 de Dezembro de 2005, pela banca examinadora constituída pelos professores:

Prof. Ademário Araújo Junior

FAJ – Orientador

Prof. Silvio Petroli Neto

FAJ

Prof. Carlos Alessandro Bassi Viviani

USF
 4

Ao prof. Ademário

Pelo incentivo e ajuda na escolha do assunto e pela dedicação ao prestar

orientação, e que, em todos os momentos que fora solicitado seu suporte,
prontamente me auxiliou.
 5

AGRADECIMENTOS

A minha família que sempre me apoiou para que pudesse conquistar meus objetivos
e em especial, minha esposa Luciana que em todos os momentos, seja de alegria ou
dificuldades se mostrou firme e paciente. Aos meus filhos Vinícius e Caroline que
tiveram que entender a necessidade do estudo quando os deixava em casa para
estudar.

Aos meus amigos Mário Silva, Dante e Robison que em todos os momentos foram
parceiros e contribuiram para o sucesso deste trabalho, me ajudando com as
dúvidas e críticas de incentivo.

A todos, expresso minha gratidão.

 6

MARCILIO, Samuel Jonas. Uso de templates com ênfase na ferramenta Smarty Template
Engine e a linguagem de programação PHP para desenvolvimento de aplicações para a
Internet. 2005. Monografia (Bacharelado em Ciências da Computação) – Curso de Ciências
da Computação da Faculdade de Jaguariúna, Jaguariúna.

RESUMO

O presente trabalho tem por objetivo relatar as atividades desenvolvidas do aluno Samuel
Jonas Marcilio, orientado pelo professor Ademário Araújo Junior. Consiste em uma pesquisa
sobre o uso de templates, com ênfase na ferramenta Smarty Template Engine no
desenvolvimento de aplicações para a Internet juntamente com a utilização da linguagem de
programação PHP (acrônimo recursivo para PHP: “Hypertext Preprocessor"). Devido à
complexidade de códigos, busca-se a legibilidade dos mesmos para o desenvolvimento e
manutenção ao se implementar uma aplicação web, bem como a separação dos códigos da
aplicação. O objetivo será demonstrar as vantagens, facilidades e comparações do uso da
Smarty em relação à programação com mistura de códigos PHP, HTML e outros. Serão
acrescentadas funcionalidades extras ao smarty, como exemplo: montagem automática de
formulários de cadastro e desenvolvimento de aplicações web para demonstração da
ferramenta Smarty Templates.

Palavras-chave: SMARTY, PHP, HTML, TEMPLATES

 7

ABSTRACT

The present job has the target to relate the developed activities by the student Marcilio,
Samuel Jonas, oriented by the teacher Junior, Ademário Araujo. It consists in a research of
the use of templates, with emphasis on the Smarty Template Engine tool to develop
applications for the Internet together with the use of PHP programming language (recursive
acronym to PHP: “Hypertext Pre-processor”). Due to the codes complexity, it looks for their
legibility to developing and the maintenance on the implementation of a web application as
well as the separation of the application codes. The objective will be to demonstrate the
advantages, facilities and comparison of the Smarty uses in relation of the PHP, HTML and
others mix programming. There will be added extra functionalities to the Smarty as example:
automatic building forms and web applications development to demonstrate the Smarty
Template tools.

Key words: SMARTY, PHP, HTML, TEMPLATE

 8

SUMÁRIO

LISTA DE FIGURAS ............................................................................................................10

LISTA DE EXEMPLOS ........................................................................................................11
LISTA DE SIGLAS ...............................................................................................................12
1. INTRODUÇÃO .............................................................................................................13
1.1. OBJETIVO ..............................................................................................................13
2. PHP ..............................................................................................................................15
2.1. O que é PHP?.........................................................................................................15
2.2. O que pode ser feito com PHP?..............................................................................15
2.3. Como surgiu a linguagem PHP? .............................................................................16
3. TEMPLATES ................................................................................................................18
3.1. O que são Templates (Modelos)? ...........................................................................18
3.2. Finalidade do uso de Templates .............................................................................18
3.3. Dificuldades de um sistema com códigos PHP e HTML misturados........................19
3.4. As ferramentas existentes.......................................................................................19
4. FERRAMENTA DE TEMPLATES “SMARTY TEMPLATE ENGINE”...........................21
4.1. O que é o Smarty? ..................................................................................................21
4.2. Características do Smarty que o torna poderoso ....................................................21
4.3. Funcionamento do Smarty PHP ..............................................................................23
4.4. Como fazer a instalação do Smarty PHP ................................................................24
4.5. Inclusão de uma chamada para a classe ................................................................25
4.6. Estrutura da aplicação ............................................................................................26
4.7. Algumas particularidades do Smarty .......................................................................27
4.7.1. Delimitadores ..........................................................................................................27
4.7.2. Comentários............................................................................................................27
4.7.3. Funções ..................................................................................................................27
4.7.4. Atributos..................................................................................................................28
4.7.5. Variáveis .................................................................................................................28
4.7.6. Modificadores de variáveis......................................................................................29
4.7.7. Arquivos de configuração........................................................................................31
5. APLICAÇÕES UTILIZANDO SMARTY TEMPLATES..................................................34
5.1. SISTEMA DE NOTÍCIAS.........................................................................................34
5.2. SISTEMA DE LISTAGEM DE UM CADASTRO DE LIVROS...................................38
5.3. GERADOR DE FORMULÁRIO DE CONTATOS COMO UMA NOVA
FUNCIONALIDADE ..........................................................................................................41
6. CONCLUSÃO...............................................................................................................44
 9

7. REFERÊNCIAS BIBLIOGRÁFICAS.............................................................................45
8. ANEXOS ......................................................................................................................46
8.1. Anexo 1 – index.conf – Sistema de notícias ............................................................46
8.2. Anexo 2 – index.tpl – Sistema de notícias ...............................................................46
8.3. Anexo 3 – mostra_noticias.tpl – Sistema de notícias...............................................47
8.4. Anexo 4 – index.php – Sistema de notícias.............................................................48
8.5. Anexo 5 – mostra_noticia.php – Sistema de notícias ..............................................48
8.6. Anexo 6 – conexao.php – Sistema de notícias........................................................49
8.7. Anexo 7 – index_mix2.php – Sistema de Listagem de um cadastro de livros..........49
8.8. Anexo 8 – index1.php - Sistema de Listagem de um cadastro de livros ..................50
8.9. Anexo 9 – index.tpl - Sistema de Listagem de um cadastro de livros ......................51
8.10. Anexo 10 – index.conf - Sistema de Listagem de um cadastro de livros .................52
8.11. Anexo 11 – conexao.php - Sistema de Listagem de um cadastro de livros .............52
8.12. Anexo 12 – index.php – Gerador de formulários de contato....................................52
8.13. Anexo 13 – index.tpl - Gerador de formulários de contato.......................................53
8.14. Anexo 14 – index.conf - Gerador de formulários de contato....................................54
 10

LISTA DE FIGURAS

FIGURA 1 – Logotipo da Smarty Template Engine...............................................................21

FIGURA 2 – Arquivo teste.php .............................................................................................23
FIGURA 3 – Arquivo compilado teste.tpl.php........................................................................24
FIGURA 4 – Resultado da página principal das notícias.......................................................37
FIGURA 5 – Resultado de uma das notícias indicadas.........................................................37
FIGURA 6 – Mesma página desenvolvida em ambas as codificações..................................41
 11

LISTA DE EXEMPLOS

EXEMPLO 1 – Arquivo index.conf ........................................................................................34

EXEMPLO 2 – Arquivo index.tpl ...........................................................................................35
EXEMPLO 3 – Arquivo mostra_noticias.tpl...........................................................................35
EXEMPLO 4 – Arquivo index.php .........................................................................................36
EXEMPLO 5 – PHP misturado com HTML ...........................................................................38
EXEMPLO 6 – Arquivo com PHP puro .................................................................................39
EXEMPLO 7 – Arquivo template escrito com a Smarty.........................................................40
EXEMPLO 8 – Arquivo PHP de chamada do formulário de contato......................................42
EXEMPLO 9 – Trecho do template de geração do form .......................................................42
 12

LISTA DE SIGLAS

PHP Hypertext Preprocessor

HTML Hypertext Markup Language
PERL Practical Extraction and Report Language
CGI Common Gateway Interface
HTTP Hypertext Transfer Protocol
GUI Graphical User Interface
C Linguagem de programação de alto nível
PDF Portable Document Format
URL Uniform Resource Locator
XML Extensible Markup Language
XHTML Extensible Hypertext Markup Language
IMAP Internet Message Access Protocol
SNMP Simple Network Management Protocol
NNTP Network News Transfer Protocol
POP3 Post Office Protocol 3
 13

1. INTRODUÇÃO

Devido à complexidade dos códigos e o crescimento de aplicações cada vez mais

dinâmicas, busca-se a legibilidade e estruturação visando facilitar a compreensão,
separação e a manutenção ao implementar-se uma aplicação web (Internet). Neste caso,
não se faz necessário o uso de uma técnica específica para estruturação de códigos e para
melhoria do ambiente de programação?
O objetivo dos templates é separar a lógica do programa da lógica de exibição,
colocando em lugares distintos os códigos responsáveis pela exibição e os responsáveis por
outras tarefas, como exemplo, o acesso a informações de um banco de dados.
Resumidamente, criar “scripts” ou funções PHP, independentes do layout que será usado
para exibição do conteúdo da página.
De acordo com Niederauer (1999, p.279), existem várias justificativas que apontam o
uso de templates como uma das soluções para os desenvolvedores. Serão citadas algumas
como referência.
• Grande vantagem quando se desenvolvem sistemas com equipes mistas
(programadores e designers), onde cada setor é responsável por parte dos códigos
internos das aplicações. É comum nas grandes empresas essa separação de áreas,
ou seja, a equipe de programadores pode não ser a mesma que desenvolverá o layout
da página.
• Uma vez desenvolvida totalmente com a técnica do uso de templates, a aplicação
ficará customizável para qualquer designer ou programador que tiver acesso aos
códigos dos templates utilizados.
• Facilidades para documentação e melhorias na manutenção dos códigos criados,
tendo em vista a separação das atividades que o uso de templates proporciona.

1.1. OBJETIVO

O propósito deste trabalho de graduação é apresentar uma pesquisa sobre uma das
soluções emergentes para o desenvolvimento de sistemas e aplicações web, o uso das
ferramentas denominadas “Template Engines” ou modelos ou simplesmente templates , que
são utilizadas em conjunto com a linguagem PHP (acrônimo recursivo para “PHP: Hypertext
Pré-Processor”) como base na estrutura das aplicações para Internet.
Para o estudo, será focado o pacote de ferramentas “Smarty Template Engine”,
acesso em http://smarty.php.net/, um dos pacotes mais avançados da atualidade.
Serão apresentadas as diferenças entre a programação com a mistura de códigos
(HTML + PHP por exemplo) e aplicações desenvolvidas com a utilização de templates.
 14

Demonstrar as facilidades na estruturação da documentação e manutenção do código

ao se utilizar a programação baseada em templates.
Serão desenvolvidas aplicações de teste para demonstração e comparações entre as formas
de programação.
 15

2. PHP

2.1. O que é PHP?

De acordo com Hojtsy (2004, Cap.1), PHP, que significa “Hypertext Preprocessor”, é
uma linguagem que permite criar sites web dinâmicos, possibilitando uma interação com o
usuário através de formulários, parâmetros da URL (endereço da página) e links. A diferença
de PHP com relação a linguagens semelhantes a Javascript é que o código PHP é
executado no servidor, sendo enviado para o cliente apenas HTML puro. Desta maneira é
possível interagir com bancos de dados e aplicações existentes no servidor, com a
vantagem de não expor o código fonte para o cliente. Isso pode ser útil quando o programa
está lidando com senhas ou qualquer tipo de informação confidencial.
O que diferencia PHP de um script CGI escrito em C ou Perl é que o código PHP fica
embutido no próprio HTML, enquanto no outro caso é necessário que o script CGI gere todo
o código HTML, ou leia de um outro arquivo.
Em resumo, o objetivo principal da linguagem é permitir a desenvolvedores escrever
páginas que serão geradas dinamicamente rapidamente.

2.2. O que pode ser feito com PHP?

Segundo Schimid (2004, Cap.1), o PHP é focado para ser uma linguagem de script do
lado do servidor, portanto, pode-se fazer qualquer coisa que outro programa CGI pode fazer,
como: coletar dados de formulários, gerar páginas com conteúdo dinâmico ou enviar e
receber cookies e muito mais.
Esses são os maiores campos onde os scripts PHP podem se utilizados:
Script no lado do servidor (server-side). Este é o mais tradicional e principal campo de
atuação do PHP. Serão necessárias três coisas para o trabalho. O interpretador do PHP
(como CGI ou módulo), um servidor web e um browser. Basta rodar o servidor web
conectado a um PHP instalado.
Pode-se acessar os resultados do programa PHP com um browser, visualizando a
página PHP através do servidor web.
Pode-se fazer um script PHP funcionar sem um servidor web ou browser. A única
coisa necessária é o interpretador.
Escrevendo aplicações GUI no lado do cliente (client-side), o PHP não é
(provavelmente) a melhor linguagem para produção de aplicações com interfaces em
janelas, mas o faz muito bem.
O PHP pode ser utilizado na maioria dos sistemas operacionais, incluindo Linux,
variantes Unix (incluindo HP-UX, Solaris e OpenBSD), Microsoft Windows e outros. Também
 16

é suportado pela maioria dos servidores web atuais, incluindo Apache, Microsoft Internet
Information Server, Personal Web Server, Netscape e muitos outros. O PHP pode ser
configurado como módulo para a maioria dos servidores, e para os outros como um CGI
comum.
Com o PHP, portanto, tem-se a liberdade para escolher o sistema operacional e o
servidor web. Do mesmo modo, pode-se escolher entre utilizar programação estrutural ou
programação orientada a objeto, ou ainda uma mistura deles.
O PHP não está limitado a gerar somente HTML. As habilidades do PHP incluem
geração de imagens, arquivos PDF e animações Flash criados dinamicamente. Pode-se
facilmente criar qualquer padrão texto, como XHTML e outros arquivos XML. O PHP pode
gerar esses padrões e os salvar no sistema de arquivos, em vez de imprimi-los, formando
um cache dinâmico de suas informações no lado do servidor.
PHP também tem como uma das características mais importantes o suporte a um
grande número de bancos de dados, como dBase, Interbase, mSQL, mySQL, Oracle,
Sybase, PostgreSQL e vários outros. Construir uma página baseada em um banco de dados
torna-se uma tarefa extremamente simples com PHP. Além disso, PHP tem suporte a outros
serviços através de protocolos de comunicação como IMAP, SNMP, NNTP, POP3 e,
logicamente, HTTP. Ainda é possível abrir sockets e interagir com outros protocolos.

2.3. Como surgiu a linguagem PHP?

De acordo com Schimid (2004, Cap.1), a linguagem PHP foi concebida durante
meados de 1994 por Rasmus Lerdorf. As primeiras versões não foram disponibilizadas,
tendo sido utilizadas em sua home-page apenas para que ele pudesse ter informações
sobre as visitas que estavam sendo feitas. A primeira versão utilizada por outras pessoas foi
disponibilizada em 1995, e ficou conhecida como “Personal Home Page Tools” (ferramentas
para página pessoal). Era composta por um sistema bastante simples que interpretava
algumas macros e alguns utilitários que rodavam “por trás” das home-pages: um livro de
visitas, um contador, etc...
Em meados de 1995 o interpretador foi reescrito, e ganhou o nome de PHP/FI, o “FI”
veio de um outro pacote escrito por Rasmus que interpretava dados de formulários HTML
(Form Interpreter). Ele combinou os scripts do pacote Personal Home Page Tools com o FI e
adicionou suporte a mSQL, nascendo assim o PHP/FI.
Em 1997, PHP/FI 2.0, a segunda versão lançada da implementação C, obteve
milhares de usuários ao redor do mundo (estimado), com aproximadamente 50,000 domínios
reportando que tinha PHP/FI 2.0 instalado, obtendo 1% dos domínios da Internet. Enquanto
isto havia milhares de pessoas contribuindo com pequenos códigos para o projeto, e ainda
 17

assim o PHP/FI 2.0 foi oficialmente lançado somente em Novembro de 1997, após perder a
maior parte de sua vida em versões betas. Ele foi rapidamente substituído pelas versões do
PHP 3.0. Uma das maiores características do PHP 3.0 era sua forte capacidade de
extensibilidade. Em seu pico, o PHP 3.0 foi instalado em aproximadamente 10% dos
servidores Web da Internet. Os objetivos do projeto eram melhorar a performance de
aplicações complexas.
A empresa Zend Engine fazendo disso um grande sucesso, foi introduzida em meados
de 1999 lançando então a versão do PHP4 no ano 2000 com altíssimo grau de
melhoramento de performance. Atualmente, a versão do PHP5 já foi lançada com novas
funcionalidades e diretivas e a maioria dos códigos do PHP4 são entendidos pela versão do
PHP5 sem problemas de incompatibilidade entre as versões.
 18

3. TEMPLATES

3.1. O que são Templates (Modelos)?

De acordo com Orth (2004, p.10) de forma resumida, o “objetivo dos modelos
(templates) é separar a lógica do programa da lógica de exibição”. Isso não consiste em
separar o código HTML do código PHP, mas sim em colocar em lugares separados os
códigos responsáveis pela exibição e os códigos responsáveis por outras tarefas, como por
exemplo, o acesso e obtenção de informações de um banco de dados.
Portanto, o objetivo é criar scripts PHP independentes do layout que será utilizado para
exibir o conteúdo da página. Fazendo essa separação, facilita-se a compreensão como a
manutenção do código dos programas. Existem controvérsias com relação ao uso de
templates, mas, a maioria dos programadores que começam a usá-los, adotam-no como
ferramenta contínua no trabalho. De acordo com a faq (perguntas mais freqüêntes) sugerida
no site PHP Brasil, por Villa, acesso em http://phpbrasil.com/faqs/faq.php/id/1417, 2004, a
maioria dos programadores aprovam o uso dos templates em seus projetos.

3.2. Finalidade do uso de Templates

Suponha-se uma empresa de soluções para Web, que desenvolve e presta

manutenção de websites. Fora contratado um funcionário para trabalhar como programador
PHP, ou seja, este será responsável pela codificação PHP. Significa que, a estrutura visual
das páginas não será criada por este programador e sim pelo designer. Isto é muito comum
em grandes empresas onde nem sempre é o mesmo funcionário que desenvolve o layout e
a programação.
Portanto, a criação dos templates tornam possível esta separação entre código de
programação e a parte visual do site para que se possa ter um ganho de produtividade e
adequação do sistema aproveitando-se o máximo de recursos por parte de cada profissional
envolvido. Para estes profissionais, será muito mais fácil adequar um sistema de
documentação da página e manutenção do código, pois cada um cuidará de sua parte
predominante. A iteração entre os desenvolvedores (designer e programador) será facilitada,
pois, cada um solicitará somente o necessário para interface entre os códigos. Para que haja
esta separação entre código PHP aplicado à página, faz-se necessário o uso de um bom
sistema de templates que facilitará ao designer e ao programador PHP que terão suas
tarefas divididas e poderão contirnuar trabalhando em conjunto para o desenvolvimento da
sistema solicitado.
 19

3.3. Dificuldades de um sistema com códigos PHP e HTML

misturados

O programador receberá do designer a página HTML pronta e terá a incumbência de

inserir o código PHP e fazer com que a página se torne dinâmica. Esta página com certeza
voltará várias vezes para o designer que fará os ajustes necessários no layout. Neste caso,
não seria adequado entregar ao mesmo uma página repleta de códigos PHP. Com certeza
não seria o ideal por duas razões: Normalmente, o designer não entende de código PHP, o
que faria com que ficasse confuso ao manipular uma página repleta de códigos PHP e por
fim, poderia alterar a estrutura dos códigos sem perceber, prejudicando o funcionamento da
página. O mesmo acontece com o programador que não precisará se importar com a
codificação HTML e outros compontentes que não sejam de sua alçada.
Em resumo, existem desvantagens na manipulação de elementos de um sistema
programado em PHP e repleto de códigos HTML entre outros, pois se misturam. Os
programas ficarão mais difíceis de se entender por conta dessa mistura de códigos. Poderão
existir diversos profissionais trabalhando em conjunto para o desenvolvimento do mesmo
sistema e por mais que se haja a documentação estes deverão entender o que os demais
estão fazendo para continuar o trabalho. Esta tarefa pode se tornar mais complexa na
medida que os códigos aumentam.

3.4. As ferramentas existentes

Segundo Niederauer (1999, p.280), “qualquer método que separe a lógica do

programa da lógica de programação pode ser considerado um modelo ou template”. Muitos
criam sistemas proprietários de templates, para uso em projetos menores. Niederauer (1999,
p.280) também descreve que, não há necessidade de se perder tempo criando a própria
ferramenta de templates, pois há no mercado, várias plataformas prontas para uso, como
exemplos são:

• Smarty
• FastTemplate
• PowerTemplate
• Xtemplate
• ecTemplate
• Atemplate
 20

Essas ferramentas oferecem a funcionalidade de substituição básica de variáveis e

permitem criar blocos dinâmicos nos modelos. A ferramenta Smarty possui arquivos de
configuração, funções para templates, modificadores de variáveis e oferece muitas outras
funcionalidades para programadores e designers. De acordo com Niederauer (1999, p.280),
essas são algumas das razões mais vantajosas da ferramenta Smarty em relação as
demais.
 21

4. FERRAMENTA DE TEMPLATES “SMARTY TEMPLATE ENGINE”

FIGURA 1 – Logotipo da Smarty Template Engine

4.1. O que é o Smarty?

É um pacote de códigos criado por David Hahn, que hoje é CEO da empresa New
Digital Group (localizada em Lincoln, Nebraska e fundada recentemente em, 2005),
especializada em construir redes de publicidades online. Smarty é um sistema de templates
para PHP, mais especificamente, fornece uma maneira fácil de controlar a separação da
aplicação lógica e o conteúdo de sua apresentação.
Um objetivo do projeto Smarty é a separação da lógica do negócio e da lógica da
apresentação. Isto significa que os templates podem certamente conter a lógica sob a
circunstância que é somente para apresentação. Alguns exemplos são: a inclusão de outros
templates, alternação de cores nas linhas das tabelas, colocar o texto de uma variável em
maiúsculo, percorrer uma matriz de dados e mostrá-la, etc. são todos exemplos de
apresentação lógica. Isto não significa que o Smarty força a separação da lógica de
negócios e da lógica de apresentação. O Smarty não tem conhecimento do que é o que na
aplicação.
Um dos aspectos únicos do Smarty é seu sistema de compilação de templates. O
Smarty lê os arquivos de templates e cria scripts PHP a partir deles. Uma vez criados, eles
são executados sem ser necessária uma outra compilação do template novamente. Com
isso, os arquivos de template não são 'parseados' (analisados) toda vez que um template é
solicitado, e cada template tem a total vantagem de soluções de cache do compilador PHP.

4.2. Características do Smarty que o torna poderoso

Desde que o Smarty ficou conhecido como um “mecanismo de template”, poderia ter
sido chamado mais precisamente como uma “estrutura de apresentação”. Isto é, provê que o
programador e o projetista do template com uma riqueza de ferramentas, automatizar tarefas
comumente negociáveis com a camada de uma apresentação. Embora possa ser usado
para um simples propósito, seu foco é o desenvolvimento rápido e sem problemas enquanto
mantém alta performance, escalabilidade, segurança e crescimento futuro.
 22

Algumas características mais notáveis que o torna eficiente conforme o Site oficial da
Smarty, acesso em http://smarty.php.net/rightforme.php, mar, 2005.
• Caching: Smarty provê características mais refinadas para o cache de todas as partes
de uma página de web renderizada, ou deixar partes sem cachê. Os programadores
podem registrar funções de templates como “cacheáveis” ou “não-cacheáveis”, grupos
de páginas com cachê dentro de unidades lógicas para melhor manutenção, etc.
• Arquivos de configuração: O smarty pode admitir variáveis puxadas de arquivos
configuráveis. Os designers podem manter valores comuns para muitos templates em
uma locação sem a intervenção de programadores, e variáveis configuráveis podem
ser facilmente compartilhadas entre programadores e porções de apresentação de
uma aplicação.
• Segurança: Templates não contem código PHP. Por esta razão, um designer de
templates está desatrelado ao completo poder do PHP, mas somente com o
subconjunto disponível para eles, vindo dos programadores.
• Fácil de usar e manter: Designers de páginas de web não lidam com sintaxe de
código PHP, mas ao invés, lidam com sintaxe de templates fácil de usar não muito
diferente do plano HTML. Os templates são muito próximos de uma representação
final de saída. Drasticamente encurtam o ciclo de projeto.
• Modificadores de variáveis: O conteúdo de variáveis atribuídas pode ser facilmente
ajustado para mostrar hora com modificadores, tal como mostrar tudo maiúsculo,
HTML espaçado, formatação de data, truncar os blocos de texto, adicionar espaços
entre caracteres, etc.
• Funções Templates: Muitas funções estão disponíveis para o designer de templates
para manusear tais tarefas, tais como gerar seguimentos de código HTML (dropdowns,
tabelas, pop-ups, etc.), mostrando conteúdo de outros templates em linha, conteúdo de
vetores de loop, formatação de texto para saída de emails, cores cíclicas.
• Filtros: O programador tem completo controle da saída e compilação dos conteúdos
dos templates com os pré-filtros, pós-filtros e filtros de saída.
• Recursos: Templates podem ser baixados de inúmeras fontes, criando novos
manipuladores de recursos, e então usá-los nos projetos.
• Plugins: Quase todos os aspectos do Smarty são controlados com o uso de plugins.
Eles são geralmente tão fácil quanto jogá-los dentro de um diretório e então,
mencionando-os no template ou usando-os no código da aplicação.
• Add-ons: Muitos Add-nos de comunidades contribuintes estão disponíveis tais como
Paginação, Formulários de validação, Menus Drop Down, Calendários, etc...Essas
 23

ferramentas ajudam a acelerar o ciclo de desenvolvimento, não há necessidade de

reinventar a roda ou debugar código que já estão estáveis e prontos para uso.
• Depuração: O Smarty vem com uma console integrada de depuração então, o
designer pode ver todas as variáveis atribuídas e o programador pode investigar
velocidades de renderização.
• Compilação: O Smarty compila templates dentro do código PHP atrás das cenas,
eliminando problemas de Run-time nos tremplates.
• Performance: O Smarty funciona extremamente bem, apesar de uma vasta gama de
características. A maioria da capacidade do Smarty é carregada por demanda. O
smarty vem com inúmeras ferramentas de apresentação, minimizando códigos de
aplicação e resultando em rapidez, menos propenso a erros no desenvolvimento e na
manutenção. O smarty template compila arquivos PHP internamente (uma só vez),
eliminando custo de busca e influenciando na velocidade de códigos operadores e
aceleradores do PHP.

4.3. Funcionamento do Smarty PHP

Seu funcionamento consiste em fazer uma espécie de compilação, convertendo os

templates para scripts PHP. Se não fossem utilizados, normalmente teria uma única página
PHP, contendo programação e HTML juntas.
Portanto, sem templates tem-se uma página do tipo:

teste.php
<html>
<body>
<?php
while…bla
?>
</body>
</html>

FIGURA 2 – Arquivo teste.php

Já utilizando a ferramenta de template como a Smarty, têm-se dois arquivos, sendo um

com a programação PHP e outro com o layout (HTML) e os elementos da Smarty (variáveis,
funções, etc.). Utilizando esses dois arquivos, a Smarty criará o arquivo final que mistura
HTML e PHP.
 24

Utilizando-se templates, tem-se duas páginas:

• Página PHP com a programação
• Pagina do template contendo o layout. Esse será o arquivo usado pelo designer.
Normalmente utiliza-se a extensão .tpl para esse tipo de arquivo.

FIGURA 3 – Arquivo compilado teste.tpl.php

Segundo Niederauer (1999, p.282), “ muitos desenvolvedores web reclamam da perda

de desempenho de suas aplicações devido ao uso de ferramentas de templates. A Smarty
tenta reduzir essa perda exatamente por esse processo de reutilizar os scripts já
compilados.”
Por essa razão, a diferença de velocidade muitas vezes nem é percebida,
principalmente quando as páginas envolvidas não são muito complexas.
Portanto têm-se duas situações:
• ter um código mais confuso e atingir o máximo de desempenho nas aplicações.
• melhorar a compreensão e manutenção do código, apesar da perda de um pouco de
desempenho. Neste caso, a melhor opção são os templates.

4.4. Como fazer a instalação do Smarty PHP

Para executar a Smarty será necessário que a versão do PHP seja 4.0.6 ou superior.
O Smarty é uma ferramenta que pode ser baixada livremente na internet bem como sua
documentação, direto do site Templates disponível em http://smarty.php.net/.
 25

Após a descompactação do arquivo de download serão criados uma pasta com os

arquivos de instalação incluindo um subdiretório chamado libs, que será necessário em local
adequado no servidor. Será importante o local onde serão armazenados, pois no início dos
programas deverá ser incluída uma chamada para a classe Smarty. Esses arquivos serão
acessados através dos programas, e nunca diretamente pelo navegador. Por esta razão, por
questões de segurança, é recomendável que os arquivos sejam colocados fora da raiz do
servidor web (document root). Dessa forma, não poderão ser acessados com uma chamada
direta através do navegador. Basicamente, copia-se o diretório libs para dentro da pasta
onde o PHP está instalado e instancia-se os templates dentro dos arquivos PHP que serão
usados juntamente com os templates como será visto a seguir.

4.5. Inclusão de uma chamada para a classe

Armazenando, por exemplo, os arquivos em um diretório chamado libs, considerando

que o programa PHP se encontra no mesmo local desse diretório, devem-se executar as
seguintes linhas no início do programa para criar uma instância da classe Smarty:
require(“libs/smarty.class.php”);
$smarty = new smarty;

A smarty permite o uso de uma constante chamada SMARTY_DIR, que armazena o

caminho do sistema dos arquivos da biblioteca. No entanto, não é obrigatório o uso da
constante.
Existem três maneiras de ativar a biblioteca nos programas PHP:
• Fornecendo diretamente o caminho para o arquivo.
Exemplo:
require(‘c:/php5/smarty/smarty.class.php’);
$smarty = new Smarty;
• Adicionando o diretório da classe na diretiva include_path em seu arquivo de
configuração php.ini, e logo após reiniciando o servidor.
Neste caso, bastaria passar o nome da classe como parâmetro:
require(‘smarty.class.php’);
$smarty = new smarty;
• Definindo o valor da constante SMARTY_DIR antes de incluir a chamada para a
classe.
define(‘SMARTY_DUST’,’c:/php5/smarty/’);
require(SMARTY_DIR.’Smarty.class.php’);
$smarty = new smarty;
 26

4.6. Estrutura da aplicação

Para utilizar uma aplicação Smarty será necessária a criação de alguns diretórios. A
Smarty requer quatro diretórios que, por padrão, são nomeados como:
DIRETÓRIO DESCRIÇÃO
templates Armazena os arquivos dos templates(modelos).
templates_c Diretório que armazena os templates compilados. Deve
possuir permissão de escrita.
configs Armazena arquivos de configuração, se houverem.
cache Armazena os arquivos de cache, e não ser criado caso
essa funcionalidade esteja desabilitada. Deve possuir
permissão de escrita.

Os nomes desses diretórios estão definidos nas propriedades da classe, nas variáveis
$template_dir, $compile_dir, $config_dir e $cache_dir. É recomendável a criação desses
diretórios separadamente para cada aplicação a ser desenvolvida.
Por exemplo, uma aplicação que apresenta a lista de produtos de uma empresa, e a
raiz do servidor web fosse /www, poderia ter a seguinte estrutura:
/www/produtos/templates/
/www/produtos/templates/produtos.tpl
/www/produtos/templates_c/
/www/produtos/config/
/www/produtos/cache/
/www/produtos/produtos.php

São necessários apenas dois arquivos, os restantes são diretórios que serão utilizados
pela Smarty. O arquivo produtos.tpl seria o arquivo do template, ou seja, aquele que define o
layout da página, enquanto que o arquivo produtos.php seria o programa PHP responsável
por obter as informações sobre os produtos.
É comum também nomear o programa principal como index.php, para simplificar o
acesso ao navegador. Por exemplo, se o arquivo produtos.php fosse nomeado para
index.php, ao invés de digitar no navegador.
http://dominio.com.br/produtos/produtos.php
bastaria digitar:
http://dominio.com.br/produtos
 27

Isto acontece porque normalmente os servidores web que suportam PHP são
configurados para utilizar a página index.php como sendo a página inicial de um diretório.
Importante: O /www não faz parte do endereço, pois, ele é o diretório raiz do servidor
web (document root), portanto, ao digitar o endereço do site, já estará acessando os
arquivos localizados dentro do diretório /www.

4.7. Algumas particularidades do Smarty

Serão apresentadas algumas características e particularidades da ferramenta Smarty

Template engine.

4.7.1. Delimitadores

Os elementos do Smarty devem estar sempre entre delimitadores utilizados pela

ferramenta, que por padrão são “(”e”)”. Porém, pode-se alterá-los modificando o valor das
variáveis $left_delimiter e $right_delimiter no arquivo da classe Smarty (smarty.class.php).
Orth (2004, p.19)
Exemplo:
olá {$nome}

4.7.2. Comentários

Dentro dos delimitadores, pode-se incluir comentários para documentar os templates

que são criados. Para inserir comentários, deve-se utilizar o caractere “*”. Orth (2004, p.19).
Exemplo:
{* smarty *}
{* Exibir o nome *}
olá {$nome} <br>
{* Exibir endereço *}
Seu endereço é {$endereco}

4.7.3. Funções

Além de colocar variáveis e comentários nas tags da Smarty, pode-se também incluir
uma chamada para alguma função. Orth (2004, p.19).
Existem dois tipos de funções:
• Embutidas – são as funções internas da Smarty, e não podem ser modificadas.
Exemplo:
 28

if, elseif, else, section.

• Personalizadas – são as funções adicionais, acrescentadas através de plugins. Pode-
se modificá-las se desejar, exemplo: assign, eval, fetch, html_options. É nesse grupo
que serão incluídas as funções que venham a ser criadas.
A sintaxe básica para a chamada de funções é a seguinte:
{nome_função atributo1=“valor” atributo2=“valor”…}
Dependendo da função, pode existir ou não atributos relacionados a ela.
A seguir, um exemplo envolvendo as funções include e if :
{include file=“cabecalho.tpl”}
{if $nome eq “Samuel”}
Seja bem-vindo!
{else}
Desculpe {$nome}, você não pode acessar esta página.
{/if}

4.7.4. Atributos

Usar atributos na Smarty é muito semelhante a usar atributos nas tags HTML. Eles
servem para passar informações à função, definindo como será o seu funcionamento.
Passando-se uma string como valor do atributo, recomenda-se utilizar aspas em torno
dela. As aspas não são necessárias caso seja fornecida uma variável ao invés de uma
string, ou se o valor do atributo for lógico (como true, false, yes, no). Orth (2004, p.20).
Exemplo:
{include file=“cabecalho.tpl”}
{include file=$nome_arquivo}
{include file=#nome_arquivo#}
{html_select_date display_days=yes}
<SELECT name=lista>
{html_options value=$valores selected=$selecionado output=$saida}
</SELECT>

4.7.5. Variáveis

Existem três tipos de variáveis que podem ser usadas em uma aplicação Smarty.
• Variáveis definidas pelo PHP – iniciam com o caracter $. Podem ser variáveis
simples, arrays indexados, arrays associativos ou objetos. Orth (2004, p.23).
Exemplo:
 29

{$nome}
{$dados[0]}
{$dados.nome}
{$dados->nome}

• Variáveis definidas em arquivos de configuração – são definidas nos arquivos

localizados no diretório configs da aplicação. Normalmente utiliza-se a extensão .conf
para esses arquivos. Para utilizar essas variáveis no template, delimitá-las com o
caracter “#”, ou então utilize a variável especial $smarty.config.
Exemplo:
{#nome#}
ou
{$smarty.config.nome}

• Variável reservada {$smarty} – através dessa variável, pode-se acessar diversas

informações sobre o template, sobre o ambiente, obter o valor de cookies, de variáveis
recebidas via método GET ou POST.
Exemplo:
{* exibe o valor do cookie “nomeusuario” *}
{$smarty.cookies.nomeusuario}
{* exibe o valor da variável do servidor “SERVER_NAME”}
{$smarty.server.SERVER_NAME}
{* exibe o valor da variável de sessão“nome”}
{$smarty.session.nome}
{*data atual formatada*}
{$smarty.now|date_format:“%y-%m-%d %H:%M:%S”}

4.7.6. Modificadores de variáveis

O objetivo dos modificadores é produzir alguma alteração em uma variável, função

personalizada ou string. Devem ser acrescentados ao lado desses elementos, sendo
percebidos pelo caracter | (pipe). Orth (2004, p.28).
Por exemplo, para exibir o conteúdo da variável $nome com letras maiúsculas:
{$nome|upper}

É possível aplicar mais de um modificador a uma variável. Para isso basta colocá-los
em seqüência, separados pelo caracter | (pipe). A ordem de aplicação é da esquerda para a
 30

direita. Por exemplo, para exibir o conteúdo da variável $nome com letras minúsculas e com
um espaço entre cada caracter, tem-se:
{$nome|lower|spacify}

Alguns modificadores podem receber parâmetros adicionais, que irão afetar o seu
comportamento. Esses parâmetros devem ser especificados após o nome do modificador,
sendo precedidos pelo caracter : (dois pontos). Por exemplo, para exibir apenas os 30
primeiros caracteres da variável $nome, tem-se:
{$nome|truncate:30}

A seguir será apresentada a lista dos modificadores da Smarty que podem ser
utilizados, bem como uma descrição do que cada um deles faz:
• capitalize – coloca em maiúsculas as primeiras letras de cada palavra contida na
variável.
• count_characters – retorna o número de caracteres de uma variável.
• cat – permite a concatenação de um valor ao conteúdo da variável. O valor a ser
concatenado deve ser passado como parâmetro.
• count_paragraphs – retorna o número de parágrafos existentes no conteúdo de uma
variável.
• count_sentences – retorna o número de palavras existentes no conteúdo de uma
variável.
• date_format – formata a data e a hora. Esse modificador permite aos designers ter o
controle sobre o formato que a data deve ser exibida ao usuário.
• default – define um valor padrão para uma variável. Esse valor deve ser passado
como parâmetro, e será utilizado caso a variável esteja vazia ou não definida.
• escape – formata o valor da variável de acordo com o tipo fornecido como parâmetro.
Os tipos possíveis são html, htmlall, url, quotes, hexentity e javascript. O padrão é html.
• indent – faz a identificação das linhas da string. Possui dois parâmetros opcionais,
para especificar o número de caracteres a serem identados e o caracter a ser usado
para fazer a indentificação.
• lower – exibe o conteúdo de uma variável em letras minúsculas.
• nl2br – converte todas as quebras de linha <br/> no conteúdo da variável.
• regex_replace – realiza busca e substituição de expressões regulares em uma
variável.
• replace – realiza busca e substituição em uma variável.
 31

• spacify – permite incluir um espaço entre cada caracter . Pode-se ainda especificar
outro caracter ou com a string a ser usada ao invés de um espaço.
• string_format – formata uma string. Pode ser usada, por exemplo, para números
decimais. A sintaxe é semelhante a do comando sprint do PHP.
• strip – substitui espaços, quebras de linhas e tabulações repetidas por um espaço
simples ou com a string fornecida como parâmetro.
• strip_tags – remove as tags de marcação , ou seja, os trechos delimitados pelos
caracteres < e >.
• truncate – trunca uma variável em um determinado tamanho. Se nenhum tamanho for
fornecido, será usado o padrão (80). Opcionalmente, pode-se definir um texto a ser
exibido ao final, caso a variável seja truncada.
• upper – exibe o conteúdo de uma variável em letras maiúsculas.
• wordwrap – define uma largura para cada coluna em uma string se nenhum tamanho
for fornecido, será usado o valor padrão (80). Opcionalmente, pode-se especificar um
segundo parâmetro, indicando o caracter ou string a ser usada na troca de linha. O
padrão é \n.

O exemplo a seguir utiliza o modificador capitalize para converter a primeira letra de

cada palavra da variável $titulo para maiúscula:
index.php
<?php
require(‘smarty.class.php’);
$smarty = new smarty;
$smarty -> assign (‘titulo’,’Palmeiras campeão brasileiro’);
$smarty -> display (‘index.tpl’);
?>
index.tpl
{$titulo}<br>
{$titulo|capitalize}
RESULTADO:
Palmeiras campeão brasileiro
Palmeiras Campeão Brasileiro

4.7.7. Arquivos de configuração

Os arquivos de configuração, que devem estar localizados no diretório “configs” da

aplicação, são de grande utilidade para os designers. Pode-se manter nesses arquivos todas
 32

as variáveis globais, que serão usadas em várias páginas. Por exemplo, poderia ser definida
uma variável global contendo a cor de fundo das páginas. Se o designer quiser trocar essa
cor, bastaria editar um arquivo, e a nova cor seria aplicada em todos os templates que
utilizassem essa variável. Orth (2004, p.88).
Para utilizar um arquivo de configuração em um template, deve-se carregá-lo com a
função config_load. Por exemplo:
{config_load file=”teste.conf”}
Algumas considerações em relação aos arquivos de configuração:
• Para incluir comentários nesses arquivos, procura-se utilizar o caracter # no início de
cada linha.
• Não é obrigatório o uso de aspas em torno dos valores das variáveis.
• Valores que ocupam mais de uma linha devem ser delimitados por aspas triplas (“””).
• É possível criar seções de variáveis, e posteriormente carregar apenas as seções
desejadas. O nome das seções deve estar entre ([ ]).
• As variáveis globais, definidas fora das seções, serão sempre carregadas quando o
arquivo for carregado.
• Se existir uma variável global e uma de seção com o mesmo nome, será considerada
a de seção.
• É possível ocultar outras variáveis ou seções inteiras. Isto é útil nos casos em que as
variáveis serão usadas apenas pelo programador, não interessando ao criador dos
templates (ex. informações sobre o banco de dados). Para ocultar variáveis ou seções,
acrescente um ponto(.) antes de seus nomes.

A seguir um exemplo de arquivo de configuração e será nomeado como index.conf.

#variáveis globais
titulo = “Esta é a smarty!!!”
corFundo = #D6D6D6
corTitulo = #0000FF
[Margens]
margemSuperior = 10
margemEsquerda = 10

Esse arquivo deve estar no diretório “configs”, e para poder utilizar o valor dessas
variáveis no template, pode-se chamá-lo da seguinte forma:
{config_load file=“index.conf”}
 33

Porém, se for chamado assim, estarão disponíveis apenas as variáveis globais, ou

seja, aquelas definidas fora da seção [margens]. Para utilizá-las todas, deve-se acrescentar
o parâmetro section na função config_load.
 34

5. APLICAÇÕES UTILIZANDO SMARTY TEMPLATES

A seguir, serão descritos 3 exemplos de aplicações para demonstração de uso,

vantagens e diferenças do uso de aplicações com o Smarty Templates e aplicações feitas
com com mistura de códigos.

5.1. SISTEMA DE NOTÍCIAS

Refere-se a um sistema de notícias on-line para que seja demonstrado as vantagens

do esquema de separação e documentação dos códigos quando se usa templates, ou seja,
demonstrar o uso da Smarty Template na confecão da página.
Basicamente, os arquivos estão separados em três tipos, um arquivo de configuração
index.conf responsável por ajustes de cores, margens e fontes das páginas exibidas pelos
templates index.tpl e mostra_notícias.tpl que são responsáveis pela exibição da página bem
como informações do sistema como data, hora, nome do servidor e os arquivos index.php e
mostra_notícias.php que fazem as conexões com o banco de dados e passam as notícias
através de variáveis instanciadas para os templates.
A seguir, demonstra-se nas figuras e exemplos de arquivos que a separação dos
códigos é efetiva e facilmente identifica-se a parte documental de cada profissional, ou seja,
do programador e do designer, que fica mais predominante para cada tipo de codificação
conforme desenvolvimento de cada um.
Em todos os arquivos há uma documentação específica para as linhas mais
importantes de códigos e suas funcionalidades que são rápidamente explicadas.

Documentação
ou comentários

Diretório
configs
Variáveis de configuração

EXEMPLO 1 – Arquivo index.conf

As variáveis e a documentação são facilmente identificáveis. Observa-se que o

arquivos estarão cada um em sua pasta conforme recomendado pelo Smarty Templates.
 35

Documentação
ou comentários

Ex de variável vinda do
arq index.conf

HTML

Modificador de
Variável Smarty

EXEMPLO 2 – Arquivo index.tpl

No exemplo 2, existe um modificador de variáveis Smarty chamado date_format que

em dois momentos é utilizado. Em um deles, recebe de uma variável reservada Smarty
$smarty.now que busca a data do sistema e é formatada pelo modificador date_format. Em
um segundo momento, recebe a data da variável $datas[i] do PHP que também é formatada
pelo modificador date_format para posterior exibição.

Documentação
ou comentários

Diretório templates

Variável reservada
Smarty, exibe o
nome do servidor

EXEMPLO 3 – Arquivo mostra_noticias.tpl

No exemplo 3, também fica visível a separação dos códigos e funções Smarty bem
como sua documentação.
 36

Na sequência, será exibido pelo exemplo 4, o arquivo index.php onde a codificação é

totalmente diferente, facilmente reconhecida e “limpa” de outros tipos de códigos. Somente
código PHP está no arquivo.

Variáveis PHP
carregadas
com valores do
banco de dados

Variáveis PHP que

serão enviadas ao
template

EXEMPLO 4 – Arquivo index.php

Em seguida, serão demonstrados os resultados finais das páginas que foram

desenvolvidas usando a Smarty Templates.
A figura 4 demonstrará a página principal com o índice de notícias e a figura 5
demonstrará uma das notícias anunciadas após acesso do link “[Leia mais]”.
 37

FIGURA 4 – Resultado da página principal das notícias

FIGURA 5 – Resultado de uma das notícias indicadas

 38

5.2. SISTEMA DE LISTAGEM DE UM CADASTRO DE LIVROS

Refere-se a um sistema de listagem de um cadastro de livros que visa demonstrar a

diferença de uma aplicação desenvolvida com mistura de códigos PHP e HTML e a mesma
aplicação desenvolvida usando templates. Isto é, demonstrar as dificuldades que uma
página repleta de mistura de códigos tem em relação ao uso da Smarty Templates no
desenvolvimento da mesma aplicação.
O exemplo 5 demonstra a página da aplicação escrita usando PHP e HTML
misturados. Pode-se observar que o código fica confuso de se entender devido a essa
mistura que se torna mais complexa quanto maior a quantidade de código. Mesmo para uma
pessoa com experiência, pode-se levar um tempo para entendimento caso seja uma
aplicação muito grande.
Pode acontecer de, mais profissionais terem que atuar no desenvolvimento do sistema
e com isso a junção dos códigos pode acabar dificultando para que todos possam intervir
nesse trabalho.
Por fim, incluindo-se a documentação interna da página, esta tem que ser muito bem
detalhada a medida que exista um aumento de desenvolvimento para que não se perca o
controle e facilite o entendimento do código escrito.

PHP

HTML

PHP MIX DE
CÓDIGOS
!!!!!
HTML

EXEMPLO 5 – PHP misturado com HTML

 39

Os exemplos 6 e 7 a seguir, demonstrão a mesma aplicação utilizando a Smarty e

poderá ser notado com muita clareza que a separação dos códigos tornara o ambiente de
desenvolvimento mais adequado à cada profissional envolvido, ou seja, aquele que escreve
o código da aplicação só mexerá neste, ao passo que os designers farão somente a parte
visual. Nenhum deles terá que se preocupar com o trabalho de desenvolvimento do outro a
não ser, o trabalho em conjunto quando da definição das variáveis que serão trocadas entre
as páginas.
Cada qual fará sua documentação conforme o código aplicado e neste caso, com
certeza a apresentação de cada profissional será mais adequada e clara facilitando para
qualquer outro que, por exemplo, possa estar ajudando no trabalho de codificação.

SOMENTE
PHP
!!!!!

EXEMPLO 6 – Arquivo com PHP puro

 40

SOMENTE
SMARTY
!!!!!

EXEMPLO 7 – Arquivo template escrito com a Smarty

Comparando-se o exemplo 5 contendo mistura de códigos com os exemplos 6 e 7

nota-se claramente a diferença dos códigos descritos. Portanto, a eficiência na codificação é
mais efetiva com a separação dos códigos do que a junção de todos os elementos de
programação em uma única página.
A figura 6 abaixo demonstrará exatamente a mesma página escrita com as diferentes
formas de programação como apresentado anteriormente, ou seja, com mistura de códigos e
com o uso da Smarty Templates.
 41

FIGURA 6 – Mesma página desenvolvida em ambas as codificações

5.3. GERADOR DE FORMULÁRIO DE CONTATOS COMO UMA

NOVA FUNCIONALIDADE

Esta aplicação tem como finalidade a geração de um formulário de contato somente

com a passagem das variáveis pela página PHP e instanciando-se um template Smarty que
montará todo o formulário de contato automaticamente. O simples fato de deixar um
template fazer toda a rotina de montagem do formulário de contatos torna muito mais fácil o
trabalho dos programadores.
O programador da codificação PHP só precisará de um simples arquivo para
passagem de variáveis com os arrays de estados e siglas e instanciar o template.
Para o designer, se este quiser alterar o visual do formulário necessitará somente de
ajustar o arquivo de configuração para que o visual seja alterado. Isto facilitará para o caso
de se desenvolver mais de uma aplicação onde será necessário a inclusão de formulário de
contatos à pedido dos clientes ao desenvolvedor.
 42

O exemplo 8 demonstrará que a página PHP será muito mais simplificada enquanto o
template ficará com a parte pesada de programação visual.

Instancia-se
somente o form de
contato!

EXEMPLO 8 – Arquivo PHP de chamada do formulário de contato

Caso necessite um ou outro ajuste o designer terá muito mais facilidade de atuar no
mesmo usando o arquivo de configuração, pois, algumas codificações como variáveis de
cores se repetem várias vezes e será necessário somente a alteração de uma única variável
no arquivo de configuração para alteração do visual do form. Praticamente, não haverá
mudanças internas do arquivo de template. A seguir, apresenta-se no exemplo 9, um
trecho do arquivo index.tpl que é o template gerador do formulário de contato onde o
mesmo recebe as variáveis vindas do arquivo index.php. No trecho da tag “select”,
essas variáveis fazem com que o formulário exiba o menu de estados e pode ser
alterado para exibir, por exemplo, somente siglas ao invés do nome dos estados
bastando alterar o valor de “output” para siglas, que também é variável disponível do
arquivo index.php.
Variáveis do arquivo de
configuração !

Gera o menu de
EXEMPLO 9 – Trecho do template de geração do form
estados no form !
 43

Na seqüência, a figura 7 mostra o exemplo de um formulário gerado pela Smarty

conforme explicado anteriormente.

FIGURA 7 - Formulário de contato gerado pela Smarty

Nota-se na figura 7, que o menu aberto apresenta a configuração de estados,

mas pode ser alterado pelo designer com muita facilidade para apresentar somente
siglas, conforme exposto no exemplo 9, onde está indicado por um balão “Gera o
menu de estados no form!”.
 44

6. CONCLUSÃO

O uso da ferramenta de templates Smarty Template Engine realmente é efetivo e

proporciona um ambiente de programação melhorado comparando-se com a programação
tradicional efetuada com mistura de códigos. A separação dos códigos de aplicação em
relação aos códigos de exibição é mais vantajosa por diversos motivos.
O desempenho altera-se em absolutamente nada ao longo do uso do site, pois, logo
após a primeira compilação do template, já não existirá mais diferença de performance
alguma.
Os programadores e designers poderão trabalhar em uma mesma aplicação sem que
seus trabalhos atrapalhem entre sí pelo fato de estarem programando cada qual em sua
parte. Desde que trabalhem em equipe nas definições das variáveis que serão
compartilhadas, será um conveniente passo para o sucesso da programação e do trabalho a
ser desenvolvido.
A documentação estará muito mais facilitada, pois, o designer fará a documentação de
seus templates e o programador PHP fará a documentação de seu código. Isto facilitará para
um outro profissional da mesma área que em um primeiro contato com a aplicação
entenderá com maior rapidez aquilo que lhe é pertinente.
Na programação com mistura de códigos há a possibilidade de um programador
cometer algum equívoco desestruturando a formatação da página, por exemplo. O designer
pode alterar um código PHP sem perceber fazendo com que uma consulta a um banco de
dados, por exemplo, pare de funcionar. No caso do uso de templates, não haverá essa
possibilidade já que cada um é entendido em sua função e não haverá a necessidade de se
preocupar com a parte alheia de codificação.
Existem inúmeras funções prontas que o Smarty proporciona que uma vez inserida na
aplicação facilitam o trabalho de ambos os programadores. Muitas delas não exigem que o
programador PHP desenvolva códigos, pois, já estão disponíveis bastando apenas instanciá-
las no template.
Uma vez desenvolvido um template juntamente com a codificação PHP, estes poderão
ser utilizados em outras aplicações com muita facilidade bastando somente alterar algumas
variáveis globais para que a aplicação tome um novo formato e o ganho de tempo que isso
proporciona é muito vantajoso quando se necessita, por exemplo, de agilidade na entrega de
um software para um cliente. No caso do exemplo do formulário de contatos, o mesmo
poderia ser inserido em outras aplicações bastando ser trocada somente a configuração
visual no template. Caso necessitasse de cidades ao invés de estados Brasileiros, facilmente
alterava-se, por exemplo, modificando somente o arquivo PHP onde está localizado o array.
 45

7. REFERÊNCIAS BIBLIOGRÁFICAS

HOJTSY, Gabor. PHP Documentation Group. Manual do PHP. HTM, 2004.

OHRT, Monte. Smarty Documentation. Smarty - a ferramenta para compilar

templates para PHP, 2004.

VILLA, Gustavo. Templates separam o PHP do design. Disponível via URL em:
http://phpbrasil.com/faqs/faq.php/id/1417. Acesso em: 11 de Novembro de 2004.

NIEDERAUER, Juliano. PHP para quem conhece PHP. 1.ed. São Paulo: Novatec, 1999.

SMARTY, Site. Is Smarty right for me? Disponível via URL em:
http://smarty.php.net/rightforme.php. Acesso em: 27 de Março de 2005.

SCHIMID, Egon. PHP Documentation Group. Documentação do PHP. [Internet:

http://www.php.net/download-docs.php, Acesso em: 10 de Setembro de 2004]

Site oficial do PHP no Brasil. PHP Brasil. [Internet:

http://www.phpbrasil.com/, Acesso em: 11 de Novembro de 2004]

Site oficial do PHP EUA. PHP.net. [Internet:

http://www.php.net/, Acesso em: 11 de Novembro de 2004]

Site oficial do Smarty. Smarty Template Engine. [Internet:

http://smarty.php.net/, Acesso em: 10 de Maio de 2005]

Smarty Documentation. , Smarty-2.6.9-docs.pdf. [Internet:

http://smarty.php.net/download-docs.php. Acesso em: 15 de Setembro de 2004]
 46

8. ANEXOS

8.1. Anexo 1 – index.conf – Sistema de notícias

Código do arquivo index.conf da aplicação “SISTEMA DE NOTÍCIAS”

#variáveis globais usadas para todos os templates se necessário

corFundo = #CCCC00
corTitulo = #FF0000
fonteFace = ARIAL
corTab = #EAEAEA

#variáveis específicas para definição de margens

[Margens]
margemSuperior = 50
margemEsquerda = 150

8.2. Anexo 2 – index.tpl – Sistema de notícias

Código do arquivo index.tpl da aplicação “SISTEMA DE NOTÍCIAS”

{* Define conexão com o arquivo de configuração do template *}

{config_load file="index.conf" section="Margens"}

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>

<body><font face="{#fonteFace#}">

<div align="center">
<table border="0" cellspacing="0" width="60%">
<tr>
<td width="50%" bgcolor="{#corTab#}">
<font size="5">Confira as &uacuteltimas
not&iacutecias!</font>
</td>
<td width="50%" bgcolor="{#corTab#}">

{* Busca e formata a data e hora atuais do servidor para

exibição *}
<p align="right"><b>{$smarty.now|date_format:"%d/%m/%Y
%H:%M:%S"}</b>
</td>
</tr>
<tr>
<td width="100%" colspan="1" bgcolor="#FBFBFB"><br>

{section name=i loop=$titulos}

{* Busca e formata a data e hora da notícia para exibição *}

<p><b><u>{$titulos[i]}</u></b>
<i>({$datas[i]|date_format:"%d/%m/%Y %H:%M"})</i><br>
 47

{* Exibe somente uma prévia da notícia com 100 caracteres *}

{$textos[i]|truncate:100}
{* link para o arquivo php que mostrará a notícia *}
[<a href="mostra_noticia.php?id={$ids[i]}">Leia mais</a>]</p>
{/section}
</td>
</tr>
</table>
</div>
</font>
</body>
</html>

8.3. Anexo 3 – mostra_noticias.tpl – Sistema de notícias

Código do arquivo mostra_noticias.tpl da aplicação “SISTEMA DE NOTÍCIAS”

{* Define conexão com o arquivo de configuração do template *}

{* Define conexão com o arquivo de configuração do template *}

{config_load file="index.conf" section="Margens"}

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

{* Variável título vinda como parâmetro do arquivo mostra_noticia.php *}

<title>{$titulo}</title>

</head>

{* Variáveis vindas do arquivo de config instanciado no princípio do

arquivo *}
<body bgcolor="{#corFundo#}" topmargin="{#margemSuperior#}"
leftmargin="{#margemEsquerda#}">

<p align="left">
<font face="{#fonteFace#}" size="5">{$titulo}<br>

{* Busca e formata a data e hora da notícia para exibição *}

<i>{$data|date_format:"Data: %d/%m/%Y Hora: %H:%M"} no servidor </i>

{* Busca nome do servidor no sistema *}

<i>{$smarty.server.SERVER_NAME}</i>
</font>
</p>
<hr>
<p align="justify"><font face="{#fonteFace#}" size="3">{$texto}</font></p>
<p align="center"><a href="javascript:history.back()"><font
face="{#fonteFace#}" size="3">Voltar</font></a></p>

</body>
</html>
 48

8.4. Anexo 4 – index.php – Sistema de notícias

Código do arquivo index.php da aplicação “SISTEMA DE NOTÍCIAS”

<?php
// ------ acesso ao banco de dados atraves do arquivo conexao.php ---------
-
require('conexao.php');

// ------ seleciona tabela de noticias -----------

$res = pg_query("select * from noticias order by data_hora desc limit
7");
$num_linhas = pg_num_rows($res);

// ------ faz loop para percorrer as linas da tabela e buscar resultados --

--------
for($i=0 ; $i<$num_linhas; $i++)
{
$array_ids[] = pg_result($res,$i,"id");
$array_titulos[] = pg_result($res,$i,"titulo");
$array_textos[] = pg_result($res,$i,"texto");
$array_datas[] = pg_result($res,$i,"data_hora");
}
// ------ fecha a conexao com o banco de dados -----------
pg_close($con);
// ------ variáveis atribuídas e enviadas aos templates ----------
require('c:/php5/libs/Smarty.class.php');
$smarty = new Smarty;
$smarty->assign("ids", $array_ids);
$smarty->assign("titulos", $array_titulos);
$smarty->assign("textos", $array_textos);
$smarty->assign("datas", $array_datas);
$smarty->display("index.tpl");
?>

8.5. Anexo 5 – mostra_noticia.php – Sistema de notícias

Código do arquivo mostra_noticia.php da aplicação “SISTEMA DE NOTÍCIAS”

<?php
// ------ recebe identificação da notícia a ser exibida ----
$id_noticia = $_GET['id'];

// ------ acesso ao banco de dados atraves do arquivo conexao.php ----

require('conexao.php');

// ------ query para busca de valores no banco de dados ----

$res = pg_query("select titulo,texto,data_hora from noticias where
id=$id_noticia");
$num_linhas = pg_numrows($res);

// ------ carrega valores nas variáveis ----

if($num_linhas>0)
{
$titulo = pg_result($res,0,"titulo");
$texto = pg_result($res,0,"texto");
$data = pg_result($res,0,"data_hora");
 49

// ------ fecha conexão de acesso ao banco de dados ----

pg_close($con);

// ---- instancia template, define variáveis e exibe o template -----

require('c:/php5/libs/Smarty.class.php');
$smarty = new Smarty;
$smarty->assign("titulo", $titulo);
$smarty->assign("texto", $texto);
$smarty->assign("data", $data);
$smarty->display("mostra_noticia.tpl");
?>

8.6. Anexo 6 – conexao.php – Sistema de notícias

Código do arquivo conexao.php da aplicação “SISTEMA DE NOTÍCIAS”

<!-- arquivo de configuração de conexão com banco de dados -->

<?php
$servidor = "localhost";
$base = "noticias";
$porta = "5432";
$usuario = "postgres";
$senha = "postgres";

$conect = "host=$servidor port=$porta dbname=$base user=$usuario

password=$senha";
$con = pg_connect($conect);

if(!$con)
die("Erro na Conexão!!");
?>

8.7. Anexo 7 – index_mix2.php – Sistema de Listagem de um

cadastro de livros

Código do arquivo index_mix2.php da aplicação “SISTEMA DE LISTAGEM DE UM

CADASTRO DE LIVROS”

<HTML><HEAD>
<TITLE>Guia de consulta de livros</TITLE>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</HEAD>
<!------ Define cor de fundo da página -->
<BODY BGCOLOR="#0000FF">
<?php
// ------ acesso ao banco de dados ----------
require('conexao.php');
// ------ seleciona tabela de noticias -----------
$res = pg_query("select titulo,autor,paginas,preco from livros order
by titulo") or die("Query falhou");

// ------ Coloca o título no menu

 50

echo '<h2 align="center"><font face="arial" color="ffffff">Guia de

consulta de livros</h2>';
// ------ Ajusta tabela a ser criada quando os dados forem exibidos e
coloca títulos nas colunas
echo '<table border=1 cellpadding=2 cellspacing=0
bordercolordark="#0000FF" bordercolorlight="#0000FF">';
echo '<tr bgcolor="#D6D6D6">';
echo '<td><b>Livros</b></td>';
echo '<td><b>Autores</b></td>';
echo '<td><b>P&aacuteginas</b></td>';
echo '<td><b>Valor R$</b></td>';
echo '</tr>';
// ------ loop para criação das linhas e ajuste de cores do intercalamento
das linhas
$x=0; while ($line = pg_fetch_object($res)):
if($x%2==0){$color="#AAAAFF";}else{$color="#CCCCFF";}
echo "<tr bgcolor='".$color."'>";
foreach ($line as $table) {
echo "<td><font color=black size=3>$table</font></td>";
}
echo "</tr>";
$x++; endwhile;
echo "</table>";
// ------ Libera consulta do banco de dados
pg_free_result($res);
?>
<!-- ---- Volta ao menu anterior -->
<a href="../livros">Voltar ao menu</a>
</font></BODY></HTML>

8.8. Anexo 8 – index1.php - Sistema de Listagem de um cadastro

de livros

Código do arquivo index1.php da aplicação “SISTEMA DE LISTAGEM DE UM

CADASTRO DE LIVROS”

<?php
$titulo = "Guia de consulta de livros";

// ------ acesso ao banco de dados ----------

require('conexao.php');

// ------ seleciona tabela de noticias -----------

$res = pg_query("select titulo,autor,paginas,preco from livros order by
titulo");
$num_linhas = pg_numrows($res);

for($i=0 ; $i<$num_linhas; $i++)

{
$array_livros[] = pg_result($res,$i,0);
$array_autores[] = pg_result($res,$i,1);
$array_paginas[] = pg_result($res,$i,2);
$array_preco[] = pg_result($res,$i,3);
}

// ------ fecha conexão de acesso ao banco de dados ----------

pg_close($con);
 51

// ---- define variáveis e exibe o template ----

require('c:/php5/libs/Smarty.class.php');
$smarty = new Smarty;
$smarty->assign("titulo", $titulo);
$smarty->assign("livros", $array_livros);
$smarty->assign("autores", $array_autores);
$smarty->assign("paginas", $array_paginas);
$smarty->assign("valor", $array_preco);
$smarty->display("index.tpl");
?>

8.9. Anexo 9 – index.tpl - Sistema de Listagem de um cadastro de

livros

Código do arquivo index.tpl da aplicação “SISTEMA DE LISTAGEM DE UM

CADASTRO DE LIVROS”

{config_load file="index.conf" section="Margens"}

<html>
<head>
<title>{$titulo}</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>

<body bgcolor="{#corFundo#}" topmargin="{#margemSuperior#}"

leftmargin="{#margemEsquerda#}">

<h2 align="center"><font face="{#fonteFace#}"

color="{#corTitulo#}">{$titulo}</h2>

<table>
<tr bgcolor="#D6D6D6">
<td><b>Livros</b></td>
<td><b>Autores</b></td>
<td><b>P&aacuteginas</b></td>
<td><b>Valor R$</b></td>
</tr>

{section name=i loop=$livros}

<tr bgcolor="{cycle values="#AAAAFF,#CCCCFF"}">
<td>{$livros[i]}</td>
<td>{$autores[i]}</td>
<td>{$paginas[i]}</td>
<td>{$valor[i]}</td>
</tr>
{/section}
</table>
<a href="../livros">Voltar ao menu</a>
</font>
</body>
</html>
 52

8.10. Anexo 10 – index.conf - Sistema de Listagem de um cadastro

de livros

Código do arquivo index.conf da aplicação “SISTEMA DE LISTAGEM DE UM

CADASTRO DE LIVROS”

#variáveis globais
corFundo = #0000FF
corTitulo = #ffffff
fonteFace = arial
[Margens]
margemSuperior = 10
margemEsquerda = 10

8.11. Anexo 11 – conexao.php - Sistema de Listagem de um

cadastro de livros

Código do arquivo conexao.php da aplicação “SISTEMA DE LISTAGEM DE UM

CADASTRO DE LIVROS”

<?php
$servidor = "localhost";
$base = "livros";
$porta = "5432";
$usuario = "postgres";
$senha = "postgres";

$conect = "host=$servidor port=$porta dbname=$base user=$usuario

password=$senha";
$con = pg_connect($conect);

if(!$con)
die("Erro na Conexão!!");
?>

8.12. Anexo 12 – index.php – Gerador de formulários de contato

Código do arquivo index.php da aplicação “GERADORA DE FORMULÁRIOS DE

CONTATO”

<?php
require('c:/php5/libs/Smarty.class.php');
$smarty = new Smarty;
$smarty->assign('siglas', array('SP','RJ','SC','RS','MG'));
$smarty->assign('estados', array('São Paulo','Rio de Janeiro','Santa
Catarina','Rio Grande do Sul','Minas Gerais'));
$smarty->assign('inicial', 'MG');
$smarty->display('form_contato_menu.tpl');
?>
 53

8.13. Anexo 13 – index.tpl - Gerador de formulários de contato

Código do arquivo index.tpl da aplicação “GERADORA DE FORMULÁRIOS DE

CONTATO”

<!-- busca configurações no arquivo index.conf -->

{config_load file="index.conf" section="estilo"}

<!-- tag abaixo que envia o e-mail para o servidor onde localiza-se o
script que envia o email-->
<form action="/sys/formmail.php" method="POST">

<!-- variaveis abaixo : "para" "assunto" "retorno" essas são padrões -->
<input type='hidden' name='para' value='smarcilio@itelefonica.com.br'><!--
Aqui você deve colocar o e-mail de quem irá receber o e-mail-->
<input type='hidden' name='assunto' value='#-( Mensagem do Site )-#'> <!--
aqui é só o titulo do e-mail, quando chegar na sua caixa de mensagem terá
esse nome -->
<input type='hidden' name='retorno'
value='http://www.dms.eti.br/adm/sys/emailenviado.html'><!-- aqui é o
Feedback ou menssagem de retorno, conclusão etc.. coloque a url completa
!!! -->
<!-- variaveis acima: "para" "assunto" "retorno" essas são padroes -->

<div align="center">
<center>
<table border="1" width="549" height="47"
bordercolorlight="{#bdrcolorl#}" bordercolordark="{#bdrcolord#}"
cellspacing="0" cellpadding="0" style="background-color: #FFFFFF; border-
style: dotted; border-color: #66CCFF">
<tr>
<td width="549" height="47" bgcolor="{#bgcolor_topo#}"
bordercolorlight="{#bdrcolorl#}" bordercolordark="{#bdrcolord#}">
<p align="center"><font face="{#fonte#}" size="4"><b>Formulário de
Contato&nbsp;&nbsp;&nbsp;</b></font>
</td>
</tr>
<tr>
<td width="549" height="31" bgcolor="{#bgcolor_corpo#}"><b><font
size="2" face="{#fonte#}" color="#000080">&nbsp;Nome:&nbsp;
<input type="text" name="nome" size="39"></font></b><font
color="#FF0000" size="1" face="{#fonte#}">(*)</font><b><font size="2"
face="{#fonte#}"
color="#000080">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</font></b></td>
</tr>
<tr>
<td width="549" height="41" bgcolor="{#bgcolor_corpo#}"><b><font
size="2" face="{#fonte#}" color="#000080">&nbsp;E-mail:
<input type="text" name="email" size="39"> </font></b><font
color="#FF0000" size="1" face="{#fonte#}">(*)</font></td>
</tr>
<tr>
<td width="549" height="1" bgcolor="{#bgcolor_corpo#}"><b><font
size="2" face="{#fonte#}" color="#000080">&nbsp;Telefone:
<input type="text" name="telefone" size="20">&nbsp;</font></b><font
color="#FF0000" size="1" face="{#fonte#}">(*)</font></td>
</tr>
<tr>
<td width="549" height="1" bgcolor="{#bgcolor_corpo#}"><b><font
size="2" face="{#fonte#}" color="#000080">&nbsp;Estado:
 54

<select name="estado">
{html_options values=$siglas output=$estados
selected=$inicial}
</select>
</tr>
<tr>
<td width="549" height="1" valign="bottom"
bgcolor="{#bgcolor_corpo#}"><b><font size="2" face="{#fonte#}"><font
color="#800080">Mensagem:</font><textarea rows="3" name="mensagem"
cols="64"></textarea></font></b><font color="#FF0000" size="1"
face="{#fonte#}">(*)</font>
<p align="center"><font size="1" face="{#fonte#}"
color="#800000">Os
campos com</font><font color="#FF0000" size="1" face="{#fonte#}">
(*) </font><font color="#800000"><font size="1" face="{#fonte#}">são
</font><font size="1"
face="{#fonte#}">obrigatórios</font></font></td>
</tr>
</center>
<tr>
<td width="549" height="47" bgcolor="{#bgcolor_corpo#}">
<p align="center">&nbsp;&nbsp;&nbsp; <input type="submit"
value="Enviar" name="B1" style="background-color: #D2E9F9; border-style:
solid; border-color:
#99CCFF">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<input type="reset" value="Limpar" name="B1" style="background-color:
#FF4A4A; border-style: solid; border-color: #FF9999">
</td></tr></table></div></form>

8.14. Anexo 14 – index.conf - Gerador de formulários de contato

Código do arquivo index.conf da aplicação “GERADORA DE FORMULÁRIOS DE

CONTATO”

# variáveis globais

[estilo]
bgcolor_topo = #99CCFF
bgcolor_corpo = #F4FAFF
bdrcolorl = #F0F0FF
bdrcolord = #FFFFFF
fonte = arial