Help:Parser functions in templates/pt

= 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 dar-se 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áctico #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 sintáctico quando ele, de facto, 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.

Casos raros
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 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 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:


 *  </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 parâmetro que não seja aceite.

Ver também

 * Extensão:ParserFunctions
 * Predefinições