:TITLE: Avaliação e Substituições 3: Agrupando argumento com []
;#
;# RCSID: $Header: /home/cvs/TclTutor3/lesson/Tcl_Portuguese/Tcl_Portuguese5.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: 27/12/2005
;#*********************************************************
:LESSON_TEXT_START_LEVEL 0:
Durante a fase de substituição, uma string delimitada por colchetes([])
será avaliada como um comando, e será substituída pelo valor retornado
do comando, ao menos que os colchetes sejam precedidos por uma barra invertida.
<P>
Isso é um equivalente funcional das aspas simples na programação 
em script shell, ou chamar uma função em C, mas é atualmente parte
da fase de substituição em Tcl. 
:TEXT_END: 
:LESSON_TEXT_START_LEVEL 1:
Você ganha acesso aos resultados de um comando colocando o comando
dentro de colchetes([]). Isso é um equivalente funcional das
aspas simples na programação em script shell, ou à chamada de uma função
em C, mas é atualmente parte da fase de substituição em Tcl.
<P>
Como o interpretador Tcl lê em uma linha ele substitui todas as $variaveis com seus valores.
Se uma porção da string é agrupada com colchetes, então a string dentro dos colchetes
é passada para a porção de avaliação do interpretador, um passo de substituição é feito,
e o resultado do comando substitui a string delimitada pelas colchetes.
<P>
As exceções a essa regra são as seguintes:
<UL>
<LI> Um colchete que é precedido com uma \ é considerado como um colchete, literalmente.
<LI> Um colchetes dentro de chaves não é modificado durante a fase de substituição.
</UL>
<P>
Execute os exemplos, e examine a saída para ver como os colchetes, aspas duplas e
chaves foram usados.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 2:
A maioria das tarefas de programação do computador
envolve a manipulação de dados com comandos, e armazenamento
de dados a serem acessados mais tarde por outros comandos.
Em Tcl você ganha acesso aos resultados de um comando
colocando o comando de string dentro de colchetes([]).
<P>
Nas lições anteriores, nós aprendemos que como Tcl lê
em uma linha, ele substitui todas as $variaveis com
seus valores. Quando o interpretador Tcl encontra uma
string dentro de colchetes, a string delimitada é passada
para a porção de avaliação do interpretador. A porção de
avaliação faz um único passo de subsituição, e então executa
o comando, exatamente como se a string delimitada aparecesse
na linha, sem os colchetes. Todavia, o resultado do comando
então substitui a string delimitada, e o interpretador
continua com o passo da substituição na linha, 
da forma como essa linha agora aparece com o 
resultado do comando substituído.
<P>
O mecanismo para isso é que quando o interpretador encontra
uma string dentro de colchetes, essa string é passada para a
porção de avaliação do interpretador. A porção de avaliação do
interpretador faz um único passo de substituição, e então executa o
comando, exatamente da mesma forma como se a string aparecesse na linha
sem os colchetes. Todavia, quando o comando é executado, o resultado
do comando substitui a string delimitada, e o interpretador continua
com o passo de substituição na primeira string.
<P>
Preste atenção na terceira linha no exemplo:
<PRE><CODE>
set y [set x "def"]
</CODE></PRE>
Lembre-se que um comando <B>set</B> retorna o valor atual da
variável que está sendo atribuída. Neste comando a string dentro
dos colchetes atribui o valor <B>"def"</B> à variável <B>x</B>.
Durante a fase de substituição, esta string é extraída do comando
e é executada. O resultado da atribuição é agora colocado no comando
de string, substituindo a string delimitada, e o comando agora é
remontado:
<PRE><CODE>
set y "def"
</CODE></PRE>
Então o comando é executado, e "def" é atribuído a y.
<P>
As exceções para essa regra são as seguintes:
<UL>
<LI> Um colchete que é precedido com uma \ é considerado como um colchete, literalmente.
<LI> Um colchete dentro de chaves não é modificado durante a fase de substituição.
</UL>
<P>
Execute os exemplos, e examine a saída para ver como os colchetes, aspas duplas e
chaves são usados.
:TEXT_END:
:CODE_START:
set x "abc"
puts "Uma substituição simples: $x\n"

set y [set x "def"]
puts "Lembre-se que \"set\" retorna o novo valor da variável: X: $x Y: $y\n"

set z {[set x "Esta é uma string delimitada por aspas duplas dentro de colchetes"]}
puts "Note os colchetes: $z\n"

set a "[set x {Esta é uma string delimitada por colchetes dentro de aspas duplas}]"
puts "Veja como set é executado: $a"
puts "\$x is: $x\n"

set b "\[set y {Esta é uma string delimitada por colchetes dentro de aspas duplas}\]"
puts "Note a \\ antes do colchete:\n\$b is: $b"
puts "\$y is: $y"

:TEXT_END: