:TITLE: Estruturas de repetição 102 - For e incr
;#
;# RCSID: $Header: /home/cvs/TclTutor3/lesson/Tcl_Portuguese/Tcl_Portuguese10.lsn,v 1.1 2008/08/02 12:37:36 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: 30/12/2005
;#*********************************************************
:LESSON_TEXT_START_LEVEL 0:
<B>Sintaxe: </B><CODE>for</CODE> <I>início teste próximo corpo</I>
<P>
A entrada da página do manual para o comando <CODE>for</CODE>:
<P>
For é um comando de repetição, similar em estrutura à declaração em C.
Os argumentos início, próximo, e corpo devem ser comandos de string Tcl,
e o teste é uma expressão de string.
<P>
O comando <CODE>for</CODE> primeiro chama o interpretador Tcl para iniciar a execução.
Então ele repetidamente avalia o teste como uma expressão; se o resultado
não for zero, o comando chama o interpretador Tcl no <I>corpo</I>, então
chama o interpretador Tcl em <I>próximo</I>, e então repete o laço.
O comando termina quando o <I>teste</I> for avaliado como 0.
<P>
Se um comando continue é chamado dentro do corpo então quaisquer comandos
restantes na execução atual do corpo são saltados; o processamento
continua através da chamada ao interpretador Tcl em próximo, então
com a avaliação do teste, e assim por diante.
<P>
Se um comando break for chamado dentro do corpo ou próximo, então o
comando for irá retornar imediatamente. A operação de break e continue
são similares às correspondentes declarações em C.
<P>
For retorna uma string vazia.
<P>
Assim como o comando <CODE>while</CODE>, o teste deveria ser colocado
dentro de chaves para evitar que a fase de substituição do interpretador 
substitua a variável de iteração com seu valor inicial antes de avaliar
o comando for.
<P>
Como a iteração de incremento de uma variável é muito comum, Tcl tem
um comando especial para isso:
<P>
<B>incr</B> <I>nomeVariavel ?incremento?</I>
<P>
Este comando adiciona o valor no segundo argumento para a variável
nomeada no primeiro argumento. Se nenhum valor for dado para o
segundo argumento, ele é padronizado para 1.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 1:
Tcl suporta uma estrutura de repetição similar ao <CODE>for</CODE>
em C, e o laço <CODE>do</CODE> em Fortran. O comando <CODE>for</CODE>
em Tcl toma quatro argumentos; uma inicialização, um teste, um incremento,
e o corpo do código para avaliar em cada passo do laço. A sintaxe para
o comando <CODE>for</CODE> é:
<P>
<CODE>for</CODE> <I>início teste próximo corpo</I>
<P>
Durante a avaliação do comando <CODE>for</CODE>, o código de <I>início</I>
é avaliado uma vez, antes que qualquer outro argumento seja avaliado. Depois
que o código de início foi avaliado, o <I>teste</I> é avaliado. Se o
<I>teste</I> é avaliado como verdadeiro, então o <I>corpo</I>
é avaliado, e finalmente, o <I>próximo</I> argumento é avaliado. Depois
de avaliar o argumento <I>próximo</I>, o interpretador retorna ao <I>teste</I>,
e repete o processo. Se o <I>teste</I> é avaliado como falso,
então o laço será encerrado imediatamente.
<P>
<I>Início</I> é a porção de inicialização do comando. É comumente usado
para inicializar a variável de iteração, mas pode conter qualquer
código que você quiser executar antes do laço iniciar.
<P>
O argumento <I>teste</I> é avaliado numericamente, da mesma forma que
com o comando <CODE>expr</CODE> e com o comando <CODE>while</CODE>.
O argumento <I>teste</I> pode conter qualquer expressão que você
passaria para <CODE>expr</CODE>.
<P>
<I>Próximo</I> é normalmente um comando de incremento, mas pode conter
qualquer comando que o interpretador Tcl possa avaliar.
<P>
<I>Corpo</I> é o corpo do código para executar.
<P>
Como você normalmente não quer que a fase de substituição do interpretador
Tcl mude as variáveis para seus valores atuais antes de passar o controle
para o comando <CODE>for</CODE>, é comum agrupar os argumentos com chaves.
Quando chaves são usadas para delimitação, o caracter de nova linha não é
tratado como o fim de um comando Tcl. Isso torna mais simples escrever
múltiplas linhas de comando. Todavia, a abertura de chaves deve estar na
linha do comando <CODE>for</CODE>, ou o interpretador Tcl irá tratar o
fechamento da chave em <I>próximo</I> como o fim de um comando, e
não haverá argumentos suficientes para o comando <CODE>for</CODE>.
<P>
Dentro do código do <I>corpo</I>, os comandos <CODE>break</CODE> e
<CODE>continue</CODE> podem ser usados assim como eles são usados
como o comando <CODE>while</CODE>. Quando um <CODE>break</CODE> é 
encontrado, o laço termina imediatamente. Quando um <CODE>continue</CODE> 
é encontrado, a avaliação do <I>corpo</I> cessa, e o <I>teste</I> é
reavaliado.
<P>
Como a iteração de incremento de uma variável é muito comum, Tcl
tem um comando especial para isso:
<P>
<B>incr</B> <I>nomeVariavel ?incremento?</I>
<P>
Este comando adiciona o valor no segundo argumento para a variável
nomeada no primeiro argumento. Se nenhum valor for dado para o
segundo argumento, ele é padronizado para 1.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 2:
O comando <CODE>while</CODE> é muito poderoso, e pode ser usado em qualquer
lugar que você precise realizar uma repetição. Todavia, há muitos casos
em que você quer um método simples de contrução de um laço.
<P>
Tcl suporta uma estrutura de repetição chamada <CODE>for</CODE>.
O comando <CODE>for</CODE> toma quatro argumentos; uma inicialização,
um teste, um incremento, e o corpo do código para avaliar em cada passo
da repetição. São as mesmas quatro partes de código que você usou com
o comando <CODE>while</CODE>, mas elas podem ser expressas mais
compactamente com o comando <CODE>for</CODE>.
<P>
A sintaxe para o comando <CODE>for</CODE> é:
<P>
<CODE>for</CODE> <I>início teste próximo corpo</I>
<P>
A avaliação do comando <CODE>for</CODE> é feita da seguinte maneira:
<OL>
<LI> O código <I>início</I> é avaliado uma vez, antes que quaisquer outros argumentos
     sejam avaliados.
<LI> O <I>teste</I> é avaliado.
<UL>
<LI> Se o <I>teste</I> é avaliado como verdadeiro, 
     então o <I>corpo</I> é avaliado.
<LI> Se o <I>teste</I> não for verdadeiro, então o
     laço termina imediatamente.
</UL>
<LI> O argumento <I>próximo</I> é avaliado.
<LI> Retorna para o passo 2, e o processo se repete.
</OL>
<P>
<I>Início</I> é a porção de inicialização do comando. É comumente
usada para inicializar a variável de iteração, mas pode conter
qualquer código que você quiser executar antes que o laço comece.
<P>
O argumento <I>teste</I> é avaliado numericamente, da mesma forma
que o comando <CODE>expr</CODE> e o comando <CODE>while</CODE>. 
O argumento <I>teste</I> pode conter qualquer expressão que você
passaria para o comando <CODE>expr</CODE>.
<P>
<I>Próximo</I> é normalmente um comando de incremento, mas pode
conter qualquer comando que o interpretador Tcl pode avaliar.
<P>
<I>Corpo</I> é o corpo do código para executar.
<P>
Como você provavelmente não quer que a fase de substituição do
interpretador Tcl mude as variáveis para seus valores atuais antes
de passar o controle para o comando, é comum agrupar os argumentos
com chaves. Quando chaves são usadas para delimitação, o caracter de
nova linha não é tratado como o fim de um comando Tcl. Isso torna
mais simples escrever múltiplas linhas de comando. Todavia, a
abertura de chave deve estar na mesma linha do comando
<CODE>for</CODE>, ou o interpretador Tcl irá tratar o
fechamento da chave de <I>próximo</I> como o fim do comando,
e não haverá argumentos suficientes para o comando <CODE>for</CODE>.
<P>
Dentro do código do <I>corpo</I>, os comandos <CODE>break</CODE> e
<CODE>continue</CODE> podem ser usados da mesma forma que foram
usados com o comando <CODE>while</CODE>. Quando um <CODE>break</CODE> 
é encontrado, o laço termina imediatamente. Quando um <CODE>continue</CODE> 
é encontrado, a avaliação do <I>corpo</I> cessa, e o <I>teste</I> é
reavaliado.
<P>
Como a iteração de incremento de variável é muito comum, Tcl tem
um comando especial para isso:
<P>
<B>incr</B> <I>nomeVariavel ?incremento?</I>
<P>
Este comando adiciona o valor no segundo argumento para a variável
nomeada no primeiro argumento. Se nenhum valor for dado para o
segundo argumento, ele é padronizado para 1. O segundo argumento
(<I>incremento</I>) pode ser um valor negativo se você quer
decrementar, ao invés de incrementar.
:TEXT_END:
:CODE_START:
for {puts "Início"; set i 0} {$i < 2} {incr i; puts "i depois de incrementar: $i"; } {
  puts "i dentro do primeiro laço: $i"
  }

;# Como o teste é avaliado antes do corpo,
;# este laço não irá executar o corpo do código.

for {puts "Início"; set i 3} {$i < 2} {incr i; puts "i depois de incrementar: $i"; } {
  puts "i dentro do segundo laço: $i"
  }

;# Um laço while equivalente ao primeiro laço for:

puts "Início"; set i 0;
while {$i < 2} {
  puts "i dentro do primeiro laço: $i"
  incr i; 
  puts "i depois do incremento: $i"; 
  }
:TEXT_END: