Tutorial TCL TK: linguagem de comando de ferramenta
Emily Carter
O que é TCL?
TCL é um aplicativo shell que lê o comando TCL de sua entrada padrão ou de um arquivo e fornece os resultados desejados.
TCL é uma linguagem de script baseada em strings e também uma linguagem processual. Foi criado pela primeira vez por John Osterhout em 1989. O objetivo do desenvolvimento desta linguagem são aplicativos inti () facilmente incorporados. A linguagem é comumente usada para GUIs e testes. Por exemplo, prototipagem rápida, Ensaios interação com banco de dados, etc. No TCL, por padrão, tudo é uma string.
Neste tutorial, você aprenderá
- O que é TCL
- Como executar o TCL
- Scripts TCL
- Tipo de substituição TCL
- Variável TCL
- Expressão TCL e Operator
- Controle de fluxo TCL e tomada de decisão
Como executar o TCL
Existem duas maneiras de executar o código TCL
- Windows aplicativo baseado está disponível aqui arquivo tcltutorexe
- Aplicativo baseado em Linux
In Linux interpretador interativo, podemos executar os scripts TCL conforme abaixo
Para acessar a sessão interativa TCL, execute o seguinte comando
Scripts TCL
O programa TCL deve ter uma extensão .tcl. Cada script no UNIX/LINUX começa com o caminho do shell TCL
#!/usr/bin/tclsh
Exemplo:-
#!/usr/bin/tclsh Puts "Hello World" Script execution:- $ chmod +x helloworld.tcl $ ./helloworld.tcl
saída: Olá Mundo
No TCL, o comando “Puts” é usado para imprimir mensagens no console. A sintaxe de puts está abaixo
coloca?-nonewline? ?canalId? corda
- Nenhuma nova linha: este parâmetro opcional suprime o caractere de nova linha por comando padrão. Ele coloca uma nova linha para cada string
- ID do canal: Este parâmetro é usado para canal de entrada padrão (stdin) e canal de saída padrão (stdout).
Ex:-
%puts "Hello World" % Hello World %puts stdout "Hello World" % Hello World
Tipo de substituição TCL
Existem três tipos de substituições no TCL
- Substituição de comando
- Substituição de variável
- substituição de barra invertida
Vamos estudar um por um
Substituição de comando
Colchetes são usados para substituição de comandos.
Exemplo:-
% puts [expr 1*3] % 3
Aqui o comando entre colchetes é avaliado primeiro. O resultado é retornado .”expr” usado para realizar o cálculo aritmético.
Substituição de variável
TCL realiza substituição de variáveis com a ajuda de $ placa.
Exemplo:-
#!/usr/bin/tclsh set a 10 puts a puts $a
Aqui criamos uma variável chamada “a” e definimos o valor “10” para ela.
- coloca a: imprimirá a string “a”, mas não o valor de 'a' no console
- puts $a : Irá imprimir o valor de 'a' no console
Vamos executar e verificar. Você obterá a saída conforme abaixo.
$ ./substitution.tcl
a
10
substituição de barra invertida
No Tcl, a barra invertida é usada para escapar de caracteres especiais, bem como para espalhar comandos longos por múltiplas linhas. Qualquer caractere imediatamente após a barra invertida permanecerá sem substituição. No exemplo abaixo, você pode ver o caractere especial ““, permanece após a barra invertida.
Vamos verificar isso com um exemplo
#!/usr/bin/tclsh puts "This is my \"car\" $ ./backslashsubstitution.tcl This is my "car"
NOTA: -Para comentar qualquer string em TCL é usado “#”. Todos os caracteres após “#” são ignorados pelo comando shell tclsh.
Variável TCL
Uma variável é um identificador que contém um valor. Em outras palavras, uma variável é uma referência à memória do computador, onde o valor é armazenado.
As variáveis são criadas pelo “comando set” e todos os nomes de variáveis diferenciam maiúsculas de minúsculas. Significa olá, olá, OLÁ, todos são diferentes no TCL. Veja algum exemplo de variável que diferencia maiúsculas de minúsculas.
% set name Techoit % set Name Technoit_1 % set NAME Technoit_2
Resultado:-
% puts $name % Technoit %puts $Name %Technoit_1 %puts $NAME %Technoit_2
Criando Variáveis TCL
Para criar variáveis em TCL, você precisa usar "definir" comando
conjunto de 10
Para obter o valor da variável deve-se usar o símbolo “$” como
% colocar $a
10%
Portanto, obtemos o valor da variável 'a' como 10.
Existem informações de comando TCL
O comando “set” é usado para criar e ler variáveis conforme mostrado acima. O comando unset é usado para destruir uma variável. O comando “info exist” retorna 1 se varName existir como uma variável (ou um elemento de array) no contexto atual, caso contrário retorna 0. (veja o exemplo abaixo).
Existem vários comandos “info” no TCL, como “informações existem”, “funções de informações”, “informações globais” e assim por diante. Aqui veremos um exemplo de “informações existem”.
Ex:-
% set a 20 % puts $a % 20 % puts [info exists a] % 1 % unset a %puts [info exists a] % 0
Diferentes aparelhos e seu comportamento
{} -> Chaves
Chaves em TCL agrupam palavras para se tornarem argumentos. Chaves são usadas para definir um bloco que é adiado – em outras palavras, ele pode ser executado APÓS o restante do comando na linha atual. Os caracteres entre colchetes são passados para um comando exatamente como estão escritos.
Alguns pontos para lembrar
- A substituição de variáveis não é permitida entre {} colchetes
- É usado para criar o tipo de dados de lista
Exemplo:-
% set x 10
% puts {$x}
% $x
%set number {1 2 3 4 5} -> Aqui number é um tipo de dados de lista
%coloca $número
% 1 2 3 4 5
[] -> colchetes
Colchetes são usados para criar comandos aninhados. Simplificando, a saída de um comando é passada como argumento para outro comando. Colchetes são usados para definir um bloco que é executado ANTES do resto do comando na linha atual, e o resultado é substituído na linha.
Exemplo: –
% set x 10 % puts "y : [set y [set x 10]]" %y : 10 % puts "x : $x" %x : 10
() -> colchetes redondos
Este comando é usado para criar o tipo de dados array e também indicar a precedência do operador.
% set a(1) 10 % set a(2) 20
Aqui “a” é um array com valores 10 e 20. Veja abaixo os comandos para imprimir chaves, pares de valores-chave e valores do array.
% puts [array get a] -> To print key value pairs we use this command % 1 10 2 20 % puts [array names a] -> To print only keys % 1 2 % puts $a(1) -> To print first value of array % 10 % puts $a(2) -> To print second value of array % 20
Para imprimir o “enésimo” valor do array a, usaremos Puts $a(N)
Argumentos de linha de comando TCL
Itens de dados passados para um script a partir da linha de comando são conhecidos como argumentos. O número de argumentos de linha de comando para um script Tcl é passado como variável global argumento . O nome de um script Tcl é passado para o script como a variável global argv0 , e o restante dos argumentos da linha de comando são passados como uma lista em argumento.
TCL tem 3 variáveis predefinidas, como
$argc -> indicates the number of arguments passed to the script $argv -> indicates list of arguments $argv0 -> indicates the name of script
Ex:-
arg-script.tcl #!/usr/bin/tclsh< puts "number of arguments passed to the scripts : $argc" puts "list of arguments are passed to the script: $argv" puts "the name of scripts is: $argv0"
$ ./arg-script.tcl 10 20 30
saída:-
- Número de argumentos passados para os scripts: 3
- Lista de argumentos passados para o script: 10 20 30
- O nome do script é: arg-script.tcl
Expressão TCL e Operator
Expressão é construída a partir de operandos e operadores. É avaliada com o comando "expr". OperaOs operadores são avaliados com base na precedência e associatividade. A linguagem TCL possui operadores integrados conforme abaixo
| Operacategoria | Símbolo | Precedência/Associatividade |
|---|---|---|
| Aritmética Operator | + - * /% | Esquerda para a Direita |
| Relacional Operator | == != < > <= >= | Da esquerda para direita |
| lógico Operator | && || ! | Da esquerda para direita |
| Bit a bit Operator | & | ^ ~ | Da esquerda para direita |
| Ternário Operator | ?: | Direita para esquerda |
| Shift Operator | << >> | Da esquerda para direita |
| Comparação de Strings Operator | eq não | Da esquerda para direita |
| Exponenciação Operator | ** | Da esquerda para direita |
| Lista Operator | Em nenhum | Da esquerda para direita |
Aritmética Operator
Uma expressão TCL consiste em uma combinação de operandos, operadores e parênteses. Vejamos um exemplo de operadores aritméticos em TCL
+ Adicione dois ou mais operandos
Ex:-
%set a 10 %set b 20 %puts [expr $a + $b] 30
- Subtrai dois ou mais operandos
Ex:-
%set a 20 %set b 10 %puts [expr $a - $b] 10
*Multiplique dois ou mais operandos
%set a 20 %set b 10 %puts [expr $a * $b] 200
/ Divida numerador por denumerador
%set a 20 %set b 10 %puts [expr $a / $b] 2
O operador % Módulo divide numerador por denumerador, mas retorna lembrete
%set a 20 %set b 10 %puts [expr $a % $b] 0
Relacional Operator
Verifica se o valor do operando esquerdo é maior que o valor do operando direito. Se sim, então a condição se torna verdadeira e retorna 1, caso contrário retorna 0.
%set a 20 %set b 10 %puts [expr $a > $b] 1
Verifique se o valor do operando esquerdo é menor que o valor do operando direito. Se sim, então a condição se torna verdadeira e retorna 1, caso contrário retorna 0
%set a 10 %set b 20 %puts [expr $a < $b] 1
>= Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim então a condição se torna verdadeira e retorna 1, caso contrário retorna 0
%set a 20 %set b 10 %puts [expr $a >= $b] 1
<= Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se sim, a condição se torna verdadeira e retorna 1, caso contrário, retorna 0
%set a 20 %set b 10 %puts [expr $a <= $b] 0
!= Verifica se os valores de dois operandos são iguais ou não, se os valores não forem iguais então a condição se torna verdadeira e retorna 1, caso contrário retorna 0
%set a 20 %set b 10 %puts [expr $a != $b] 1
== Verifica se os valores de dois operandos são iguais ou não, se sim então a condição se torna verdadeira e retorna 1, caso contrário retorna 0
%set a 20 %set b 10 %puts [expr $a == $b] 0
lógico Operator
&& Se ambos os operandos forem diferentes de zero, a condição se tornará verdadeira e retornará 1, caso contrário, retornará 0
%set a 20 %set b 10 %puts [expr $a && $b] 1
|| Se qualquer um dos dois operandos for diferente de zero, a condição se tornará verdadeira e retornará 1, caso contrário, retornará 0
%set a 0 %set b 10 %puts [expr $a || $b] 1
! Usado para reverter o resultado de qualquer expressão. Aqui na saída, você pode ver que o valor de 'a' agora passou de 1 para 0. Enquanto o valor de 'b' passou de 0 para 1.
%set a 0 %set b 1 %puts [expr !$a] 1 %puts [expr !$b] 0
Bit a bit Operator
& (bit a bit e) executa a operação bit a bit e segue a tabela abaixo para operação.
| A | B | A & B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
| 1 | 0 | 0 |
Ex:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 1 0 1 0 0 So now as per above tabular rules A & B will be 0 0 0 0 0 0 0 0
| (bit a bit ou) execute a operação bit a bit e siga a tabela abaixo
| A | B | Um | B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
Ex:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 1 0 1 0 0 So now as per above tabular rules A | B will be 0 0 0 1 1 1 1 0
^ (exclusivo bit a bit ou) execute a operação bit a bit e siga a tabela abaixo
| A | B | A^B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
Ex:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 à 0 0 0 1 0 1 0 0 So now as per above tabular rules A ^ B will be 0 0 0 1 1 1 1 0 à 30
O operador ~ (negação bit a bit) muda a cada 1 para 0 e 0 para 1, siga a tabela como referência
| A | ~A |
|---|---|
| 0 | 1 |
| 1 | 0 |
%set A 7 %puts [expr ~$A] -8
Ternário Operator (?:)
Sintaxe é
condition-expression? expression_1: expression_2
Se a condição-exp for verdadeira, exp1 será avaliada e o resultado será retornado. Se cond-exp for falso, exp2 é avaliado e seu resultado é retornado. No nosso exemplo, exp1 é verdadeiro porque o valor de A é maior que 6.
%set A 7 %set result [expr $A > 6 ? true : false] %puts $result true
Shift Operator
Shift operador é denotado pelo operador << deslocamento para a esquerda ou pelo operador >> deslocamento para a direita. Para o operador << deslocamento para a esquerda, o valor dos operandos da esquerda é movido para a esquerda pelo número de bits especificado pelo operando da direita.
%set A 7 %set result [expr $A << 2] %puts $result
Para o operador >> right shift, o valor dos operandos esquerdos é movido para a direita pelo número de bits especificado pelo operando direito.
%set A 7 %set result [expr $A >> 2] %puts $result
Comparação de Strings Operator
O operador de comparação de strings compara o valor de ambos os operandos. Se o valor do operando for o mesmo, ele retornará 1, caso contrário, retornará 0. No exemplo, o valor para A e B é 7, portanto, o resultado retornará 1.
Ex:-
%set A 7 %set B 7 %set result [expr $A eq $B] %puts $result 1
Ne (se o valor de ambos os operandos for diferente, ele retornará 1, caso contrário, retornará 0)
%set A 7 %set B 8 %set result [expr $A ne $B] %puts $result 1
Operador de exponenciação
Pow() e ** ambos são iguais. Ele sempre retorna um valor flutuante.
** indica a potência do operando desejado.
Ex:-
%set A 7 %set result [expr $A ** 2] %puts $result 49
Lista Operator
Se o valor necessário for encontrado na lista definida, ele retornará 1, caso contrário, retornará 0. No exemplo, o valor 1 existe na variável 'a', portanto, retornará 1.
set a {1 2 3}
if {1 in $a} {
puts "ok"
} else {
puts "fail"
}
Output: ok
ni, se o valor necessário for encontrado na lista definida, ele retornará 0, caso contrário, retornará 1.
Ex:-
set a {1 2 3}
if {1 ni $a} {
puts "ok"
} else {
puts "fail"
}
Output: fail
Controle de fluxo TCL e tomada de decisão
Existem vários comandos de controle de fluxo e tomada de decisão que são usados para alterar o fluxo de um programa. As execuções do programa sempre começam do início ao fim do arquivo de origem.
A instrução If consiste em uma expressão booleana seguida por uma ou mais instruções.
Se ... declaração
Sintaxe:-
se expr ?então? corpo
se expr for avaliado como verdadeiro, o corpo do comando será executado.
Ex:-
set age 10
if {$age < 20} {
puts "Age is less than 20"
}
Output: Age is less than 20
Declaração If...else
Sintaxe:-
Se expressão? então corpo_1 senão corpo_2
Se a expressão for avaliada como verdadeira, ela retornará body_1, caso contrário, retornará body_2
Ex:--
set age 10
if {$age < 20} {
puts "Age is less than 20"
} else {
Puts "Age is greater than 20"
}
output: Age is less than 20
Instrução if..else aninhada
Isso significa que uma instrução if ou else..if pode ser colocada dentro de outra instrução if ou else..if.
Sintaxe:-
If {expression_1} {
Body_1
If {expression_2} {
Body_2
}
}
Ex:--
set a 10
set b 20
if {$a == 10} {
# if expression_1 is true then it will go to expression_2
if {$b == 20} {
#if expression_2 is true then it will print the below string
puts "value of a is 10 and b is 20"
}
}
o/p: value of a is 10 and b is 20
Declaração de mudança
A instrução switch permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores. Avalia a lista de valores e retorna o resultado dessa avaliação. Se nenhum valor corresponder, os valores padrão serão retornados.
Exemplo:
#!/usr/bin/tclsh
# switch_cmd.tcl
set domain x
switch $domain {
x { puts "x" }
y { puts "y" }
z { puts "z" }
default { puts "unknown" }
}
Interruptor aninhado
Instrução switch aninhada significa instrução switch dentro de uma instrução switch.
Sintaxe :-
switch <switchingstring1> {
<matchstring1> {
body1
switch <switchingstring2> {
<matchstring2> {
body2
}
...
switch <switchingstringN> {
<matchStringN> {
bodyN
}
}
}
Exemplo: No exemplo a seguir, o valor de a é 100, e com o mesmo código trocamos a instrução para outro valor de b é 200. A saída mostrará o valor para a e b.
#!/usr/bin/tclsh
set a 100
set b 200
switch $a {
100 {
puts "The value of a is $a"
switch $b {
200 {
puts "The value of b is $b"
}
}
}
}
Resultado:-
O valor de a é 100
O valor de b é 200
Instrução de loop TCL
A instrução Loop permite executar uma instrução ou grupo de instruções várias vezes. Tcl fornece os seguintes tipos de instruções de loop.
Enquanto comando
Quando uma determinada condição é verdadeira, uma instrução ou grupo de instruções que estão no corpo do loop se repete.
Sintaxe:
While {condition} {
Statements
}
Ex:-
#!/usr/bin/tclsh
Set a 10
While {$a < 12} {
Puts "a is $a"
incr a
}
Resultado:-
um é 10
um é 11
No exemplo acima, o comando interno “incr” é usado. Isso significa que o valor de 'a' será aumentado em 1 até o valor máximo (<12).
Para comando
Ele executa uma sequência de instruções múltiplas vezes com base em um valor de contador. É aumentado ou diminuído automaticamente durante cada repetição do loop.
Sintaxe :-
For {start} {test} {next} {
Body
}
Exemplo: No exemplo abaixo, o valor de 'i' é definido como 0 e incrementado até o valor <5.
#!/usr/bin/tclsh
for {set i 0} {$i < 5} {incr i} {
put $i
}
Resultado:-
0 1 2 3 4
Resumo:
- TCL é uma linguagem de script baseada em strings e também uma linguagem processual
- A linguagem é comumente usada para GUIs e testes
- No TCL por padrão tudo é string
- TCL é um aplicativo shell que lê o comando TCL de sua entrada padrão ou de um arquivo e fornece os resultados desejados.
- O programa TCL deve ter extensão .tcl
