:TITLE: Comparação Textual - switch
;#
;# RCSID: $Header: /home/clif/CVS_ROOT/TclTutor/Tcl7.lsn,v 1.12 2000/04/24 16:17:53 clif Exp $
;# Copyright (c) 1995 Clif Flynt
;# 9300 Fleming Rd.
;# Dexter, MI  48130
;# clif@cflynt.com
;# Veja o arquivo "AVISO" com os termos da licença.
;#
;#*********************************************************
;# Portuguese translation: Lucio Agostinho Rocha
;# E-mail: outrosdiasvirao@yahoo.com.br
;# Last update: 28/12/2005
;#*********************************************************
:LESSON_TEXT_START_LEVEL 0:
<B>switch</B> <I>string modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN?</I>
   <P>- ou -<P>
<B>switch</B> <I>string { modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN? }</I>
<P>
O comando switch compara o argumento <I>string</I> com cada um dos 
argumentos <I>modelo</I> na ordem. Quando um <I>modelo</I> for igual
à <I>string</I> o argumento <I>corpo</I> é avaliado pelo interpretador Tcl
e o resultado daquela avaliação é retornado como o retorno do comando <B>switch</B>.
<P>
O comando switch interrompe a comparação entre a <I>string</I> e os argumentos
de <I>modelo</I> tão logo encontre um modelo que seja igual à string. O comando switch
irá encontrar apenas um <I>modelo</I> para a<I>string</I>.
<P>
Se o último argumento de modelo para o comando switch for a string <B>default</B>
então o comando switch irá ser compatível com qualquer string que não foi 
previamente encontrada. Se nenhum argumento for igual à string e
nenhum <B>default</B> for dado, então o comando switch retorna uma string vazia.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 1:
O comando switch permite a você escolher uma das muitas opções em
seu código baseado no conteúdo de uma string. A string será comparada
a um conjunto de modelos, e quando um modelo for compatível com a string, 
o código associado com aquele modelo será avaliado.
<P>
  A sintaxe do comando é:
<P>
<B>switch</B> <I>string modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN?</I>
   <P>- ou -<P>
<B>switch</B> <I>string { modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN? }</I>
<P>
<I>String</I> é a string que você quer testar, e <I>modelo1,
modelo2, etc</I> são os modelos com os quais a string será comparada.
Se <I>string</I> for igual a um modelo, então o código associado
com aquele modelo será executado. O retorno do <I>corpo</I> será retornado
como o retorno da declaração switch, e o comando switch será completado.
Apenas um modelo será encontrado.
<P>
Se o último argumento <I>modelo</I> for a string <B>default</B>, 
aquele modelo irá ser compatível com qualquer string. Isso garante que
algum conjunto de código será executado, sem importar qual seja o conteúdo
de <I>string</I>.
<P>
Se não há argumento <B>default</B>, e nenhum dos <I>modelos</I> 
for igual à<I>string</I>, então o comando <B>switch</B> 
irá retornar uma string vazia.
<P>
Se você usa a versão com chaves para esse comando, não serão feitas
substituições nos modelos. O corpo do comando, todavia,
será tratado e avaliado da mesma forma que qualquer outro comando, e então
haverá um passo de substituições feito nele, da mesma forma como será
feito na primeira sintaxe. A vantagem da segunda forma é que você pode
escrever múltiplas linhas de comando mais legíveis com as chaves.
<P>
Note que você pode usar chaves para agrupar o argumento <I>corpo</I> 
quando estiver utilizando os comando <B>switch</B> ou <B>if</B>. Isso é
porque esse comandos passam seu argumento <I>corpo</I> para o interpretador
Tcl para avaliação. Essa avaliação inclui um passo de substituições
da mesma forma que é feito para o código que não está dentro do argumento <I>corpo</I>.
<P>
Se você não executou o exemplo ainda, faça isso agora, então tente mudar a
string atribuída para x de <CODE>UM</CODE> para <CODE>DOIS</CODE> e
execute o exemplo novamente.
:TEXT_END:
<P>
:LESSON_TEXT_START_LEVEL 2:
Quando você está escrevendo um programa você algumas vezes quer escolher
um conjunto de código para executar ao invés de outro. Um dos comandos que
você pode usar para selecionar qual conjunto de código deverá ser executado é
o comando <B>switch</B>.
<P>
O comando switch permite que você escolha uma das muitas opções em seu
código, baseado em uma string. A string será comparada a um conjunto de
modelos, e quando uma string for compatível com um modelo, o código associado
com aquele modelo será avaliado.
<P>
A sintaxe do comando switch é:
<P>
<B>switch</B> <I>string modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN?</I>
   <P>- ou -<P>
<B>switch</B> <I>string { modelo1 corpo1 ?modelo2 corpo2?...?modeloN corpoN? }</I>
<P>
<I>String</I> é a string que você quer comparar com vários modelos e
<I>modelo1</I> é o primeiro modelo com o qual a string será comparada. Se
<I>string</I> for igual ao <I>modelo1</I>, então o código dentro do
<I>corpo1</I> será executado, e o valor retornado pelo <I>corpo1</I>
será o retorno do comando switch.
<P>
Se <I>modelo1</I> não for igual à <I>string</I>, então
<I>modelo2</I> será checado, e assim por diante até, ou um modelo ser igual
à string, ou não haver mais modelos. Quando um modelo for igual à <I>string</I>,
então o comando switch está completo, e a próxima linha é executada.
Apenas um modelo no comando switch será encontrado.
<P>
Se o último argumento <I>modelo</I> for a string <B>default</B>, 
aquele modelo irá ser compatível com qualquer string. Isso garante que
algum conjunto de código será executado, não importando o conteúdo da <I>string</I>.
<P>
Se não há argumento <B>default</B>, e nenhum dos <I>modelos</I> for
igual à <I>string</I>, então o comando <B>switch</B> irá retornar
uma string vazia.
<P>
O comando switch vem em dois "sabores". Cada modelo e corpo pode
ser passado para o comando como um argumento separado (a primeira forma),
ou eles podem todos ser agrupados dentro de chaves como um único argumento.
Se eles estão agrupados em uma única unidade, o comando switch irá
separá-los em modelos e corpos, mas não realizará quaisquer substituições
de variáveis nos modelos.
<P>
Quando um <I>modelo</I> for igual a uma string o argumento <I>corpo</I>
será avaliado pelo interpretador Tcl como qualquer outra linha de código.
Se o corpo for agrupado com chaves, as chaves serão retiradas antes que
a avaliação ocorra, permitindo as substituições.
<P>
Se você não executou o exemplo ainda, faça isso agora, então tente mudar
a string atribuída a x de <CODE>UM</CODE> para <CODE>DOIS</CODE>
e execute o exemplo novamente.
:TEXT_END:
:CODE_START:
;# Atribui as variáveis que nós iremos comparar
set x UM;
set y 1;
set z UM;

;# Isso é legal
switch $x "UM" "puts UM=1" "DOIS" "puts DOIS=2" "default" "puts NÃO_ENCONTRADO"

;# Isso é mais legível, os modelos estão à esquerda, e o corpo 
;# associado com cada modelo está à sua direita.
switch $x \
  "UM" 	        "puts UM=1"  \
  "DOIS" 	"puts DOIS=2" \
  "default" 	"puts NÃO_ENCONTRADO";

;# Esses dois exemplos mostram a diferença entre utilizar as versões
;# sem chaves e com chaves do comando switch.
;# Você pode ver também como um comando switch pode se tornar
;# muito complexo para ser escreito em uma única linha.

;# Esta forma permite substituições nos argumentos modelo.

switch $x \
  "$z"		{set y1 [expr $y+1]; puts "ENCONTRADO \$z. $y + $z é $y1" } \
  "UM"		{set y1 [expr $y+1]; puts "ENCONTRADO UM. $y + um é $y1"} \
  "DOIS"	{set y1 [expr $y+2]; puts "ENCONTRADO DOIS. $y + dois é $y1" } \
  "TRÊS"	{set y1 [expr $y+3]; puts "ENCONTRADO TRÊS. $y + três é $y1" } \
  "default"	{puts "$x não é igual a nenhuma dessas escolhas";}

;# Esta forma do comando desativa a substituição de variáveis no modelo

switch $x {
  "$z"		{set y1 [expr $y+1]; puts "ENCONTRADO \$z. $y + $z é $y1" }
  "UM"		{set y1 [expr $y+1]; puts "ENCONTRADO UM. $y + um é $y1"}
  "DOIS"	{set y1 [expr $y+2]; puts "ENCONTRADO DOIS. $y + dois é $y1"}
  "TRÊS"	{set y1 [expr $y+3]; puts "ENCONTRADO TRÊS. $y + três é $y1"}
  "default"	{puts "$x NÃO FOI ENCONTRADO"}
  }
:TEXT_END: