Help:Parser functions in templates/pt-br

Parâmetros de funções nas predefinições

Quando uma predefinição espera um parâmetro, quer este seja anônimo ({{{1}}}) ou não ({{{nome}}}), pode ocorrer um de três casos:

1. não é passado qualquer parâmetro
2. é passado o parâmetro esperado, mas está vazio
3. é passado o parâmetro esperado e tem um valor

No primeiro caso, quando o parâmetro esperado não é passado de todo, o comportamento das funções muitas vezes não é o esperado. Por exemplo, para a função do analisador sintático #if:

{{#if: {{{1}}} | verdadeiro | falso }} → verdadeiro

#if: parece considerar que o parâmetro {{{1}}} tem um valor, quando não lhe foi passado qualquer parâmetro! Outro fenômeno de origem semelhante ocorre na função #expr::

{{#expr: {{{número}}} - 10}} →

Não tendo sido passado o parâmetro {{{número}}}, resulta um erro de sintxe quando ele, de fato, não existe.

É possível contornar este problema, definindo um valor por omissão para o parâmetro.

Valor por omissão

Ao analisar o valor de um parâmetro dentro de uma predefinição, é possível definir que este tome um determinado valor por omissão, caso o parâmetro não tenha sido passado. Para definir o valor por omissão, use a seguinte sintaxe:

{{{ 1 | valor por omissão }}}

Por exemplo:

{{{ 1 | a }}} → a

Como {{{1}}} não foi passado, o parâmetro toma o valor por omissão.

Com esta funcionalidade disponível, pode-se contornar o problema da função #if:, acima, da seguinte forma:

{{#if: {{{ 1 | }}} | verdadeiro | falso }} → falso

Como o parâmetro não foi passado, por omissão é considerado o valor vazio, explicitado em {{{ 1 | }}}. De igual forma para a função #expr::

{{#expr: {{{número | 0}}} - 10}} → -10

o parâmetro toma o valor 0 por omissão e o cálculo ocorre sem problema.

Esta forma de analisar o parâmetro, especificando um valor por omissão é, muito frequentemente, a desejada e correcta. Quando se assume que o parâmetro é passado, mas não o é, o comportamento resultante é frequentemente imprevisível.

Normalmente, ao analisar o valor de um parâmetro nas predefinições, deve especificar-se um valor por omissão, mesmo que este seja o valor vazio ou zero. Só não é necessário fazê-lo quando se pretende explicitamente distinguir se o parâmetro não foi passado, o que é muito raro.

Casos raros

Nota:

Estes casos são muito raros e bastante complexos. Se não os puder acompanhar não se preocupe, pois dificilmente necessitará deste conhecimento.

Testar se o parâmetro não foi passado

São raros os casos em que se pretende distinguir se um parâmetro não foi passado. Se necessitar de fazê-lo, pode usar um dos seguintes.

Se, numa predefinição (aqui chamada exemplo), examinar um parâmetro desta forma:

{{#switch: {{{ 1 | ¬ }}}
 | ¬       = valor por omissão
 |         = vazio
 |#default = {{{1}}}
}}

em que o valor por omissão seja algo que não deva ser passado no parâmetro (neste caso «¬»), consegue facilmente identificar se o parâmetro foi passado:

{{exemplo}} → valor por omissão

{{exemplo | }} → vazio

{{exemplo | a }} → a

No entanto, corre o risco de ser passado no parâmetro o texto que escolheu para valor por omissão e o comportamento não será o desejado:

{{exemplo | ¬ }} → valor por omissão

É retornado valor por omissão quando pretende retornar o valor do parâmetro. Uma forma mais fiável de identificar expressamente se o parâmetro foi passado é a seguinte:

{{#ifeq: {{{ 1 | }}} | {{{ 1 | - }}} 
 | parâmetro passado (e pode estar vazio) 
 | parâmetro não foi passado 
}}

Dando ao parâmetro diferentes valores por omissão (vazio e «-») na comparação, #ifeq: será verdadeiro se {{{1}}} tiver sido passado, mesmo que vazio. Se for falso, sabe de certeza que não foi passado o parâmetro:

{{exemplo}} → parâmetro não foi passado

{{exemplo | }} → parâmetro passado (e pode estar vazio)

{{exemplo | a }} → parâmetro passado (e pode estar vazio)

Em particular:

{{exemplo | - }} → parâmetro passado (e pode estar vazio)

Distinguir não passado, de passado mas vazio

Em casos raros, uma predefinição pode comportar-se de formas diferentes quando não é passado um parâmetro e quando este é passado mas está vazio. Se uma tal predefinição for usada dentro de uma segunda predefinição que use os mesmos parâmetros e com o mesmo nome, surge um problema.

O problema é como garantir que, se um parâmetro não é passado a esta segunda definição, ela não passa esse parâmetro à primeira mas, se for passado à segunda ele é passado à primeira.

Por exemplo, imagine uma predefinição Template:Segunda que aceita dois parâmetros normal e sensível. Por sua vez, esta chama uma predefinição Template:Primeira que aceita os mesmos normal e sensível. Mas o seu comportamento é diferente quando sensível não é passado e quando é passado mas está vazio.

Se Template:Segunda chamar Template:Primeira assim:

...
{{primeira
 | normal = {{{ normal | }}}
 | sensível{{#ifeq: {{{ sensível | }}} | {{{ sensível | - }}}
            |
            | x
           }} = {{{ sensível | }}}
}}
...

o problema é resolvido. Note, primeiro, que tanto normal como sensível podem não ser passados a Template:Segunda, ou podem ser passados mas vazios. Analise o que acontece aos dois parâmetros:

• Quer normal não tenha sido passado a Template:Segunda, ou tenha sido passado mas vazio, Template:Segunda chama Template:Primeira passando um valor vazio no parâmetro normal. É perdida a informação sobre se este foi originalmente passado a Template:Segunda, ou não.

• Em contraste, se sensível não for originalmente passado a Template:Segunda, isto causa que seja adicionado um x ao seu nome (resultando sensívelx), quando o parâmetro é passado por Template:Segunda a Template:Primeira. Portanto, se sensível não foi originalmente passado, continua a não ser passado a Template:Primeira (estritamente falando, ele é passado no parâmetro sensívelx, que não é usado). É assim preservada a informação de que o parâmetro não foi originalmente passado a Template:Segunda, que é o efeito pretendido.

Claro que para isto funcionar é preciso garantir que o sufixo adicionado (neste caso x) transforma o nome do parâmetro num nome de parâmetro que não seja esperado por Template:Primeira.

Ver também

• Extensão:ParserFunctions
• Predefinições