Tcl-Tk - Guia Rápido

Tcl é a forma abreviada de Tool Command Language. John Ousterhout, da University of California, Berkeley, o projetou. É uma combinação de uma linguagem de script e seu próprio interpretador que fica embutido no aplicativo, que desenvolvemos com ele.

Tcl foi desenvolvido inicialmente para Unix. Em seguida, foi portado para Windows, DOS, OS / 2 e Mac OSX. Tcl é muito semelhante a outras linguagens de shell Unix como Bourne Shell (Sh), C Shell (csh), Korn Shell (sh) e Perl.

Tem como objetivo fornecer capacidade para os programas interagirem com outros programas e também agir como um intérprete incorporável. Mesmo assim, o objetivo original era permitir que os programas interajam, você pode encontrar aplicativos completos escritos em Tcl / Tk.

Características do Tcl

As características do Tcl são as seguintes -

Tempo de desenvolvimento reduzido.
Kit de interface de usuário poderoso e simples com integração de TK.
Escreva uma vez, corra em qualquer lugar. Ele roda em Windows, Mac OS X e quase todas as plataformas Unix.
Muito fácil de começar para programadores experientes; já que a linguagem é tão simples que eles podem aprender Tcl em algumas horas ou dias.
Você pode facilmente estender os aplicativos existentes com o Tcl. Além disso, é possível incluir Tcl em C, C ++ ou Java para Tcl ou vice-versa.
Tenha um poderoso conjunto de funções de rede.
Por fim, é um código aberto, gratuito e pode ser usado para aplicativos comerciais sem qualquer limite.

Formulários

Tcl é uma linguagem de propósito geral e você pode encontrar Tcl em qualquer lugar. Inclui,

Sites escaláveis que geralmente são apoiados por bancos de dados.
Servidores web de alto desempenho construídos com TclHttpd.
Tcl com sites baseados em CGI.
Aplicativos de desktop GUI.
Aplicativos integrados.

Configuração de ambiente local

Se você deseja configurar seu ambiente para Tcl, você precisa dos dois aplicativos de software a seguir disponíveis em seu computador -

Editor de texto
Tcl Interpreter.

Editor de texto

Isso será usado para digitar seu programa. Exemplos de alguns editores de texto incluem o Windows Notepad, o comando OS Edit, Brief, Epsilon, EMACS e vim ou vi.

O nome e a versão de um editor de texto podem variar em diferentes sistemas operacionais. Por exemplo, o Bloco de notas será usado no Windows e o vim ou vi pode ser usado no Windows, bem como no Linux ou UNIX.

Os arquivos que você cria com seu editor de texto são chamados de arquivos-fonte e contêm o código-fonte do programa. Os arquivos de origem dos programas Tcl são nomeados com a extensão".tcl".

Antes de iniciar sua programação, certifique-se de ter um editor de texto instalado e de ter experiência suficiente para escrever um programa de computador, salvá-lo em um arquivo, compilá-lo e finalmente executá-lo.

O intérprete Tcl

É apenas um pequeno programa que permite digitar comandos Tcl e executá-los linha por linha. Ele interrompe a execução de um arquivo tcl, caso encontre um erro, ao contrário de um compilador que executa totalmente.

Vamos ter um arquivo helloWorld.tcl da seguinte maneira. Vamos usar isso como um primeiro programa, rodamos em uma plataforma de sua escolha.

#!/usr/bin/tclsh

puts "Hello World!"

Instalação em Windows

Baixe a versão mais recente do instalador do Windows na lista de binários Tcl ativos disponíveis. A edição da comunidade Tcl ativa é gratuita para uso pessoal.

Execute o executável baixado para instalar o Tcl, o que pode ser feito seguindo as instruções na tela.

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, alternando para a pasta que contém o arquivo usando o comando 'cd' e, em seguida, executar o programa usando as seguintes etapas

C:\Tcl> tclsh helloWorld.tcl

Podemos ver a seguinte saída.

C:\Tcl> helloWorld

C: \ Tcl é a pasta que estou usando para salvar minhas amostras. Você pode alterá-lo para a pasta na qual salvou os programas Tcl.

Instalação em Linux

A maioria dos sistemas operacionais Linux vem com o Tcl embutido e você pode começar imediatamente com esses sistemas. Caso não esteja disponível, você pode usar o seguinte comando para baixar e instalar o Tcl-Tk.

$ yum install tcl tk

$ tclsh helloWorld.tcl

Podemos ver a seguinte saída -

$ hello world

Instalação em sistemas baseados em Debian

Caso não esteja disponível em seu sistema operacional, você pode usar o seguinte comando para baixar e instalar o Tcl-Tk -

$ sudo apt-get install tcl tk

$ tclsh helloWorld.tcl

Podemos ver a seguinte saída -

$ hello world

Instalação em Mac OS X

Baixe a versão mais recente do pacote Mac OS X da lista de binários Active Tcl disponíveis. A edição da comunidade Tcl ativa é gratuita para uso pessoal.

Execute o executável baixado para instalar o Active Tcl, o que pode ser feito seguindo as instruções na tela.

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, mudando para a pasta que contém o arquivo usando 'cd' e, em seguida, executar o programa usando as seguintes etapas -

$ tclsh helloWorld.tcl

Podemos ver a seguinte saída -

$ hello world

Instalação de arquivos de origem

Você pode usar a opção de instalar a partir de arquivos de origem quando um pacote binário não estiver disponível. Geralmente é preferível usar binários Tcl para Windows e Mac OS X, portanto, apenas a compilação de fontes em sistemas baseados em unix é mostrada abaixo.

Baixe os arquivos de origem.
Agora, use os seguintes comandos para extrair, compilar e construir depois de alternar para a pasta baixada.

$ tar zxf tcl8.6.1-src.tar.gz $ cd tcl8.6.1
$ cd unix $ ./configure —prefix=/opt —enable-gcc
$ make $ sudo make install

Note - Certifique-se de alterar o nome do arquivo para a versão que você baixou nos comandos 1 e 2 fornecidos acima.

Em Tcl, classificamos algumas das variáveis como variáveis especiais e elas têm um uso / funcionalidade predefinido. A lista de variáveis especiais está listada abaixo.

Sr. Não.	Variável Especial e Descrição
1	argc Refere-se a vários argumentos de linha de comando.
2	argv Refere-se à lista que contém os argumentos da linha de comando.
3	argv0 Refere-se ao nome do arquivo que está sendo interpretado ou o nome pelo qual chamamos o script.
4	env Usado para representar a matriz de elementos que são variáveis ambientais.
5	errorCode Fornece o código de erro para o último erro Tcl.
6	errorInfo Fornece o rastreamento de pilha para o último erro Tcl.
7	tcl_interactive Usado para alternar entre os modos interativo e não interativo, definindo como 1 e 0, respectivamente.
8	tcl_library Usado para definir a localização de bibliotecas Tcl padrão.
9	tcl_pkgPath Fornece a lista de diretórios onde os pacotes são geralmente instalados.
10	tcl_patchLevel Refere-se ao nível de patch atual do interpretador Tcl.
11	tcl_platform Usado para representar a matriz de elementos com objetos, incluindo byteOrder, machine, osVersion, platform e os.
12	tcl_precision Refere-se à precisão, ou seja, ao número de dígitos a serem retidos ao converter para números de ponto flutuante em strings. O valor padrão é 12.
13	tcl_prompt1 Refere-se ao prompt principal.
14	tcl_prompt2 Refere-se ao prompt secundário com comandos inválidos.
15	tcl_rcFileName Fornece o arquivo de inicialização específico do usuário.
16	tcl_traceCompile Usado para controlar o rastreamento de compilação de bytecode. Use 0 para nenhuma saída, 1 para resumo e 2 para detalhes.
17	tcl_traceExec Usado para controlar o rastreamento de execução de bytecode. Use 0 para nenhuma saída, 1 para resumo e 2 para detalhes.
18	tcl_version Retorna a versão atual do interpretador Tcl.

As variáveis especiais acima têm seus significados especiais para o interpretador Tcl.

Exemplos de uso de variáveis especiais Tcl

Vamos ver alguns exemplos de variáveis especiais.

Versão Tcl

#!/usr/bin/tclsh

puts $tcl_version

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

8.6

Caminho do ambiente Tcl

#!/usr/bin/tclsh

puts $env(PATH)

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

/home/cg/root/GNUstep/Tools:/usr/GNUstep/Local/Tools:/usr/GNUstep/
System/Tools:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/webmaster/.local/bin:/
home/webmaster/bin:/usr/local/scriba/bin:/usr/local/smlnj/
bin:/usr/local/bin/std:/usr/local/bin/extra:/usr/local/fantom/bin:/usr/
local/dart/bin:/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/opt/mono/
bin:/opt/mono/lib/mono/4.5:/usr/local/bin:.:/usr/libexec/sdcc:/usr/local/
icon-v950/bin:/usr/local/mozart/bin:/opt/Pawn/bin:/opt/jdk1.7.0_75/bin:/
opt/jdk1.7.0_75/jre/bin:/opt/pash/Source/PashConsole/bin/Debug/

Caminho do pacote Tcl

#!/usr/bin/tclsh

puts $tcl_pkgPath

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

/usr/lib64/tcl8.6 /usr/share/tcl8.6 /usr/lib64/tk8.6 /usr/share/tk8.6

Biblioteca Tcl

#!/usr/bin/tclsh

puts $tcl_library

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

/usr/share/tcl8.6

Tcl Patch Level

#!/usr/bin/tclsh

puts $tcl_patchLevel

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

8.6.6

Precisão Tcl

#!/usr/bin/tclsh

puts $tcl_precision

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

Arquivo de inicialização Tcl

#!/usr/bin/tclsh

puts $tcl_rcFileName

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo -

~/.tclshrc

Tcl é bastante simples de aprender e vamos começar a criar nosso primeiro programa Tcl!

Primeiro Programa Tcl

Vamos escrever um programa Tcl simples. Todos os arquivos Tcl terão uma extensão, ou seja, .tcl. Portanto, coloque o seguinte código-fonte em um arquivo test.tcl.

#!/usr/bin/tclsh

puts "Hello, World!"

Assumindo que o ambiente Tcl está configurado corretamente; vamos executar o programa depois de mudar para o diretório do arquivo e, em seguida, executar o programa usando -

$ tclsh test.tcl

Obteremos a seguinte saída -

Hello, World!

Vamos agora ver a estrutura básica do programa Tcl, de forma que seja fácil para você entender os blocos de construção básicos da linguagem Tcl. No Tcl, usamos nova linha ou ponto-e-vírgula para encerrar a linha de código anterior. Mas o ponto-e-vírgula não é necessário, se você estiver usando nova linha para cada comando.

Comentários

Os comentários são como texto de ajuda em seu programa Tcl e o interpretador os ignora. Os comentários podem ser escritos usando um sinal de hash _ (#) no início.

#!/usr/bin/tclsh

# my first program in Tcl
puts "Hello World!"

Quando o código acima é executado, ele produz o seguinte resultado -

Hello World!

O comentário de várias linhas ou bloco é escrito usando 'if' com a condição '0'. Um exemplo é mostrado abaixo.

#!/usr/bin/tclsh

if 0 {
   my first program in Tcl program
   Its very simple
}
puts "Hello World!"

Quando o código acima é executado, ele produz o seguinte resultado -

Hello World!

Comentários inline usam; #. Um exemplo é dado abaixo.

#!/usr/bin/tclsh

puts "Hello World!" ;# my first print in Tcl program

Quando o código acima é executado, ele produz o seguinte resultado -

Hello World!

Identificadores

Um identificador Tcl é um nome usado para identificar uma variável, função ou qualquer outro item definido pelo usuário. Um identificador começa com uma letra de A a Z ou a a z ou um sublinhado (_) seguido por zero ou mais letras, sublinhados, dólares ($) e dígitos (0 a 9).

Tcl não permite caracteres de pontuação como @ e% nos identificadores. Tcl é umcase sensitive_ língua. Assim, Manpower e manpower são dois identificadores diferentes em Tcl. Aqui estão alguns dos exemplos de identificadores aceitáveis -

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

Palavras reservadas

A lista a seguir mostra algumas das palavras reservadas em Tcl. Essas palavras reservadas não podem ser usadas como constantes ou variáveis ou quaisquer outros nomes de identificador.

depois de	acrescentar	matriz	auto_execok
auto_import	auto_load	auto_load_index	auto_qualify
binário	Bgerror	pausa	pegar
CD	Relógio	Fechar	concat
continuar	Dde	padrão	outro
elseif	Codificação	eof	erro
avaliação	Exec	Saída	expr
fblocked	Fconfigure	fcopy	Arquivo
evento de arquivo	Rubor	para	para cada
formato	Obtém	glob	global
história	E se	informação	interp
Junte-se	Lappend	lindex	linsert
Lista	Llength	carga	Irange
substituir	Lsearch	lsort	namespace
abrir	Pacote	pid	pkg_mkIndex
proc	Puts	pwd	ler
regexp	Regsub	renomear	recurso
Retorna	Varredura	procurar	conjunto
tomada	Fonte	Dividido	corda
subst	Interruptor	tclLog	contar
Tempo	Vestígio	desconhecido	não definido
atualizar	Nível acima	Upvar	variável
vwait	Enquanto

Espaço em branco em Tcl

Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é conhecida como um blank line, e um intérprete Tcl totalmente ignora isso.

Espaço em branco é o termo usado em Tcl para descrever espaços em branco, tabulações, caracteres de nova linha e comentários. O espaço em branco separa uma parte de uma instrução de outra e permite ao intérprete identificar onde um elemento em uma instrução, como puts, termina e o próximo elemento começa. Portanto, na seguinte declaração -

#!/usr/bin/tclsh

puts "Hello World!"

Deve haver pelo menos um caractere de espaço em branco (geralmente um espaço) entre "puts" e "Hello World!" para o intérprete poder distingui-los. Por outro lado, na seguinte declaração -

#!/usr/bin/tclsh

puts [expr 3 + 2] ;# print sum of the 3 and 2

Quando o código acima é executado, ele produz o seguinte resultado -

Nenhum caractere de espaço em branco é necessário entre 3 e +, ou entre + e 2; embora você seja livre para incluir alguns, se desejar, para fins de legibilidade.

Como você sabe, Tcl é uma linguagem de comando de ferramenta, os comandos são a parte mais vital da linguagem. Os comandos Tcl são integrados à linguagem, cada um tendo sua própria função predefinida. Esses comandos formam as palavras reservadas do idioma e não podem ser usados para outra nomenclatura de variável. A vantagem desses comandos Tcl é que você pode definir sua própria implementação para qualquer um desses comandos para substituir a funcionalidade interna original.

Cada um dos comandos Tcl valida a entrada e reduz o trabalho do interpretador.

O comando Tcl é na verdade uma lista de palavras, com a primeira palavra representando o comando a ser executado. As próximas palavras representam os argumentos. Para agrupar as palavras em um único argumento, colocamos várias palavras entre "" ou {}.

A sintaxe do comando Tcl é a seguinte -

commandName argument1 argument2 ... argumentN

Vamos ver um exemplo simples de comando Tcl -

#!/usr/bin/tclsh

puts "Hello, world!"

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, world!

No código acima, 'puts' é o comando Tcl e "Hello World" é o argument1. Como dito antes, usamos "" para agrupar duas palavras.

Vamos ver outro exemplo de comando Tcl com dois argumentos -

#!/usr/bin/tclsh

puts stdout "Hello, world!"

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, world!

No código acima, 'puts' é o comando Tcl, 'stdout' é argument1 e "Hello World" é argument2. Aqui, stdout faz com que o programa imprima no dispositivo de saída padrão.

Substituição de Comando

Em substituições de comando, colchetes são usados para avaliar os scripts dentro dos colchetes. Um exemplo simples para adicionar dois números é mostrado abaixo -

#!/usr/bin/tclsh

puts [expr 1 + 6 + 9]

Quando o código acima é executado, ele produz o seguinte resultado -

Substituição de Variável

Em substituições de variáveis, $ é usado antes do nome da variável e retorna o conteúdo da variável. Um exemplo simples para definir um valor para uma variável e imprimi-lo é mostrado abaixo.

#!/usr/bin/tclsh

set a 3
puts $a

Quando o código acima é executado, ele produz o seguinte resultado -

Substituição de barra invertida

Estes são comumente chamados escape sequences; com cada barra invertida, seguida por uma letra com seu próprio significado. Um exemplo simples de substituição de nova linha é mostrado abaixo -

#!/usr/bin/tclsh

puts "Hello\nWorld"

Quando o código acima é executado, ele produz o seguinte resultado -

Hello
World

O tipo de dados primitivo de Tcl é string e freqüentemente podemos encontrar aspas em Tcl como linguagem apenas de string. Esses tipos de dados primitivos, por sua vez, criam tipos de dados compostos para lista e array associativo. Em Tcl, os tipos de dados podem representar não apenas os objetos Tcl simples, mas também podem representar objetos complexos, como alças, objetos gráficos (principalmente widgets) e canais de E / S. Vejamos os detalhes sobre cada uma das opções acima.

Objetos Tcl Simples

Em Tcl, seja um número inteiro, booleano, número de ponto flutuante ou uma string. Quando você deseja usar uma variável, pode atribuir diretamente um valor a ela, não há etapa de declaração em Tcl. Pode haver representações internas para esses diferentes tipos de objetos. Ele pode transformar um tipo de dados em outro quando necessário. A sintaxe para atribuir valor à variável é a seguinte -

#!/usr/bin/tclsh

set myVariable 18
puts $myVariable

Quando o código acima é executado, ele produz o seguinte resultado -

A instrução acima criará um nome de variável myVariable e o armazenará como uma string, embora não tenhamos usado aspas duplas. Agora, se tentarmos fazer uma aritmética na variável, ela será automaticamente transformada em um inteiro. Um exemplo simples é mostrado abaixo -

#!/usr/bin/tclsh

set myVariable 18
puts [expr $myVariable + 6 + 9]

Quando o código acima é executado, ele produz o seguinte resultado -

Uma coisa importante a observar é que essas variáveis não têm nenhum valor padrão e devem receber valores atribuídos antes de serem usadas.

Se tentarmos imprimir usando puts, o número será transformado na string apropriada. Ter duas representações, interna e externa, ajuda o Tcl a criar estruturas de dados complexas facilmente em comparação com outras linguagens. Além disso, o Tcl é mais eficiente devido à sua natureza de objeto dinâmico.

Representações de String

Ao contrário de outras línguas, em Tcl, você não precisa incluir aspas duplas quando é apenas uma palavra. Um exemplo pode ser -

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

Quando o código acima é executado, ele produz o seguinte resultado -

hello

Quando queremos representar várias strings, podemos usar aspas duplas ou chaves. É mostrado abaixo -

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable set myVariable {hello world} puts $myVariable

Quando o código acima é executado, ele produz o seguinte resultado -

hello world
hello world

Lista

A lista nada mais é do que um grupo de elementos. Um grupo de palavras usando aspas duplas ou chaves pode ser usado para representar uma lista simples. Uma lista simples é mostrada abaixo -

#!/usr/bin/tclsh

set myVariable {red green blue}
puts [lindex $myVariable 2] set myVariable "red green blue" puts [lindex $myVariable 1]

Quando o código acima é executado, ele produz o seguinte resultado -

blue
green

Matriz Associativa

Matrizes associativas têm um índice (chave) que não é necessariamente um número inteiro. Geralmente é uma string que atua como pares de valores-chave. Um exemplo simples é mostrado abaixo -

#!/usr/bin/tclsh

set  marks(english) 80
puts $marks(english) set marks(mathematics) 90 puts $marks(mathematics)

Quando o código acima é executado, ele produz o seguinte resultado -

80
90

Alças

Os identificadores Tcl são comumente usados para representar arquivos e objetos gráficos. Isso pode incluir identificadores para solicitações de rede e também outros canais como comunicação de porta serial, soquetes ou dispositivos de E / S. A seguir está um exemplo em que um identificador de arquivo é criado.

set myfile [open "filename" r]

Você verá mais detalhes sobre os arquivos no capítulo de E / S do arquivo Tcl .

Em Tcl, não há conceito de declaração de variável. Assim que um novo nome de variável for encontrado, Tcl definirá uma nova variável.

Nomenclatura de Variável

O nome das variáveis pode conter qualquer caractere e comprimento. Você pode até ter espaços em branco colocando a variável entre colchetes, mas não é o preferido.

O comando set é usado para atribuir valor a uma variável. A sintaxe do comando set é,

set variableName value

Alguns exemplos de variáveis são mostrados abaixo -

#!/usr/bin/tclsh

set variableA 10
set {variable B} test
puts $variableA puts ${variable B}

Quando o código acima é executado, ele produz o seguinte resultado -

10
test

Como você pode ver no programa acima, o $ variableName é usado para obter o valor da variável.

Digitação Dinâmica

Tcl é uma linguagem tipada dinamicamente. O valor da variável pode ser convertido dinamicamente para o tipo necessário quando necessário. Por exemplo, um número 5 armazenado como string será convertido em número ao fazer uma operação aritmética. É mostrado abaixo -

#!/usr/bin/tclsh

set variableA "10"
puts $variableA
set sum [expr $variableA +20]; puts $sum

Quando o código acima é executado, ele produz o seguinte resultado -

10
30

Expressões Matemáticas

Como você pode ver no exemplo acima, expr é usado para representar expressões matemáticas. A precisão padrão do Tcl é de 12 dígitos. Para obter resultados de ponto flutuante, devemos adicionar pelo menos um único dígito decimal. Um exemplo simples explica o acima.

#!/usr/bin/tclsh

set variableA "10"
set result [expr $variableA / 9]; puts $result
set result [expr $variableA / 9.0]; puts $result
set variableA "10.0"
set result [expr $variableA / 9]; puts $result

Quando o código acima é executado, ele produz o seguinte resultado -

1
1.1111111111111112
1.1111111111111112

No exemplo acima, você pode ver três casos. No primeiro caso, o dividendo e o divisor são números inteiros e obtemos um número inteiro como resultado. No segundo caso, o divisor sozinho é um número decimal e, no terceiro caso, o dividendo é um número decimal. No segundo e no terceiro casos, obtemos um número decimal como resultado.

No código acima, você pode alterar a precisão usando a variável especial tcl_precision. É mostrado abaixo -

#!/usr/bin/tclsh

set variableA "10"
set tcl_precision 5
set result [expr $variableA / 9.0]; puts $result

Quando o código acima é executado, ele produz o seguinte resultado -

1.1111

Um operador é um símbolo que informa ao compilador para executar manipulações matemáticas ou lógicas específicas. A linguagem Tcl é rica em operadores integrados e fornece os seguintes tipos de operadores -

Operadores aritméticos
Operadores Relacionais
Operadores lógicos
Operadores bit a bit
Operador Ternário

Este capítulo explicará os operadores aritméticos, relacionais, lógicos, bit a bit e ternários, um por um.

Operadores aritméticos

A tabela a seguir mostra todos os operadores aritméticos suportados pela linguagem Tcl. Suponha que a variável 'A' contenha 10 e a variável 'B' contenha 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
+	Adiciona dois operandos	A + B dará 30
-	Subtrai o segundo operando do primeiro	A - B dará -10
*	Multiplica ambos os operandos	A * B dará 200
/	Divide numerador por de-numerador	B / A dará 2
%	Operador de Módulo e o restante após uma divisão inteira	B% A dará 0

Operadores Relacionais

A tabela a seguir mostra todos os operadores relacionais suportados pela linguagem Tcl. Assumir variávelA contém 10 e variável B contém 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
==	Verifica se os valores dos dois operandos são iguais ou não, se sim a condição torna-se verdadeira.	(A == B) não é verdade.
! =	Verifica se os valores de dois operandos são iguais ou não, se os valores não são iguais, a condição se torna verdadeira.	(A! = B) é verdade.
>	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim então a condição torna-se verdadeira.	(A> B) não é verdade.
<	Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(A <B) é verdade.
> =	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(A> = B) não é verdade.
<=	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito; em caso afirmativo, a condição torna-se verdadeira.	(A <= B) é verdadeiro.

Operadores lógicos

A tabela a seguir mostra todos os operadores lógicos suportados pela linguagem Tcl. Assumir variávelA detém 1 e variável B segura 0, então -

Mostrar exemplos

Operador	Descrição	Exemplo
&&	Operador lógico chamado AND. Se ambos os operandos forem diferentes de zero, a condição se torna verdadeira.	(A && B) é falso.
\|\|	Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(A \|\| B) é verdade.
!	Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador NOT lógico tornará falso.	! (A && B) é verdade.

Operadores bit a bit

O operador bit a bit funciona em bits e executa a operação bit a bit. As tabelas de verdade para &, | e ^ são as seguintes -

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Suponha que A = 60; e B = 13; agora em formato binário serão os seguintes -

A = 0011 1100

B = 0000 1101

----------------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

Os operadores bit a bit suportados pela linguagem Tcl estão listados na tabela a seguir. Assumir variávelA detém 60 e variável B detém 13, então -

Mostrar exemplos

Operador	Descrição	Exemplo
E	O operador Binário AND copia um bit para o resultado se ele existir em ambos os operandos.	(A e B) dará 12, que é 0000 1100
\|	O operador binário OR copia um bit se ele existir em qualquer operando.	(A \| B) dará 61, que é 0011 1101
^	O operador binário XOR copia o bit se estiver definido em um operando, mas não em ambos.	(A ^ B) dará 49, que é 0011 0001
<<	Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita.	Um << 2 dará 240, que é 1111 0000
>>	Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita.	Um >> 2 dará 15, que é 0000 1111

Operador Ternário

Mostrar exemplos

Operador	Descrição	Exemplo
? :	Ternário	Se a condição for verdadeira? Então valor X: Caso contrário, valor Y

Precedência de operadores em Tcl

A precedência do operador determina o agrupamento de termos em uma expressão. Isso afeta como uma expressão é avaliada. Certos operadores têm precedência mais alta do que outros; por exemplo, o operador de multiplicação tem precedência mais alta do que o operador de adição.

For example: x = 7 + 3 * 2; aqui, x é atribuído a 13, não 20, porque o operador * tem precedência mais alta do que +, portanto, primeiro é multiplicado por 3 * 2 e, em seguida, soma 7.

Aqui, os operadores com a precedência mais alta aparecem na parte superior da tabela, aqueles com a mais baixa aparecem na parte inferior. Em uma expressão, os operadores de precedência superior serão avaliados primeiro.

Mostrar exemplos

Categoria	Operador	Associatividade
Unário	+ -	Direita para esquerda
Multiplicativo	* /%	Da esquerda para direita
Aditivo	+ -	Da esquerda para direita
Mudança	<< >>	Da esquerda para direita
Relacional	<<=>> =	Da esquerda para direita
E bit a bit	E	Da esquerda para direita
XOR bit a bit	^	Da esquerda para direita
OR bit a bit	\|	Da esquerda para direita
E lógico	&&	Da esquerda para direita
OR lógico	\|\|	Da esquerda para direita
Ternário	?:	Direita para esquerda

As estruturas de tomada de decisão requerem que o programador especifique uma ou mais condições a serem avaliadas ou testadas pelo programa, juntamente com uma instrução ou instruções a serem executadas se a condição for determinada como verdadeira e, opcionalmente, outras instruções a serem executadas se a condição está determinado a ser falso.

A seguir está a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

A linguagem Tcl usa o comando expr internamente e, portanto, não é necessário usarmos a instrução expr explicitamente.

A linguagem Tcl fornece os seguintes tipos de declarações de tomada de decisão -

Sr. Não.	Declaração e descrição
1	declaração if Uma declaração 'if' consiste em uma expressão booleana seguida por uma ou mais declarações.
2	declaração if ... else Uma instrução 'if' pode ser seguida por uma instrução opcional 'else', que é executada quando a expressão booleana é falsa.
3	declarações if aninhadas Você pode usar uma instrução 'if' ou 'else if' dentro de outra instrução 'if' ou 'else if'.
4	declaração switch UMA switch instrução permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores.
5	instruções switch aninhadas Você pode usar um switch declaração dentro de outra switch afirmações).

O ? : Operador

Nós cobrimos conditional operator ? : no capítulo anterior, que pode ser usado para substituir if...elseafirmações. Tem a seguinte forma geral -

Exp1 ? Exp2 : Exp3;

Onde Exp1, Exp2 e Exp3 são expressões. Observe o uso e a localização do cólon.

O valor de um '? expressão 'é determinada assim: Exp1 é avaliada. Se for verdadeiro, então Exp2 é avaliado e se torna o valor de '? expressão.' Se Exp1 for falso, então Exp3 é avaliado e seu valor se torna o valor da expressão. Um exemplo é mostrado abaixo.

#!/usr/bin/tclsh

set a 10;
set b [expr $a == 1 ? 20: 30] puts "Value of b is $b\n"
set b [expr $a == 10 ? 20: 30] puts "Value of b is $b\n"

Quando você compila e executa o programa acima, ele produz o seguinte resultado -

Value of b is 30
Value of b is 20

Pode haver uma situação em que você precise executar um bloco de código várias vezes. Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes e a seguir está a forma geral de uma instrução de loop na maioria das linguagens de programação -

A linguagem Tcl fornece os seguintes tipos de loops para lidar com os requisitos de loop.

Sr. Não.	Tipo de Loop e Descrição
1	loop while Repete uma declaração ou grupo de declarações enquanto uma determinada condição for verdadeira. Ele testa a condição antes de executar o corpo do loop.
2	para loop Executa uma sequência de instruções várias vezes e abrevia o código que gerencia a variável de loop.
3	loops aninhados Você pode usar um ou mais loops dentro de qualquer outro loop while, for ou do..while.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos.

Tcl oferece suporte às seguintes instruções de controle.

Sr. Não.	Declaração de controle e descrição
1	declaração de quebra Encerra o loop ou a instrução switch e transfere a execução para a instrução imediatamente após o loop ou switch.
2	continuar declaração Faz com que o loop pule o restante de seu corpo e teste novamente sua condição imediatamente antes de reiterar.

The Infinite Loop

Um loop se torna um loop infinito se uma condição nunca se torna falsa. owhileloop é tradicionalmente usado para esse propósito. Você pode fazer um loop infinito deixando a expressão condicional como 1.

while {1} {
   puts "This loop will run forever."
}

Quando a expressão condicional está ausente, ela é considerada verdadeira. Os programadores Tcl mais comumente usam a construção while {1} para significar um loop infinito.

NOTE - Você pode encerrar um loop infinito pressionando as teclas Ctrl + C.

Uma matriz é um arranjo sistemático de um grupo de elementos usando índices. A sintaxe da matriz convencional é mostrada a seguir.

set ArrayName(Index) value

Um exemplo de criação de array simples é mostrado abaixo.

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts $languages(0) puts $languages(1)

Quando o código acima é executado, ele produz o seguinte resultado -

Tcl
C Language

Tamanho da Matriz

A sintaxe para calcular a matriz de tamanho é mostrada abaixo.

[array size variablename]

Um exemplo de impressão do tamanho é mostrado abaixo.

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts  [array size languages]

Quando o código acima é executado, ele produz o seguinte resultado -

Iteração de array

Porém, os índices da matriz podem ser não contínuos como os valores especificados para o índice 1, índice 10 e assim por diante. Mas, no caso de serem contínuos, podemos usar a iteração do array para acessar os elementos do array. Uma iteração de array simples para imprimir elementos do array é mostrada abaixo.

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
for { set index 0 }  { $index < [array size languages] } { incr index } { puts "languages($index) : $languages($index)"
}

Quando o código acima é executado, ele produz o seguinte resultado -

languages(0) : Tcl
languages(1) : C Language

Matrizes Associativas

Em Tcl, todas as matrizes por natureza são associativas. Os arrays são armazenados e recuperados sem qualquer ordem específica. As matrizes associativas têm um índice que não é necessariamente um número e podem ser preenchidas de forma esparsa. Um exemplo simples de matriz associativa com índices não numéricos é mostrado abaixo.

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts  $personA(Name) puts $personA(Age)

Quando o código acima é executado, ele produz o seguinte resultado -

Dave
14

Índices de Matriz

A sintaxe para recuperar índices de array é mostrada abaixo.

[array names variablename]

Um exemplo de impressão do tamanho é mostrado abaixo.

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts [array names personA]

Quando o código acima é executado, ele produz o seguinte resultado -

Age Name

Iteração de Matriz Associativa

Você pode usar os índices do array para iterar por meio do array associativo. Um exemplo é mostrado abaixo.

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
foreach index [array names personA] {
   puts "personA($index): $personA($index)"
}

Quando o código acima é executado, ele produz o seguinte resultado -

personA(Age): 14
personA(Name): Dave

O tipo de dados primitivo de Tcl é string e freqüentemente podemos encontrar aspas em Tcl como linguagem apenas de string. Essas strings podem conter caracteres alfanuméricos, apenas números, booleanos ou até dados binários. Tcl usa caracteres Unicode de 16 bits e os caracteres alfanuméricos podem conter letras, incluindo caracteres não latinos, número ou pontuação.

O valor booleano pode ser representado como 1, sim ou verdadeiro para verdadeiro e 0, não ou falso para falso.

Representações de String

Ao contrário de outras línguas, em Tcl, você não precisa incluir aspas duplas quando é apenas uma palavra. Um exemplo pode ser -

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

Quando o código acima é executado, ele produz o seguinte resultado -

hello

Quando queremos representar várias strings, podemos usar aspas duplas ou chaves. É mostrado abaixo -

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable set myVariable {hello world} puts $myVariable

Quando o código acima é executado, ele produz o seguinte resultado -

hello world
hello world

Sequência de escape da corda

Um literal de caractere pode ser um caractere simples (por exemplo, 'x'), uma seqüência de escape (por exemplo, '\ t') ou um caractere universal (por exemplo, '\ u02C0').

Existem certos caracteres em Tcl quando eles são precedidos por uma barra invertida, eles têm um significado especial e são usados para representar como nova linha (\ n) ou tabulação (\ t). Aqui, você tem uma lista de alguns desses códigos de sequência de escape -

Sequência de fuga	Significado
\\	\ personagem
\ '	' personagem
\ "	" personagem
\?	? personagem
\uma	Alerta ou sino
\ b	Backspace
\ f	Feed de formulário
\ n	Nova linha
\ r	Retorno de carruagem
\ t	Aba horizontal
\ v	Aba vertical

A seguir está o exemplo para mostrar alguns caracteres da sequência de escape -

#!/usr/bin/tclsh

puts "Hello\tWorld\n\nTutorialspoint";

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Hello   World

Tutorialspoint

String Command

A lista de subcomandos para o comando string está listada na seguinte tabela -

Sr. Não.	Métodos e Descrição
1	compare string1 string2 Compara string1 e string2 lexograficamente. Retorna 0 se igual, -1 se string1 vem antes de string2, caso contrário, 1.
2	first string1 string2 Retorna a primeira ocorrência do índice de string1 em string2. Se não for encontrado, retorna -1.
3	index índice de corda Retorna o caractere no índice.
4	last string1 string2 Retorna a última ocorrência do índice de string1 em string2. Se não for encontrado, retorna -1.
5	length corda Retorna o comprimento da string.
6	match pattern corda Retorna 1 se a string corresponder ao padrão.
7	range string index1 index2 Retorna o intervalo de caracteres na string de índice1 a índice2.
8	tolower corda Retorna a string em minúsculas.
9	toupper corda Retorna a string maiúscula.
10	trim string? trimcharacters? Remove trimcharacter em ambas as extremidades da string. O trimcharacter padrão é o espaço em branco.
11	trimleft string? trimcharacters? Remove trimcharacter no início esquerdo da string. O trimcharacter padrão é o espaço em branco.
12	trimright string? trimcharacters? Remove trimcharacter na extremidade esquerda da string. O trimcharacter padrão é o espaço em branco.
13	wordend índice findstring Retorna o índice em findstring do caractere após a palavra que contém o caractere no índice.
14	wordstart índice findstring Retorna o índice em findstring do primeiro caractere na palavra que contém o caractere no índice.

Exemplos de alguns subcomandos de string Tcl comumente usados são fornecidos abaixo.

Comparação de cordas

#!/usr/bin/tclsh

set s1 "Hello"
set s2 "World"
set s3 "World"
puts [string compare $s1 $s2]
if {[string compare $s2 $s3] == 0} {
   puts "String \'s1\' and \'s2\' are same.";
}

if {[string compare $s1 $s2] == -1} {
   puts "String \'s1\' comes before \'s2\'.";
}

if {[string compare $s2 $s1] == 1} {
   puts "String \'s2\' comes after \'s1\'.";
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

-1
String 's1' and 's2' are same.
String 's1' comes before 's2'.
String 's2' comes after 's1'.

Índice de String

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "o"
puts "First occurrence of $s2 in s1" puts [string first $s2 $s1] puts "Character at index 0 in s1" puts [string index $s1 0]
puts "Last occurrence of $s2 in s1" puts [string last $s2 $s1] puts "Word end index in s1" puts [string wordend $s1 20]
puts "Word start index in s1"
puts [string wordstart $s1 20]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

First occurrence of o in s1
4
Character at index 0 in s1
H
Last occurrence of o in s1
7
Word end index in s1
11
Word start index in s1
6

Comprimento da corda

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Length of string s1"
puts [string length $s1]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Length of string s1
11

Manuseio de casos

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Uppercase string of s1"
puts [string toupper $s1] puts "Lowercase string of s1" puts [string tolower $s1]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Uppercase string of s1
HELLO WORLD
Lowercase string of s1
hello world

Cortando caracteres

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "World"
puts "Trim right $s2 in $s1"
puts [string trimright $s1 $s2]

set s2 "Hello"
puts "Trim left $s2 in $s1"
puts [string trimleft $s1 $s2]

set s1 " Hello World "
set s2 " "
puts "Trim characters s1 on both sides of s2"
puts [string trim $s1 $s2]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Trim right World in Hello World
Hello 
Trim left Hello in Hello World
 World
Trim characters s1 on both sides of s2
Hello World

Matching Strings

#!/usr/bin/tclsh

set s1 "[email protected]" 
set s2 "*@*.com"
puts "Matching pattern s2 in s1"
puts [string match "*@*.com" $s1 ] puts "Matching pattern tcl in s1" puts [string match {tcl} $s1]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Matching pattern s2 in s1
1
Matching pattern tcl in s1
0

Append Command

#!/usr/bin/tclsh

set s1 "Hello" 
append s1 " World"
puts $s1

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Hello World

Comando de formatação

A tabela a seguir mostra a lista de especificadores de formato disponíveis em Tcl -

Especificador	Usar
% s	Representação de string
% d	Representação inteira
% f	Representação de ponto flutuante
% e	Representação de ponto flutuante com forma expoente de mantissa
% x	Representação decimal hexa

Alguns exemplos simples são fornecidos abaixo -

#!/usr/bin/tclsh

puts [format "%f" 43.5]
puts [format "%e" 43.5]
puts [format "%d %s" 4 tuts]
puts [format "%s" "Tcl Language"]
puts [format "%x" 40]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

43.500000
4.350000e+01
4 tuts
Tcl Language
28

Comando de digitalização

O comando Scan é usado para analisar uma string com base no especificador de formato. Alguns exemplos são mostrados abaixo.

#!/usr/bin/tclsh

puts [scan "90" {%[0-9]} m]
puts [scan "abc" {%[a-z]} m]
puts [scan "abc" {%[A-Z]} m]
puts [scan "ABC" {%[A-Z]} m]

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Lista é um dos tipos de dados básicos disponíveis em Tcl. É usado para representar uma coleção ordenada de itens. Ele pode incluir diferentes tipos de itens na mesma lista. Além disso, uma lista pode conter outra lista.

Uma coisa importante a ser observada é que essas listas são representadas como strings completamente e processadas para formar itens individuais quando necessário. Portanto, evite listas grandes e em tais casos; use array.

Criação de uma lista

A sintaxe geral da lista é fornecida abaixo -

set listName { item1 item2 item3 .. itemn }
# or
set listName [list item1 item2 item3]
# or 
set listName [split "items separated by a character" split_character]

Alguns exemplos são fornecidos abaixo -

#!/usr/bin/tclsh

set colorList1 {red green blue}
set colorList2 [list red green blue]
set colorList3 [split "red_green_blue" _]
puts $colorList1
puts $colorList2 puts $colorList3

Quando o código acima é executado, ele produz o seguinte resultado -

red green blue
red green blue
red green blue

Anexando Item a uma Lista

A sintaxe para anexar item a uma lista é fornecida abaixo -

append listName split_character value
# or
lappend listName value

Alguns exemplos são fornecidos abaixo -

#!/usr/bin/tclsh

set var orange
append var " " "blue"
lappend var "red" 
lappend var "green" 
puts $var

Quando o código acima é executado, ele produz o seguinte resultado -

orange blue red green

Comprimento da lista

A sintaxe para comprimento da lista é fornecida abaixo -

llength listName

O exemplo do comprimento da lista é fornecido abaixo -

#!/usr/bin/tclsh

set var {orange blue red green}
puts [llength $var]

Quando o código acima é executado, ele produz o seguinte resultado -

Item da lista no índice

A sintaxe para selecionar o item da lista em um índice específico é fornecida abaixo -

lindex listname index

O exemplo de item da lista no índice é fornecido abaixo -

#!/usr/bin/tclsh

set var {orange blue red green}
puts [lindex $var  1]

Quando o código acima é executado, ele produz o seguinte resultado -

blue

Inserir item no índice

A sintaxe para inserir itens de lista em um índice específico é fornecida a seguir.

linsert listname index value1 value2..valuen

Um exemplo para inserir um item de lista em um índice específico é fornecido abaixo.

#!/usr/bin/tclsh

set var {orange blue red green}
set var [linsert  $var 3 black white]
puts $var

Quando o código acima é executado, ele produz o seguinte resultado -

orange blue red black white green

Substituir itens nos índices

A sintaxe para substituir itens de lista em índices específicos é fornecida abaixo -

lreplace listname firstindex lastindex value1 value2..valuen

Um exemplo de substituição de itens de lista em índices específicos é fornecido abaixo.

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lreplace $var 2 3 black white]
puts $var

Quando o código acima é executado, ele produz o seguinte resultado -

orange blue black white

Definir item no índice

A sintaxe para definir o item da lista em um índice específico é fornecida abaixo -

lset listname index value

Um exemplo para definir o item da lista em um índice específico é fornecido abaixo -

#!/usr/bin/tclsh

set var {orange blue red green}
lset var 0 black 
puts $var

Quando o código acima é executado, ele produz o seguinte resultado -

black blue red green

Transformar lista em variáveis

A sintaxe para copiar valores para variáveis é fornecida abaixo -

lassign listname variable1 variable2.. variablen

Exemplo para transformar a lista em variáveis é fornecido abaixo -

#!/usr/bin/tclsh

set var {orange blue red green}
lassign $var colour1 colour2 puts $colour1
puts $colour2

Quando o código acima é executado, ele produz o seguinte resultado -

orange
blue

Classificando uma lista

A sintaxe para classificar uma lista é fornecida abaixo -

lsort listname

Um exemplo de classificação de uma lista é fornecido abaixo -

#!/usr/bin/tclsh

set var {orange blue red green}
set var [lsort $var]
puts $var

Quando o código acima é executado, ele produz o seguinte resultado -

blue green orange red

Um dicionário é um arranjo para mapear valores para chaves. A sintaxe para o dicionário convencional é mostrada abaixo -

dict set dictname key value
# or 
dict create dictname key1 value1 key2 value2 .. keyn valuen

Alguns exemplos para a criação de um dicionário são mostrados abaixo -

#!/usr/bin/tclsh

dict set colours  colour1 red 
puts $colours
dict set colours  colour2 green
puts $colours set colours [dict create colour1 "black" colour2 "white"] puts $colours

Quando o código acima é executado, ele produz o seguinte resultado -

colour1 red
colour1 red colour2 green
colour1 black colour2 white

Tamanho do Dict

A sintaxe para obter o tamanho do dicionário é mostrada abaixo -

[dict size dictname]

Um exemplo de impressão do tamanho é mostrado abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
puts [dict size $colours]

Quando o código acima é executado, ele produz o seguinte resultado -

Iteração de Dicionário

Uma iteração de dicionário simples para imprimir chaves e valores do dicionário é mostrada abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
foreach item [dict keys $colours] {
   set value [dict get $colours $item]
   puts $value
}

Quando o código acima é executado, ele produz o seguinte resultado -

black
white

Valor para Chave no Dict

A sintaxe para recuperar o valor da chave em dict é mostrada abaixo -

[dict get $dictname $keyname]

Um exemplo de recuperação de valor para a chave é fornecido abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set value [dict get $colours colour1]
puts $value

Quando o código acima é executado, ele produz o seguinte resultado -

black

Todas as chaves no Dict

A sintaxe para recuperar todas as chaves em dict é mostrada abaixo -

[dict keys $dictname]

Um exemplo de impressão de todas as chaves é mostrado abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set keys [dict keys $colours] puts $keys

Quando o código acima é executado, ele produz o seguinte resultado -

colour1 colour2

Todos os valores em Dict

A sintaxe para recuperar todos os valores em dict é mostrada abaixo -

[dict values $dictname]

Um exemplo de impressão de todos os valores é mostrado abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set values [dict values $colours]
puts $values

Quando o código acima é executado, ele produz o seguinte resultado -

black white

A chave existe no Dict

A sintaxe para verificar se existe uma chave em dict é mostrada abaixo -

[dict exists $dictname $key]

Um exemplo para verificar se existe uma chave em dict é mostrado abaixo -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set result [dict exists $colours colour1]
puts $result

Quando o código acima é executado, ele produz o seguinte resultado -

Os procedimentos nada mais são do que blocos de código com uma série de comandos que fornecem uma funcionalidade reutilizável específica. É usado para evitar que o mesmo código seja repetido em vários locais. Os procedimentos são equivalentes às funções usadas em muitas linguagens de programação e são disponibilizados em Tcl com a ajuda deproc comando.

A sintaxe de criação de um procedimento simples é mostrada abaixo -

proc procedureName {arguments} {
   body
}

Um exemplo simples de procedimento é fornecido abaixo -

#!/usr/bin/tclsh

proc helloWorld {} {
   puts "Hello, World!"
}
helloWorld

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, World!

Procedimentos com vários argumentos

Um exemplo de procedimento com argumentos é mostrado abaixo -

#!/usr/bin/tclsh

proc add {a b} {
   return [expr $a+$b]
}
puts [add 10 30]

Quando o código acima é executado, ele produz o seguinte resultado -

Procedimentos com Argumentos Variáveis

Um exemplo de procedimento com argumentos é mostrado abaixo -

#!/usr/bin/tclsh

proc avg {numbers} {
   set sum 0
   foreach number $numbers {
      set sum  [expr $sum + $number]
   }
   set average [expr $sum/[llength $numbers]]
   return $average
}
puts [avg {70 80 50 60}]
puts [avg {70 80 50 }]

Quando o código acima é executado, ele produz o seguinte resultado -

65
66

Procedimentos com argumentos padrão

Os argumentos padrão são usados para fornecer valores padrão que podem ser usados se nenhum valor for fornecido. Um exemplo de procedimento com argumentos padrão, que às vezes é referido como argumentos implícitos, é mostrado abaixo -

#!/usr/bin/tclsh

proc add {a {b 100} } {
   return [expr $a+$b]
}
puts [add 10 30]
puts [add 10]

Quando o código acima é executado, ele produz o seguinte resultado -

40
110

Procedimentos Recursivos

Um exemplo de procedimentos recursivos é mostrado abaixo -

#!/usr/bin/tclsh

proc factorial {number} {
   if {$number <= 1} {
      return 1
   } 
   return [expr $number * [factorial [expr $number - 1]]]

}
puts [factorial 3]
puts [factorial 5]

Quando o código acima é executado, ele produz o seguinte resultado -

6
120

Os pacotes são usados para criar unidades de código reutilizáveis. Um pacote consiste em uma coleção de arquivos que fornecem funcionalidades específicas. Esta coleção de arquivos é identificada por um nome de pacote e pode ter várias versões dos mesmos arquivos. O pacote pode ser uma coleção de scripts Tcl, biblioteca binária ou uma combinação de ambos.

O pacote usa o conceito de namespace para evitar a colisão de nomes de variáveis e nomes de procedimentos. Confira mais em nosso próximo tutorial de ' namespace '.

Criando Pacote

Um pacote pode ser criado com a ajuda de no mínimo dois arquivos. Um arquivo contém o código do pacote. Outro arquivo contém o arquivo de pacote de índice para declarar seu pacote.

A lista de etapas para criar e usar o pacote é fornecida abaixo.

ETAPA 1: Criação de código

Crie o código para o pacote dentro de uma pasta, diga HelloWorld. Deixe o arquivo ser nomeado HelloWorld.tcl com o código conforme mostrado abaixo -

# /Users/rajkumar/Desktop/helloworld/HelloWorld.tcl 
# Create the namespace
namespace eval ::HelloWorld {
 
  # Export MyProcedure
  namespace export MyProcedure
 
  # My Variables
   set version 1.0
   set MyDescription "HelloWorld"
 
  # Variable for the path of the script
   variable home [file join [pwd] [file dirname [info script]]]
 
}
 
# Definition of the procedure MyProcedure
proc ::HelloWorld::MyProcedure {} {
   puts $HelloWorld::MyDescription } package provide HelloWorld $HelloWorld::version
package require Tcl 8.0

ETAPA 2: Criando Índice de Pacote

Abra o tclsh. Mude para o diretório HelloWorld e use o comando pkg_mkIndex para criar o arquivo de índice conforme mostrado abaixo -

% cd /Users/rajkumar/Desktop/helloworld 
% pkg_mkIndex . *.tcl

ETAPA 3: Adicionando diretório ao Autopath

Use o comando lappend para adicionar o pacote à lista global como mostrado abaixo -

% lappend auto_path "/Users/rajkumar/Desktop/helloworld"

PASSO 4: Adicionando Pacote

Em seguida, adicione o pacote ao programa usando a instrução package require conforme mostrado abaixo -

% package require HelloWorld 1.0

ETAPA 5: Procedimento de Invocação

Agora, tudo sendo configurado, podemos invocar nosso procedimento conforme mostrado abaixo -

% puts [HelloWorld::MyProcedure]

Você obterá o seguinte resultado -

HelloWorld

As duas primeiras etapas criam o pacote. Depois que o pacote é criado, você pode usá-lo em qualquer arquivo Tcl, adicionando as três últimas instruções conforme mostrado abaixo -

lappend auto_path "/Users/rajkumar/Desktop/helloworld"
package require HelloWorld 1.0
puts [HelloWorld::MyProcedure]

Você obterá o seguinte resultado -

HelloWorld

O namespace é um contêiner para um conjunto de identificadores usado para agrupar variáveis e procedimentos. Os namespaces estão disponíveis a partir do Tcl versão 8.0. Antes da introdução dos namespaces, havia um único escopo global. Agora, com os namespaces, temos partições adicionais de escopo global.

Criação de namespace

Os namespaces são criados usando o namespacecomando. Um exemplo simples de criação de namespace é mostrado abaixo -

#!/usr/bin/tclsh

namespace eval MyMath {
  # Create a variable inside the namespace
  variable myResult
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
  set ::MyMath::myResult [expr $a + $b]
}
MyMath::Add 10 23

puts $::MyMath::myResult

Quando o código acima é executado, ele produz o seguinte resultado -

No programa acima, você pode ver que há um namespace com uma variável myResult e um procedimento Add. Isso torna possível criar variáveis e procedimentos com os mesmos nomes em diferentes namespaces.

Namespaces aninhados

Tcl permite o aninhamento de namespaces. Um exemplo simples de aninhamento de namespaces é fornecido abaixo -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
}

namespace eval extendedMath {
   # Create a variable inside the namespace
   namespace eval MyMath {
      # Create a variable inside the namespace
      variable myResult
   }
}
set ::MyMath::myResult "test1"
puts $::MyMath::myResult
set ::extendedMath::MyMath::myResult "test2"
puts $::extendedMath::MyMath::myResult

Quando o código acima é executado, ele produz o seguinte resultado -

test1
test2

Importando e exportando namespace

Você pode ver nos exemplos de namespace anteriores, usamos muitos operadores de resolução de escopo e é mais complexo de usar. Podemos evitar isso importando e exportando namespaces. Um exemplo é dado abaixo -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}

namespace import MyMath::*
puts [Add 10 30]

Quando o código acima é executado, ele produz o seguinte resultado -

Esqueça o namespace

Você pode remover um namespace importado usando forgetsubcomando. Um exemplo simples é mostrado abaixo -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}
namespace import MyMath::*
puts [Add 10 30]
namespace forget MyMath::*

Quando o código acima é executado, ele produz o seguinte resultado -

O Tcl suporta o manuseio de arquivos com a ajuda dos comandos embutidos open, read, puts, gets e close.

Um arquivo representa uma seqüência de bytes, não importa se é um arquivo de texto ou binário.

Abrindo arquivos

Tcl usa o comando open para abrir arquivos em Tcl. A sintaxe para abrir um arquivo é a seguinte -

open fileName accessMode

Aqui, filename é uma string literal, que você usará para nomear seu arquivo e accessMode pode ter um dos seguintes valores -

Sr. Não.	Modo e descrição
1	r Abre um arquivo de texto existente para fins de leitura e o arquivo deve existir. Este é o modo padrão usado quando nenhum accessMode é especificado.
2	w Abre um arquivo de texto para gravação; se ele não existir, um novo arquivo será criado, caso contrário, o arquivo existente será truncado.
3	a Abre um arquivo de texto para gravação em modo de acréscimo e o arquivo deve existir. Aqui, seu programa começará a anexar conteúdo ao conteúdo do arquivo existente.
4	r+ Abre um arquivo de texto para leitura e escrita. O arquivo já deve existir.
5	w+ Abre um arquivo de texto para leitura e escrita. Ele primeiro trunca o arquivo para comprimento zero se ele existir, caso contrário, crie o arquivo se ele não existir.
6	a+ Abre um arquivo de texto para leitura e escrita. Ele cria o arquivo se ele não existir. A leitura começará do início, mas a escrita só pode ser anexada.

Fechando um Arquivo

Para fechar um arquivo, use o comando close. A sintaxe para fechar é a seguinte -

close fileName

Qualquer arquivo que foi aberto por um programa deve ser fechado quando o programa terminar de usar esse arquivo. Na maioria dos casos, os arquivos não precisam ser fechados explicitamente; eles são fechados automaticamente quando os objetos Arquivo são encerrados automaticamente.

Gravando um Arquivo

O comando Puts é usado para gravar em um arquivo aberto.

puts $filename "text to write"

Um exemplo simples para gravar em um arquivo é mostrado abaixo.

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test" close $fp

Quando o código acima é compilado e executado, ele cria um novo arquivo input.txt no diretório sob o qual foi iniciado (no diretório de trabalho do programa).

Lendo um arquivo

A seguir está o comando simples para ler de um arquivo -

set file_data [read $fp]

Um exemplo completo de leitura e gravação é mostrado abaixo -

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test"
close $fp set fp [open "input.txt" r] set file_data [read $fp]
puts $file_data close $fp

Quando o código acima é compilado e executado, ele lê o arquivo criado na seção anterior e produz o seguinte resultado -

test

Aqui está outro exemplo para ler o arquivo até o final do arquivo linha por linha -

#!/usr/bin/tclsh

set fp [open "input.txt" w+]
puts $fp "test\ntest" close $fp
set fp [open "input.txt" r]

while { [gets $fp data] >= 0 } { puts $data
}
close $fp

Quando o código acima é compilado e executado, ele lê o arquivo criado na seção anterior e produz o seguinte resultado -

test
test

O tratamento de erros em Tcl é fornecido com a ajuda de error e catchcomandos. A sintaxe de cada um desses comandos é mostrada a seguir.

Sintaxe de erro

error message info code

Na sintaxe do comando de erro acima, a mensagem é a mensagem de erro, as informações são definidas na variável global errorInfo e o código é definido na variável global errorCode.

Catch Syntax

catch script resultVarName

Na sintaxe do comando catch acima, script é o código a ser executado, resultVarName é a variável que contém o erro ou o resultado. O comando catch retorna 0 se não houver erro e 1 se houver erro.

Um exemplo de tratamento de erros simples é mostrado abaixo -

#!/usr/bin/tclsh

proc Div {a b} {
   if {$b == 0} {
      error "Error generated by error" "Info String for error" 401
   } else {
      return [expr $a/$b]
   }
}

if {[catch {puts "Result = [Div 10 0]"} errmsg]} {
   puts "ErrorMsg: $errmsg" puts "ErrorCode: $errorCode"
   puts "ErrorInfo:\n$errorInfo\n" } if {[catch {puts "Result = [Div 10 2]"} errmsg]} { puts "ErrorMsg: $errmsg"
   puts "ErrorCode: $errorCode" puts "ErrorInfo:\n$errorInfo\n"
}

Quando o código acima é executado, ele produz o seguinte resultado -

ErrorMsg: Error generated by error
ErrorCode: 401
ErrorInfo:
Info String for error
   (procedure "Div" line 1)
   invoked from within
"Div 10 0"

Result = 5

Como você pode ver no exemplo acima, podemos criar nossas próprias mensagens de erro personalizadas. Da mesma forma, é possível detectar o erro gerado pelo Tcl. Um exemplo é mostrado abaixo -

#!/usr/bin/tclsh

catch {set file [open myNonexistingfile.txt]} result
puts "ErrorMsg: $result" puts "ErrorCode: $errorCode"
puts "ErrorInfo:\n$errorInfo\n"

Quando o código acima é executado, ele produz o seguinte resultado -

ErrorMsg: couldn't open "myNonexistingfile.txt": no such file or directory
ErrorCode: POSIX ENOENT {no such file or directory}
ErrorInfo:
couldn't open "myNonexistingfile.txt": no such file or directory
   while executing
"open myNonexistingfile.txt"

O Tcl fornece várias funções internas (procedimentos) para várias operações. Isso inclui -

Funções para tratamento de listas .
Funções para manipulação de strings .
Funções para manipulação de array .
Funções para manipulação de dicionário .
Funções para manipulação de E / S de arquivo .
Funções para criar namespaces e pacotes.
Funções para operações matemáticas.
Funções para operações do sistema.

Cada uma das opções acima, exceto as funções matemáticas e do sistema, são abordadas nos capítulos anteriores. As funções matemáticas e integradas do sistema são explicadas abaixo.

Funções Matemáticas

As funções matemáticas disponíveis em Tcl estão listadas na tabela a seguir -

Sr. Não.	Método e Descrição
1	abs arg Calcula o valor absoluto de arg.
2	acos arg Calcula o arco-cosseno de arg.
3	asin arg Calcula o arco seno de arg.
4	atan arg Calcula o arco tangente de arg.
5	atan2 yx Calcula o arco tangente do quociente de seus argumentos (y / x).
6	ceil arg Calcula o menor inteiro maior ou igual a um número.
7	cos arg Calcula o cosseno de arg.
8	cosh arg Calcula o cosseno hiperbólico de arg.
9	double arg Calcula se arg é um valor de ponto flutuante, retorna arg; caso contrário, converte arg em ponto flutuante e retorna o valor convertido.
10	exp arg Calcula uma função exponencial (e elevado à potência de arg).
11	floor arg Calcula o maior inteiro menor ou igual a arg.
12	fmod xy Calcula o resto do ponto flutuante da divisão de x por y. Se y for 0, um erro será retornado.
13	hypot xy Calcula o comprimento da hipotenusa de um triângulo retângulo sqrt (x * x + y * y).
14	int arg Calcula se arg é um valor inteiro da mesma largura que a palavra de máquina, retorna arg, caso contrário, converte arg em um inteiro.
15	log arg Calcula o logaritmo natural de arg.
16	log10 arg Calcula o logaritmo de base 10 de arg.
17	pow xy Calcula o valor de x elevado à potência y. Se x for negativo, y deve ser um valor inteiro.
18	rand Calcula um número pseudoaleatório entre 0 e 1.
19	round arg Calcula o valor de arg arredondado para o inteiro mais próximo.
20	sin arg Calcula o seno de arg.
21	sinh arg Calcula o seno hiperbólico de arg.
22	sqrt arg Calcula a raiz quadrada de arg. arg deve ser positivo.
23	srand arg Calcula um número pseudoaleatório entre 0 e 1. O arg, que deve ser um inteiro, é usado para redefinir a semente do gerador de número aleatório de rand.
24	tan arg Calcula a tangente de arg.
25	tanh arg Calcula a tangente hiperbólica de arg.
26	wide arg Calcula o valor inteiro com pelo menos 64 bits de largura (por extensão de sinal se arg for um número de 32 bits) para arg se ainda não for um.

Alguns exemplos usando funções matemáticas são fornecidos abaixo -

#!/usr/bin/tclsh

namespace import ::tcl::mathfunc::*
puts [tan 10]
puts [pow 10 2]
puts [ceil 10.34]
puts [hypot 10 20]
puts [srand 45]
puts [log 10]
puts [srand 45]

Quando o código acima é executado, ele produz o seguinte resultado -

0.6483608274590866
100.0
11.0
22.360679774997898
0.0003521866166741525
2.302585092994046
0.0003521866166741525

Funções do sistema

As funções importantes do sistema em Tcl incluem,

clock - função de segundos, que retorna a hora atual em segundos.
clock - função de formato, que formata os segundos em data e hora.
clock - função de varredura, que varre a string de entrada e a converte em segundos.
open - função, que é usada para abrir um arquivo.
exec - função, que é usada para executar um comando do sistema.
close - função, que é usada para fechar um arquivo.

Alguns exemplos para as funções acima estão listados abaixo -

#!/usr/bin/tclsh

#get seconds
set currentTime [clock seconds]
puts $currentTime
#get format 
puts "The time is: [clock format $currentTime -format %H:%M:%S]" puts "The date is: [clock format $currentTime -format %D]"

set date "Jun 15, 2014"
puts [clock scan $date -format {%b %d, %Y}] puts [exec ls] puts [exec dir] set a [open input.txt] puts [read $a];
puts $a close $a

Quando o código acima é executado, ele produz o seguinte resultado -

1402819756
The time is: 03:09:16
The date is: 06/15/2014
1402808400
input.txt
main.tcl
input.txt  main.tcl
This is the file you can use to provide input to your program and later on open
   it inside your program to process the input.

file3

A tabela a seguir fornece as strings de lista que podem ser usadas para formatar a data e a hora.

Sr. Não.	Formato e descrição
1	%a Dia em forma abreviada, por exemplo: Sol.
2	%A Dia completo, por exemplo: domingo.
3	%b Mês resumido.
4	%B Mês completo.
5	%d Dia do mês.
6	%j Dia juliano do ano.
7	%m Mês em número.
8	%y Ano em dois dígitos.
9	%Y Ano em quatro dígitos.
10	%H Hora no relógio de 24 horas.
11	%I Hora no relógio de 12 horas.
12	%M Minutos.
13	%S Segundos.
14	%p AM ou PM.
15	%D Data em número, mm / dd / aa.
16	%r Tempo no relógio de 12 horas.
17	%R Tempo em relógio de 24 horas sem segundos.
18	%T Tempo no relógio de 24 horas com segundos.
19	%Z Nome do fuso horário como GMT, IST, EST e assim por diante.

O comando "regexp" é usado para corresponder a uma expressão regular em Tcl. Uma expressão regular é uma sequência de caracteres que contém um padrão de pesquisa. Ele consiste em várias regras e a tabela a seguir explica essas regras e o uso correspondente.

Sr. Não.	Regra e descrição
1	x Combinação exata.
2	[a-z] Qualquer letra minúscula de az.
3	. Qualquer personagem.
4	^ A string inicial deve corresponder.
5	$ A string final deve corresponder.
6	\^ Seqüência de folga para corresponder ao caractere especial ^. Da mesma forma, você pode usar para outros caracteres.
7	() Adicione as sequências acima entre parênteses para fazer uma expressão regular.
8	x* Deve corresponder a 0 ou mais ocorrências do x anterior.
9	x+ Deve corresponder a 1 ou mais ocorrências do x anterior.
10	[a-z]? Deve corresponder a 0 ou 1 ocorrência do x anterior.
11	{digit} Corresponde exatamente a ocorrências de dígitos da expressão regex anterior. Dígito que contém 0-9.
12	{digit,} Corresponde a 3 ou mais ocorrências de dígitos da expressão regex anterior. Dígito que contém 0-9.
13	{digit1,digit2} Ocorrências corresponde ao intervalo entre ocorrências de dígito1 e dígito2 da expressão regex anterior.

Sintaxe

A sintaxe para regex é fornecida abaixo -

regexp optionalSwitches patterns searchString fullMatch subMatch1 ... subMatchn

Aqui, regex é o comando. Veremos sobre opções opcionais mais tarde. Os padrões são as regras mencionadas anteriormente. A string de pesquisa é a string real na qual o regex é executado. A correspondência completa é qualquer variável para conter o resultado do resultado regex correspondente. Submatch1 a SubMatchn são variáveis opcionais de subMatch que contêm o resultado dos padrões de subcasas.

Vejamos alguns exemplos simples antes de mergulhar nos complexos. Um exemplo simples de uma string com qualquer alfabeto. Quando qualquer outro caractere for encontrado na regex, a pesquisa será interrompida e retornada.

#!/usr/bin/tclsh

regexp {([A-Za-z]*)} "Tcl Tutorial" a b 
puts "Full Match: $a"
puts "Sub Match1: $b"

Quando o código acima é executado, ele produz o seguinte resultado -

Full Match: Tcl
Sub Match1: Tcl

Padrões múltiplos

O exemplo a seguir mostra como pesquisar vários padrões. Este é um exemplo de padrão para qualquer alfabeto seguido por qualquer caractere seguido por qualquer alfabeto.

#!/usr/bin/tclsh

regexp {([A-Za-z]*).([A-Za-z]*)} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b" puts "Sub Match2: $c"

Quando o código acima é executado, ele produz o seguinte resultado -

Full Match: Tcl Tutorial
Sub Match1: Tcl
Sub Match2: Tutorial

Uma versão modificada do código acima para mostrar que um subpadrão pode conter vários padrões é mostrada abaixo -

#!/usr/bin/tclsh

regexp {([A-Za-z]*.([A-Za-z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a" puts "Sub Match1: $b"
puts "Sub Match2: $c"

Quando o código acima é executado, ele produz o seguinte resultado -

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

Opções para Comando Regex

A lista de opções disponíveis em Tcl são,

nocase - Usado para ignorar o caso.
indices - Armazene a localização de subpadrões correspondentes em vez de caracteres correspondentes.
line- Nova correspondência de linha sensível. Ignora os caracteres após a nova linha.
start index - Define o deslocamento do início do padrão de pesquisa.
Marca o fim dos interruptores

Nos exemplos acima, usei deliberadamente [AZ, az] para todos os alfabetos, você pode facilmente usar -nocase em vez de como mostrado abaixo -

#!/usr/bin/tclsh

regexp -nocase {([A-Z]*.([A-Z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b" puts "Sub Match2: $c"

Quando o código acima é executado, ele produz o seguinte resultado -

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

Outro exemplo usando interruptores é mostrado abaixo -

#!/usr/bin/tclsh

regexp -nocase -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b 
puts "Full Match: $a" puts "Sub Match1: $b"
regexp -nocase -start 4 -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b  
puts "Full Match: $a" puts "Sub Match1: $b"

Quando o código acima é executado, ele produz o seguinte resultado -

Full Match: Tcl 
Sub Match1: Tcl 
Full Match: Tutorial
Sub Match1: Tutorial

Tk refere-se a Toolkit e fornece widgets de interface gráfica de plataforma cruzada, o que ajuda você a construir uma interface gráfica com o usuário. Ele foi desenvolvido como uma extensão da linguagem de script Tcl por John Ousterhout. O Tk permaneceu em desenvolvimento independente do Tcl com versões diferentes entre si, antes era feito em sincronia com o Tcl na v8.0.

Características do Tk

É uma plataforma cruzada com suporte para sistemas operacionais Linux, Mac OS, Unix e Microsoft Windows.

É um código aberto.
Ele fornece alto nível de extensibilidade.
É personalizável.
É configurável.
Ele fornece um grande número de widgets.
Ele pode ser usado com outras linguagens dinâmicas e não apenas com Tcl.
GUI parece idêntico em todas as plataformas.

Aplicativos construídos em Tk

Grandes aplicativos de sucesso foram criados em Tcl / Tk.

Interface do usuário do painel de controle
Forms GUI para Relational DB
GUI ad hoc para banco de dados relacional
Design de sistema de software / hardware
Xtask - Gerenciamento de Tarefas
Musicologia com Tcl e Tk
App calendário
Tk mail
Tk Debugger

Geralmente, todos os Mac e Linux mac vêm com o Tk pré-instalado. Caso não esteja disponível ou você precise da versão mais recente, pode ser necessário instalá-lo. O Windows não vem com Tcl / Tk e você pode precisar usar seu binário específico para instalá-lo.

O Intérprete Tk

É apenas um pequeno programa que permite digitar comandos Tk e executá-los linha por linha. Ele interrompe a execução de um arquivo tcl caso encontre um erro ao contrário de um compilador que executa totalmente.

Vamos ter um arquivo helloWorld.tcl da seguinte maneira. Vamos usar isso como primeiro programa, rodamos na plataforma que você escolher.

#!/usr/bin/wish

grid [ttk::button .mybutton -text "Hello World"]

A seção a seguir explica apenas como instalar Tcl / Tk em cada uma das plataformas disponíveis.

Instalação em Windows

Baixe a versão mais recente do instalador do Windows da lista de binários Tcl / Tk ativos disponíveis. A edição da comunidade Tcl / Tk ativa é gratuita para uso pessoal.

Execute o executável baixado para instalar o Tcl e Tk, o que pode ser feito seguindo as instruções na tela.

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, mudando para a pasta que contém o arquivo usando cd e, em seguida, seguindo a seguinte etapa -

C:\Tcl> wish helloWorld.tcl

Pressione enter e veremos uma saída conforme mostrado abaixo -

Instalação em Linux

A maioria dos sistemas operacionais Linux vem com o Tk embutido e você pode começar imediatamente com esses sistemas. Caso não esteja disponível, você pode usar o seguinte comando para baixar e instalar o Tcl-Tk.

$ yum install tcl tk

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, alternando para a pasta que contém o arquivo usando cd command e então usando a seguinte etapa -

$ wish helloWorld.tcl

Pressione Enter e veremos uma saída semelhante a esta -

Instalação em sistemas baseados em Debian

Caso não esteja disponível pré-construído em seu sistema operacional, você pode usar o seguinte comando para baixar e instalar Tcl-Tk -

$ sudo apt-get install tcl tk

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, alternando para a pasta que contém o arquivo usando cd command e, em seguida, usando as seguintes etapas -

$ wish helloWorld.tcl

Pressione Enter e veremos uma saída semelhante a esta -

Instalação em Mac OS X

Baixe a versão mais recente do pacote Mac OS X da lista de binários Tcl / Tk ativos disponíveis. A edição da comunidade Active Tcl é gratuita para uso pessoal.

Execute o executável baixado para instalar o Active Tcl, o que pode ser feito seguindo as instruções na tela.

Agora, podemos construir e executar um arquivo Tcl, digamos helloWorld.tcl, alternando para a pasta que contém o arquivo usando cd command e então usando a seguinte etapa -

$ wish helloWorld.tcl

Pressione enter e veremos uma saída conforme mostrado abaixo -

Instalação de arquivos de origem

Você pode usar a opção de instalar a partir de arquivos de origem quando um pacote binário não estiver disponível. Geralmente é preferível usar binários Tk para Windows e Mac OS X, portanto, apenas a compilação de fontes em sistemas baseados em Unix é mostrada abaixo -

Baixe os arquivos de origem.
Agora, use os seguintes comandos para extrair, compilar e construir após alternar para a pasta baixada.

$ tar zxf tk8.6.1-src.tar.gz
$ cd tcl8.6.1 $ cd unix
$ ./configure —with-tcl=../../tcl8.6.1/unix —prefix=/opt —enable-gcc $ make
$ sudo make install

Note - Certifique-se de alterar o nome do arquivo para a versão baixada nos comandos 1 e 2 acima.

No Tk, classificamos algumas das variáveis como variáveis especiais e elas têm um uso / funcionalidade predefinido. A lista de variáveis especiais está listada abaixo.

Sr. Não.	Variável Especial e Descrição
1	tk_library Usado para definir a localização de bibliotecas Tk padrão.
2	tk_patchLevel Refere-se ao nível de patch atual do interpretador Tk.
3	tk_strictMotif Quando diferente de zero, Tk tenta aderir à aparência do Motif o mais próximo possível.
4	tk_version Exibe a versão do Tk.

As variáveis especiais acima têm seus significados especiais para o interpretador Tk.

Exemplos de uso de variáveis especiais Tk

Vamos ver os exemplos de variáveis especiais.

VERSÃO TK

#!/usr/bin/wish

puts $tk_version

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo.

8.5

CAMINHO DA BIBLIOTECA TK

#!/usr/bin/wish

puts $tk_library

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo.

/Library/Frameworks/Tk.framework/Versions/8.6/Resources/Scripts

TK PATCH LEVEL

#!/usr/bin/wish

puts $tk_patchLevel

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo.

8.6.1

TK STRICTMOTIF

#!/usr/bin/wish

puts $tk_strictMotif

Ao executar o programa, você obterá uma saída semelhante à mostrada abaixo.

O componente básico de um aplicativo baseado em Tk é chamado de widget. Um componente também é às vezes chamado de janela, uma vez que, em Tk, "janela" e "widget" costumam ser usados alternadamente. Tk é um pacote que fornece um rico conjunto de componentes gráficos para a criação de aplicativos gráficos com Tcl.

Tk fornece uma variedade de widgets que vão desde widgets GUI básicos, como botões e menus, até widgets de exibição de dados. Os widgets são muito configuráveis, pois possuem configurações padrão tornando-os fáceis de usar.

Os aplicativos Tk seguem uma hierarquia de widget onde qualquer número de widgets pode ser colocado em outro widget e esses widgets em outro widget. O widget principal em um programa Tk é conhecido como widget raiz e pode ser criado criando uma nova instância da classe TkRoot.

Criação de um widget

A sintaxe para criar um widget é fornecida abaixo.

type variableName arguments options

O tipo aqui se refere ao tipo de widget como botão, rótulo e assim por diante. Os argumentos podem ser opcionais e obrigatórios com base na sintaxe individual de cada widget. As opções variam do tamanho à formatação de cada componente.

Convenção de nomenclatura de widget

Widget usa uma estrutura semelhante a pacotes de nomenclatura. No Tk, a janela raiz é nomeada com um ponto (.) E um elemento na janela, por exemplo, o botão é denominado .myButton1. O nome da variável deve começar com uma letra minúscula, dígito ou sinal de pontuação (exceto um ponto). Após o primeiro caractere, outros caracteres podem ser letras maiúsculas ou minúsculas, números ou sinais de pontuação (exceto pontos). Recomenda-se usar uma letra minúscula para iniciar o rótulo.

Convenção de Nomenclatura de Cores

As cores podem ser declaradas usando nomes como vermelho, verde e assim por diante. Ele também pode usar hexadecimal representando com #. O número de dígitos hexadecimais pode ser 3, 6, 9 ou 12.

Convenção de Dimensão

A unidade padrão é pixels e é usada quando não especificamos nenhuma dimensão. As outras dimensões são i para polegadas, m para milímetros, c para centímetros e p para pontos.

Opções Comuns

Existem tantas opções comuns disponíveis para todos os widgets e elas estão listadas abaixo na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	-background color Usado para definir a cor de fundo do widget.
2	-borderwidth width Usado para desenhar com borda em efeitos 3D.
3	-font fontDescriptor Usado para definir a fonte do widget.
4	-foreground color Usado para definir a cor do primeiro plano para o widget.
5	-height number Usado para definir a altura do widget.
6	-highlightbackground color Usado para definir o retângulo de cor para desenhar ao redor de um widget quando o widget não tem o foco de entrada.
7	-highlightcolor color Usado para definir o retângulo de cor para desenhar ao redor de um widget quando o widget tem o foco de entrada.
8	-padx number Define o padx para o widget.
9	-pady number Define o pady para o widget.
10	-relief condition Define o relevo 3D para este widget. A condição pode ser elevada, afundada, plana, crista, sólida ou sulcada.
11	-text text Define o texto do widget.
12	-textvariable varName Variável associada ao widget. Quando o texto do widget muda, a variável é definida com o texto do widget.
13	-width number Define a largura do widget.

Um exemplo simples de opções é mostrado abaixo.

#!/usr/bin/wish

grid [label .myLabel -background red -text "Hello World" -relief ridge -borderwidth 3]
   -padx 100 -pady 100

Quando executamos o programa acima, obteremos a seguinte saída.

A lista de widgets disponíveis é categorizada abaixo -

Widgets básicos

Sr. Não.	Widget e descrição
1	Label Widget para exibir uma única linha de texto.
2	Button Widget que é clicável e aciona uma ação.
3	Entry Widget usado para aceitar uma única linha de texto como entrada.
4	Message Widget para exibir várias linhas de texto.
5	Text Widget para exibir e opcionalmente editar várias linhas de texto.
6	Toplevel Janela com todas as bordas e decorações fornecidas pelo gerenciador de janelas.

Layout Widgets

Sr. Não.	Widget e descrição
1	Frame Widget de contêiner para conter outros widgets.
2	Place Widget para manter outros widgets em locais específicos com coordenadas de sua origem e um tamanho exato.
3	Pack Widget simples para organizar widgets em blocos antes de colocá-los no widget pai.
4	Grid Widget para aninhar widgets embalados em diferentes direções.

Widgets de seleção

Sr. Não.	Widget e descrição
1	Radiobutton Widget que possui um conjunto de botões liga / desliga e rótulos, um dos quais pode ser selecionado.
2	Checkbutton Widget que possui um conjunto de botões liga / desliga e rótulos, muitos dos quais podem ser selecionados.
3	Menu Widget que atua como suporte para itens de menu.
4	Listbox Widget que exibe uma lista de células, uma ou mais das quais podem ser selecionadas.

Mega Widgets

Sr. Não.	Widget e descrição
1	Dialog Widget para exibir caixas de diálogo.
2	Spinbox Widget que permite aos usuários escolher números.
3	Combobox Widget que combina uma entrada com uma lista de opções disponíveis para uso.
4	Notebook Widget com guias que ajuda a alternar entre uma das várias páginas, usando uma guia de índice.
5	Progressbar Widget para fornecer feedback visual sobre o andamento de uma operação longa, como upload de arquivo.
6	Treeview Widget para exibir e permitir navegar por uma hierarquia de itens mais em forma de árvore.
7	Scrollbar Widgets de rolagem sem widgets de texto ou tela.
8	Scale Widget de escala para escolher um valor numérico por meio de controles deslizantes.

Outros Widgets

Sr. Não.	Widget e descrição
1	Canvas Widget de desenho para exibir gráficos e imagens.

Abordaremos cada um desses widgets nos próximos capítulos.

Widgets básicos são widgets comuns disponíveis em quase todos os aplicativos Tk. A lista de widgets básicos disponíveis é fornecida abaixo -

Sr. Não.	Widgets e descrição
1	Rótulo Widget para exibir uma única linha de texto.
2	Botão Widget que é clicável e aciona uma ação.
3	Entrada Widget usado para aceitar uma única linha de texto como entrada.
4	mensagem Widget para exibir várias linhas de texto.
5	Texto Widget para exibir e opcionalmente editar várias linhas de texto.
6	Nível Superior Widget usado para criar um quadro que é uma nova janela de nível superior.

Um exemplo simples de Tk é mostrado abaixo usando widgets básicos -

#!/usr/bin/wish

grid [label .myLabel -text "Label Widget" -textvariable labelText] 
grid [text .myText -width 20 -height 5]
.myText insert 1.0 "Text\nWidget\n"
grid [entry .myEntry -text "Entry Widget"]
grid [message .myMessage -background red -foreground white -text "Message\nWidget"]
grid [button .myButton1  -text "Button" -command "set labelText clicked"]

Quando executarmos o programa acima, obteremos a seguinte saída -

Widgets de layout são usados para lidar com layouts para o aplicativo Tk. O widget de quadro é usado para agrupar outros widgets e o local, o pacote e a grade são gerenciadores de layout para dar a você controle total sobre sua adição às janelas. A lista de widgets de layout disponíveis é mostrada abaixo -

Sr. Não.	Widgets e descrição
1	Quadro, Armação Widget de contêiner para conter outros widgets.
2	Lugar, colocar Widget para manter outros widgets em locais específicos com coordenadas de sua origem e um tamanho exato.
3	Pacote Widget simples para organizar widgets em blocos antes de colocá-los no widget pai.
4	Rede Widget para aninhar widgets embalados em diferentes direções.

Um exemplo simples de Tk é mostrado abaixo para widgets de layout -

#!/usr/bin/wish

frame .myFrame1 -background red  -relief ridge -borderwidth 8 -padx 10 -pady 10
   -height 100 -width 100
frame .myFrame2 -background blue  -relief ridge -borderwidth 8 -padx 10 -pady 10
   -height 100 -width 50
pack .myFrame1 
pack .myFrame2

Quando executarmos o programa acima, obteremos a seguinte saída -

Os widgets de seleção são usados para selecionar diferentes opções em um aplicativo Tk. A lista de widgets de seleção disponíveis é mostrada abaixo.

Sr. Não.	Widgets e descrição
1	Botao de radio Widget que possui um conjunto de botões liga / desliga e rótulos, um dos quais pode ser selecionado.
2	Botão de verificação Widget que possui um conjunto de botões liga / desliga e rótulos, muitos dos quais podem ser selecionados.
3	Cardápio Widget que atua como suporte para itens de menu.
4	Listbox Widget que exibe uma lista de células, uma ou mais das quais podem ser selecionadas.

Um exemplo simples de Tk é mostrado abaixo usando widgets de seleção -

#!/usr/bin/wish

grid [frame .gender ]
grid [label .label1  -text "Male" -textvariable myLabel1 ] 
grid [radiobutton .gender.maleBtn -text "Male"   -variable gender -value "Male"
   -command "set  myLabel1 Male"] -row 1 -column 2
grid [radiobutton .gender.femaleBtn -text "Female" -variable gender -value "Female"
   -command "set  myLabel1 Female"] -row 1 -column 3
.gender.maleBtn select
grid [label .myLabel2  -text "Range 1 not selected" -textvariable myLabelValue2 ] 
grid [checkbutton .chk1 -text "Range 1" -variable occupied1 -command {if {$occupied1 } {
   set myLabelValue2 {Range 1 selected}
} else {
   set myLabelValue2 {Range 1 not selected}
} }]
proc setLabel {text} {
   .label configure -text $text 
}

Quando executarmos o programa acima, obteremos a seguinte saída -

A tela é usada para fornecer áreas de desenho. A sintaxe do widget de tela é mostrada abaixo -

canvas canvasName options

Opções

As opções disponíveis para o widget de tela estão listadas abaixo na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	-background color Usado para definir a cor de fundo do widget.
2	-closeenough distance Define a proximidade do cursor do mouse para um item exibível. O padrão é 1.0 pixel. Este valor pode ser uma fração e deve ser positivo.
3	-scrollregion boundingBox A caixa delimitadora da área total desta tela.
4	-height number Usado para definir a altura do widget.
5	-width number Define a largura do widget.
6	-xscrollincrement size A quantidade de rolagem horizontal quando a rolagem é solicitada.
7	-yscrollincrement size A quantidade a rolar verticalmente quando a rolagem é solicitada.

Um exemplo simples de widget de tela é mostrado abaixo -

#!/usr/bin/wish

canvas .myCanvas -background red -width 100 -height 100 
pack .myCanvas

Quando executarmos o programa acima, obteremos a seguinte saída -

Widgets para desenhar em tela

A lista de widgets disponíveis para desenho na tela está listada abaixo -

Sr. Não.	Widget e descrição
1	Linha Desenha uma linha.
2	Arco Desenha um arco.
3	Retângulo Desenha um retângulo.
4	oval Desenha uma oval.
5	Polígono Desenha um polígono.
6	Texto Desenha um texto.
7	Bitmap Desenha um bitmap.
8	Imagem Desenha uma imagem.

Um exemplo usando diferentes widgets de tela é mostrado abaixo -

#!/usr/bin/wish

canvas .myCanvas -background red -width 200 -height 200 
pack .myCanvas
.myCanvas create arc 10 10 50 50 -fill yellow
.myCanvas create line 10 30 50 50 100 10 -arrow both -fill yellow -smooth true
   -splinesteps 2
.myCanvas create oval 50 50 100 80 -fill yellow
.myCanvas create polygon 50 150 100 80 120 120 100 190 -fill yellow -outline green
.myCanvas create rectangle 150 150 170 170  -fill yellow
.myCanvas create text 170 20 -fill yellow -text "Hello" -font {Helvetica -18 bold}
.myCanvas create bitmap 180 50 -bitmap info

Quando executarmos o programa acima, obteremos a seguinte saída -

Mega widgets incluem muitos widgets complexos que são freqüentemente necessários em alguns aplicativos Tk de grande escala. A lista de mega widgets disponíveis é mostrada abaixo -

Sr. Não.	Widget e descrição
1	Diálogo Widget para exibir caixas de diálogo.
2	Spinbox Widget que permite aos usuários escolher números.
3	Caixa combo Widget que combina uma entrada com uma lista de opções disponíveis para uso.
4	Caderno Widget com guias que ajuda a alternar entre uma das várias páginas, usando uma guia de índice.
5	Barra de progresso Widget para fornecer feedback visual sobre o andamento de uma operação longa, como upload de arquivo.
6	Treeview Widget para exibir e permitir navegar por uma hierarquia de itens mais em forma de árvore.
7	Barra de rolagem Widgets de rolagem sem widgets de texto ou tela.
8	Escala Widget de escala para escolher um valor numérico por meio de controles deslizantes.

Um exemplo simples de Tk é mostrado abaixo usando alguns mega widgets.

#!/usr/bin/wish

ttk::treeview .tree -columns "Creator Year" -displaycolumns "Year Creator" 
.tree heading Creator -text "Creator" -anchor center
.tree heading Year -text "Year" -anchor center
pack .tree
.tree insert {} end -id Languages -text "Languages"
.tree insert Languages end -text C -values [list "Dennis Ritchie" "1990"]
proc scaleMe {mywidget scaleValue} {
	$mywidget configure -length $scaleValue
} 
pack [scale .s2  -from 100.0 -to 200.0 -length 100 -background yellow -borderwidth 5
   -font{Helvetica -18 bold} -foreground red -width 40 -relief ridge -orien horizontal
   -variable a -command "scaleMe .s2" ]
pack [ttk::progressbar .p1 -orient horizontal -length 200 -mode indeterminate -value 90]
pack [ttk::progressbar .p2 -orient horizontal -length 200 -mode determinate -variable a
   -maximum 75 -value 20]

Quando executarmos o programa acima, obteremos a seguinte saída -

Existem vários widgets que suportam a exibição de texto. A maioria deles fornece a opção de atributo de fonte. A sintaxe para criar uma fonte é mostrada abaixo -

font create fontName options

Opções

As opções disponíveis para a criação de fonte estão listadas abaixo na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	-family familyName O nome da família da fonte.
2	-size number O tamanho da fonte.
3	-weight level O peso da fonte.

Um exemplo simples para a criação de uma fonte é mostrado abaixo -

#!/usr/bin/wish

font create myFont -family Helvetica -size 18 -weight bold 
pack [label .myLabel -font myFont -text "Hello World"]

Quando executarmos o programa acima, obteremos a seguinte saída -

Para obter todas as fontes disponíveis, podemos usar o seguinte comando -

#!/usr/bin/wish

puts [font families]

Quando executamos o comando acima, obteremos a seguinte saída -

{Abadi MT Condensed Extra Bold} {Abadi MT Condensed Light} {Al Bayan} {Al Nile}
{Al Tarikh} {American Typewriter} {Andale Mono} Arial {Arial Black}
{Arial Hebrew} {Arial Narrow} {Arial Rounded MT Bold} {Arial Unicode MS}
Athelas Avenir {Avenir Next} {Avenir Next Condensed} Ayuthaya Baghdad {Bangla MN}
{Bangla Sangam MN} {Baoli SC} Baskerville {Baskerville Old Face} Batang {Bauhaus 93}
Beirut {Bell MT} {Bernard MT Condensed} BiauKai {Big Caslon} {Book Antiqua}
{Bookman Old Style} {Bookshelf Symbol 7} Braggadocio {Britannic Bold} {Brush Script MT}
Calibri {Calisto MT} Cambria {Cambria Math} Candara Century {Century Gothic}
{Century Schoolbook} Chalkboard {Chalkboard SE} Chalkduster {Charcoal CY} Charter
Cochin {Colonna MT} {Comic Sans MS} Consolas Constantia {Cooper Black} Copperplate
{Copperplate Gothic Bold} {Copperplate Gothic Light} Corbel {Corsiva Hebrew} Courier
{Courier New} {Curlz MT} Damascus {DecoType Naskh} Desdemona {Devanagari MT}
{Devanagari Sangam MN} Didot {DIN Alternate} {DIN Condensed} {Diwan Kufi} {Diwan Thuluth}
{Edwardian Script ITC} {Engravers MT} {Euphemia UCAS} Eurostile Farah Farisi
{Footlight MT Light} {Franklin Gothic Book} {Franklin Gothic Medium}
Futura Gabriola Garamond {GB18030 Bitmap} {Geeza Pro} Geneva {Geneva CY}
Georgia {Gill Sans} {Gill Sans MT} {Gloucester MT Extra Condensed}
{Goudy Old Style} {Gujarati MT} {Gujarati Sangam MN} Gulim GungSeo {Gurmukhi MN}
{Gurmukhi MT} {Gurmukhi Sangam MN} Haettenschweiler {Hannotate SC} {Hannotate TC}
{HanziPen SC} {HanziPen TC} Harrington HeadLineA Hei {Heiti SC} {Heiti TC}
Helvetica {Helvetica CY} {Helvetica Neue} Herculanum {Hiragino Kaku Gothic Pro}
{Hiragino Kaku Gothic ProN} {Hiragino Kaku Gothic Std} {Hiragino Kaku Gothic StdN}
{Hiragino Maru Gothic Pro} {Hiragino Maru Gothic ProN}
{Hiragino Mincho Pro} {Hiragino Mincho ProN} {Hiragino Sans GB}
{Hoefler Text} Impact {Imprint MT Shadow} InaiMathi {Iowan Old Style} Kai Kailasa
{Kaiti SC} {Kaiti TC} {Kannada MN} {Kannada Sangam MN} Kefa {Khmer MN} {Khmer Sangam MN}
{Kino MT} Kokonor Krungthep KufiStandardGK {Lantinghei SC} {Lantinghei TC} {Lao MN}
{Lao Sangam MN} {Libian SC} {LiHei Pro} {LiSong Pro} {Lucida Blackletter} {Lucida Bright}
{Lucida Calligraphy} {Lucida Console} {Lucida Fax} {Lucida Grande} {Lucida Handwriting}
{Lucida Sans} {Lucida Sans Typewriter} {Lucida Sans Unicode} {Malayalam MN}
{Malayalam Sangam MN} Marion {Marker Felt} Marlett {Matura MT Script Capitals}
Meiryo Menlo {Microsoft Sans Serif} Mishafi Mistral {Modern No. 20} Monaco {MS Gothic}
{MS Mincho} {MS PGothic} {MS PMincho} {MS Reference Sans Serif} {MS Reference Specialty}
Mshtakan {MT Extra} Muna {Myanmar MN} {Myanmar Sangam MN} Nadeem {Nanum Brush Script}
{Nanum Gothic} {Nanum Myeongjo} {Nanum Pen Script} {New Peninim MT} {News Gothic MT}
Noteworthy Onyx Optima {Oriya MN} {Oriya Sangam MN} Osaka Palatino {Palatino Linotype}
Papyrus PCMyungjo Perpetua {Perpetua Titling MT} PilGi {Plantagenet Cherokee}
Playbill PMingLiU {PT Mono} {PT Sans} {PT Sans Caption} {PT Sans Narrow} {PT Serif}
{PT Serif Caption} Raanana Rockwell {Rockwell Extra Bold} Sana Sathu {Savoye LET}
Seravek Silom SimSun {Sinhala MN} {Sinhala Sangam MN} Skia {Snell Roundhand} {Songti SC}
{Songti TC} Stencil STFangsong STHeiti STIXGeneral STIXIntegralsD STIXIntegralsSm
STIXIntegralsUp STIXIntegralsUpD STIXIntegralsUpSm STIXNonUnicode STIXSizeFiveSym
STIXSizeFourSym STIXSizeOneSym STIXSizeThreeSym STIXSizeTwoSym STIXVariants STKaiti
STSong Superclarendon Symbol Tahoma {Tamil MN} {Tamil Sangam MN} TeamViewer8 {Telugu MN}
{Telugu Sangam MN} Thonburi Times {Times New Roman} {Trebuchet MS} {Tw Cen MT} Verdana
Waseem {Wawati SC} {Wawati TC} Webdings {Weibei SC} {Weibei TC} {Wide Latin} Wingdings
{Wingdings 2} {Wingdings 3} {Xingkai SC} {Yuanti SC} YuGothic YuMincho {Yuppy SC}
{Yuppy TC} {Zapf Dingbats} Zapfino {Apple Braille} {Apple Chancery} {Apple Color Emoji}
{Apple LiGothic} {Apple LiSung} {Apple SD Gothic Neo} {Apple Symbols}
AppleGothic AppleMyungjo {Monotype Corsiva} {Monotype Sorts}

O widget de imagem é usado para criar e manipular imagens. A sintaxe para a criação de imagens é a seguinte -

image create type name options

Na sintaxe acima, o tipo é foto ou bitmap e o nome é o identificador da imagem.

Opções

As opções disponíveis para a criação de imagens estão listadas abaixo na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	-file fileName O nome do arquivo de imagem.
2	-height number Usado para definir a altura do widget.
3	-width number Define a largura do widget.
4	-data string Imagem em string codificada em base 64.

Um exemplo simples de widget de imagem é mostrado abaixo -

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/Desktop/F Drive/pictur/vb/Forests/
   680049.png" -width 400 -height 400 
pack [label .myLabel]
.myLabel configure -image imgobj

Quando executarmos o programa acima, obteremos a seguinte saída -

As funções disponíveis para imagens estão listadas abaixo na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	image delete imageName Exclui a imagem da memória e widgets relacionados visualmente.
2	image height imageName Retorna a altura da imagem.
3	image width imageName Retorna a largura da imagem.
4	image type imageName Retorna o tipo de imagem.
5	image names Retorna a lista de imagens ao vivo na memória.

Um exemplo simples para usar os comandos de widget de imagem acima é mostrado abaixo -

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/images/680049.png"
   -width 400 -height 400 
pack [label .myLabel]
.myLabel configure -image imgobj
puts [image height imgobj]
puts [image width imgobj]
puts [image type imgobj]
puts [image names]
image delete imgobj

A imagem será excluída visualmente e da memória assim que o comando "image delete imgobj" for executado. No console, a saída será como a seguinte -

400
400
photo
imgobj ::tk::icons::information ::tk::icons::error ::tk::icons::
warning ::tk::icons::question

Os eventos em sua forma mais simples são tratados com a ajuda de comandos. Um exemplo simples de manipulação de eventos é a manipulação de eventos com botão e é mostrado abaixo -

#!/usr/bin/wish

proc myEvent { } {
   puts "Event triggered"
}
pack [button .myButton1  -text "Button 1"   -command myEvent]

Quando executarmos o programa acima, obteremos a seguinte saída -

Um programa simples para mostrar evento de animação de texto de atraso é mostrado abaixo -

#!/usr/bin/wish

proc delay {} {
   for {set j 0} {$j < 100000} {incr j} {} 
}

label .myLabel -text "Hello................" -width 25
pack .myLabel
set str "Hello................"
for {set i [string length $str]} {$i > -2} {set i [expr $i-1]} { .myLabel configure -text [string range $str 0 $i]
   update
   delay
}

Quando executarmos o programa, obteremos a seguinte saída de forma animada -

Evento após atraso

A sintaxe para evento após atraso é mostrada abaixo -

after milliseconds number command

Um programa simples para mostrar após o evento de atraso é mostrado abaixo -

#!/usr/bin/wish

proc addText {} {
   label .myLabel -text "Hello................" -width 25
   pack .myLabel
}
after 1000 addText

Quando executamos o programa, obteremos a seguinte saída após um segundo -

Você pode cancelar um evento usando o comando after cancel conforme mostrado abaixo -

#!/usr/bin/wish

proc addText {} {
   label .myLabel -text "Hello................" -width 25
   pack .myLabel
}
after 1000 addText
after cancel addText

Vinculação de evento

A sintaxe para associação de evento é mostrada abaixo -

bind arguments

Exemplo de eventos de teclado

#!/usr/bin/wish

bind .  {puts "Key Pressed: %K "}

Quando executamos o programa e pressionamos a letra X, obteremos a seguinte saída -

Key Pressed: X

Exemplo de eventos de mouse

#!/usr/bin/wish

bind .  {puts "Button %b Pressed : %x %y "}

Quando executamos o programa e pressionamos o botão esquerdo do mouse, obteremos uma saída semelhante à seguinte -

Button 1 Pressed : 89 90

Vinculando eventos com exemplo de botão

#!/usr/bin/wish

proc myEvent { } {
   puts "Event triggered"
}
pack [button .myButton1  -text "Button 1"   -command myEvent]
bind .  ".myButton1 invoke"

Quando executamos o programa e pressionamos enter, obteremos a seguinte saída -

Event triggered

O gerenciador de janelas é usado para controlar a janela de nível superior. Ele ajuda a controlar o tamanho, a posição e outros atributos da janela. Em Tk,. é usado para se referir à janela principal. A sintaxe para o comando da janela é mostrada abaixo -

wm option window arguments

A lista de opções disponíveis para o comando Tk wm é mostrada na tabela a seguir -

Sr. Não.	Sintaxe e descrição
1	aspect windowName a b c d Tenta manter a relação largura / altura entre a / be c / d.
2	geometry windowName geometryParams Use para definir a geometria da janela.
3	grid windowName w h dx dy Define o tamanho da grade.
4	group windowName leaderName leaderName fornece o líder de um grupo de janelas relacionadas.
5	deiconify windowName Traz a tela ao normal, se minimizada.
6	iconify windowName Minimiza a janela.
7	state windowName Retorna o estado atual da janela.
8	withdraw windowName Desmapa a janela e remove seus detalhes da memória.
9	iconbitmap windowName image Define ou retorna o bitmap do ícone.
10	iconPhoto windowName image Define ou retorna a foto do ícone.
11	command windowName commandString Registra o comando de inicialização na propriedade WM_COMMAND.
12	protocol windowName arguments Registre um comando para lidar com o nome da solicitação de protocolo, que pode ser WM_DELETE_WINDOW, WM_SAVE_YOURSELF, WM_TAKE_FOCUS. Ex: protocolo wm. WM_DELETE_WINDOW Sair.
13	minsize windowName size Determina o tamanho mínimo da janela.
14	maxsize windowName size Determina o tamanho máximo da janela.
15	title windowName titleText Determina o título da janela.
16	attributes subOptions Existem muitos atributos disponíveis, como alfa, tela inteira e assim por diante.

Alguns dos comandos acima são usados no exemplo a seguir -

#!/usr/bin/wish

wm maxsize . 800 800
wm minsize . 300 300
wm title . "Hello"
wm attributes . -alpha ".90" 
wm geometry . 300x200+100+100

Quando executarmos o programa acima, obteremos a seguinte saída -

Como você pode ver, alpha é um dos atributos disponíveis. A lista de subcomandos comumente usados está listada abaixo -

Sr. Não.	Sintaxe e descrição
1	-alpha number Define o alfa para a janela.
2	-fullscreen number O número pode ser 0 para tela normal ou 1 para tela inteira.
3	-topmost number Define ou retorna se a janela é superior. O valor pode ser 0 ou 1.

Criando janela

Podemos usar o comando de nível superior para criar janela e um exemplo é mostrado abaixo -

#!/usr/bin/wish

toplevel .t

Quando executarmos o programa acima, obteremos a seguinte saída -

Janela de destruição

Podemos usar o comando destroy para destruir a janela e um exemplo é mostrado abaixo -

#!/usr/bin/wish

destroy .t

O comando acima irá destruir a janela chamada .t.

O gerenciador de geometria é usado para gerenciar a geometria da janela e outras molduras. Podemos usá-lo para controlar a posição e o tamanho da janela e das molduras. Os widgets de layout são usados para essa finalidade.

Posicionamento e dimensionamento

A sintaxe para posicionamento e dimensionamento da janela é mostrada abaixo -

wm geometry . wxh+/-x+/-y

Aqui, w se refere à largura eh se refere à altura. É seguido por um sinal '+' ou '-' com o número seguinte referindo-se à posição x na tela. Da mesma forma, o seguinte sinal '+' ou '-' com um número se refere à posição y na tela

Um exemplo simples é mostrado abaixo para a Declaração acima -.

#!/usr/bin/wish

wm geometry . 300x200+100+100

Quando executarmos o programa acima, obteremos a seguinte saída -

Geometria de grade

A sintaxe para a geometria da grade é mostrada abaixo -

grid gridName -column number -row number -columnspan number -rowspan number

A coluna, linha, coluna ou linha ajuda a fornecer a geometria da grade.

Um exemplo simples é mostrado abaixo para a declaração acima -

#!/usr/bin/wish

frame .myFrame1 -background red  -height 100 -width 100
frame .myFrame2 -background blue -height 100 -width 50
grid .myFrame1 -columnspan 10 -rowspan 10 -sticky w
grid .myFrame2 -column 10 -row 2

Quando executarmos o programa acima, obteremos a seguinte saída -