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 () ou não (), 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:


 *   &rarr; 

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


 *   &rarr; 

Não tendo sido passado o parâmetro </tt>, 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:


 *  </tt>

Por exemplo:


 *  </tt> &rarr; 

Como </tt> 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:</tt>, acima, da seguinte forma:
 *  </tt> &rarr; 

Como o parâmetro não foi passado, por omissão é considerado o valor vazio, explicitado em  </tt>. De igual forma para a função #expr:</tt>:


 *  </tt> &rarr; 

o parâmetro toma o valor 0</tt> 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.

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</tt>), examinar um parâmetro desta forma:

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


 *  </tt> &rarr; 
 *  </tt> &rarr; 
 *  </tt> &rarr; 

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


 *  </tt> &rarr; 

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

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


 * <tt> </tt> &rarr; 
 * <tt> </tt> &rarr; 
 * <tt> </tt> &rarr; 

Em particular:


 * <tt> </tt> &rarr; 

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 <tt>   :Segunda</tt> que aceita dois parâmetros <tt>normal</tt> e <tt>sensível</tt>. Por sua vez, esta chama uma predefinição <tt>   :Primeira</tt> que aceita os mesmos <tt>normal</tt> e <tt>sensível</tt>. Mas o seu comportamento é diferente quando <tt>sensível</tt> não é passado e quando é passado mas está vazio.

Se <tt>   :Segunda</tt> chamar <tt>    :Primeira</tt> assim:

...

...

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


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


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

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

Ver também

 * Extensão:ParserFunctions
 * Predefinições