Linguagem de template YATL¶
py4web usa Python para os seus templates, controladores e pontos de vista, embora ele usa uma sintaxe Python ligeiramente modificada nas vistas para permitir que o código mais legível, sem impor quaisquer restrições sobre o uso adequado Python.
usos py4web `` [[…]] `` para escapar código Python embutido em HTML. A vantagem de usar colchetes em vez de colchetes é que é transparente para todos os editores comum HTML. Isso permite que o desenvolvedor usar esses editores para criar visualizações py4web.
Desde o desenvolvedor está incorporação de código Python em HTML, o documento deve ser recuado de acordo com as regras HTML, e não regras Python. Portanto, permitimos que sem recuo Python dentro das `` [[…]] `` tags. Desde Python normalmente usa recuo para delimitar blocos de código, precisamos de uma maneira diferente para delimitá-los; é por isso que as marcas de linguagem template py4web usar da palavra-chave Python `` pass``.
Um bloco de código é iniciado com uma linha que termina com dois pontos e as extremidades com uma linha que se inicia com `` pass``. A palavra-chave `` pass`` não é necessário quando o fim do bloco é óbvio a partir do contexto.
Aqui está um exemplo:
[[
if i == 0:
response.write('i is 0')
else:
response.write('i is not 0')
pass
]]
Note que `` pass`` é uma palavra-chave Python, não uma palavra-chave py4web. Alguns editores Python, como Emacs, use a palavra-chave `` pass`` para significar a divisão de blocos e usá-lo para o código re-indent automaticamente.
O linguagem de template py4web faz exatamente a mesma. Quando encontra algo como:
<html><body>
[[for x in range(10):]][[=x]]hello<br />[[pass]]
</body></html>
que traduz em um programa:
response.write("""<html><body>""", escape=False)
for x in range(10):
response.write(x)
response.write("""hello<br />""", escape=False)
response.write("""</body></html>""", escape=False)
`` Response.write`` escreve para o `` response.body``.
Quando há um erro em uma visão py4web, o relatório de erro mostra o código gerado vista, e não o ponto de vista real como escrito pelo desenvolvedor. Isso ajuda o desenvolvedor de depuração do código, destacando o código real que é executado (que é algo que pode ser depurado com um editor de HTML ou o inspetor DOM do navegador).
Observe também que:
[[=x]]
gera
response.write(x)
Variáveis injetadas no HTML desta forma são escapou por padrão. O escape é ignorado se `` x`` é um objeto `` XML``, mesmo que escape é definida como `` True``.
Aqui está um exemplo que introduz o `` H1`` helper:
[[=H1(i)]]
que é traduzido para:
response.write(H1(i))
mediante avaliação, o objeto `` H1`` e seus componentes são recursivamente serializados, escapou e escrita para o corpo da resposta. As tags gerados pelo `` H1`` e HTML interior não escapamos. Este mecanismo garante que todo o texto - e somente texto - exibido na página web é sempre escaparam, evitando assim vulnerabilidades XSS. Ao mesmo tempo, o código é simples e fácil de depurar.
O método `` response.write (obj, escapar = True) `` recebe dois argumentos, o objeto a ser escrito e se ele tem que ser escapado (definido como `` True`` por padrão). Se `` obj`` tem um `` .xml () `` método, ele é chamado e o resultado escrito para o corpo da resposta (o argumento `` escape`` é ignorado). Caso contrário, ele usa `` __str__`` o método do objeto para serializar-lo e, se o argumento fuga é `` True``, lhe escapa. Todos os built-in helper objetos ( `` H1`` no exemplo) são objetos que sabem como serializar-se através do `` .xml () `` método.
Isso tudo é feito de forma transparente. Você nunca precisa (e não deve) chamar o método response.write` explicitamente.
Sintaxe básica¶
O linguagem de template py4web suporta todas as estruturas de controle Python. Aqui nós fornecemos alguns exemplos de cada um deles. Eles podem ser aninhados de acordo com a prática de programação habitual.
`` Para … in``¶
Em templates você pode fazer um loop sobre qualquer objeto iterável:
[[items = ['a', 'b', 'c']]]
<ul>
[[for item in items:]]<li>[[=item]]</li>[[pass]]
</ul>
que produz:
<ul>
<li>a</li>
<li>b</li>
<li>c</li>
</ul>
Aqui `` items`` é qualquer objeto iterável como uma lista Python, Python tupla, ou linhas objeto, ou qualquer objeto que é implementado como um iterador. Os elementos apresentados são primeiro serializado e escapou.
`` While``¶
Você pode criar um loop usando a palavra-chave, enquanto:
[[k = 3]]
<ul>
[[while k > 0:]]<li>[[=k]][[k = k - 1]]</li>[[pass]]
</ul>
que produz:
<ul>
<li>3</li>
<li>2</li>
<li>1</li>
</ul>
`` If … elif … else``¶
Você pode usar cláusulas condicionais:
[[
import random
k = random.randint(0, 100)
]]
<h2>
[[=k]]
[[if k % 2:]]is odd[[else:]]is even[[pass]]
</h2>
que produz:
<h2>
45 is odd
</h2>
Uma vez que é óbvio que `` else`` encerra a primeira `` if`` bloco, não há necessidade de um `` declaração pass``, e usando um seria incorreto. No entanto, você deve fechar explicitamente a opção `` bloco else`` com um `` pass``.
Lembre-se que, em Python “else if” está escrito `` elif`` como no exemplo a seguir:
[[
import random
k = random.randint(0, 100)
]]
<h2>
[[=k]]
[[if k % 4 == 0:]]is divisible by 4
[[elif k % 2 == 0:]]is even
[[else:]]is odd
[[pass]]
</h2>
Produz:
<h2>
64 is divisible by 4
</h2>
`` Tentar … exceto … else … finally``¶
Também é possível usar `` tentar … declarações except`` nas vistas com uma ressalva. Considere o seguinte exemplo:
[[try:]]
Hello [[= 1 / 0]]
[[except:]]
division by zero
[[else:]]
no division by zero
[[finally:]]
<br />
[[pass]]
Ela irá produzir o seguinte resultado:
Hello division by zero
<br />
Este exemplo ilustra que todas as saídas gerado antes de ocorrer uma exceção é processado (incluindo a saída que precedeu a excepção) no interior do bloco de teste. “Olá” é escrito porque precede a exceção.
`` Def … return``¶
O linguagem de template py4web permite ao desenvolvedor definir e implementar funções que podem retornar qualquer objeto Python ou uma cadeia de texto / html. Aqui, consideramos dois exemplos:
[[def itemize1(link): return LI(A(link, _href="http://" + link))]]
<ul>
[[=itemize1('www.google.com')]]
</ul>
produz o seguinte resultado:
<ul>
<li><a href="http://www.google.com">www.google.com</a></li>
</ul>
A função `` itemize1`` devolve um objecto auxiliar que é inserido no local em que a função é chamada.
Considere agora o seguinte código:
[[def itemize2(link):]]
<li><a href="http://[[=link]]">[[=link]]</a></li>
[[return]]
<ul>
[[itemize2('www.google.com')]]
</ul>
Ela produz exactamente o mesmo resultado como acima. Neste caso, a função `` itemize2`` representa um pedaço de HTML que vai substituir a tag py4web onde a função é chamada. Observe que não existe ‘=’ na frente da chamada para `` itemize2``, já que a função não retornar o texto, mas escreve-lo diretamente para a resposta.
Há uma ressalva: funções definidas dentro de uma visão deve terminar com uma declaração `` return``, ou o recuo automático falhará.