TCL TK Tutorial: Tool Command Language

Vad är TCL?

TCL är ett skalprogram som läser TCL-kommandot från dess standardinmatning eller från en fil och ger önskade resultat.

TCL är ett strängbaserat skriptspråk och även ett procedurspråk. Det skapades först av John Osterhout 1989. Syftet med att utveckla detta språk är lätta inbäddade inti ( ) applikationer. Språket används ofta för GUI och testning. Till exempel snabb prototypframställning, Testning databasinteraktion, etc. I TCL är allt som standard en sträng.

I den här handledningen kommer du att lära dig-

• Vad är TCL
• Hur man kör TCL
• TCL-skript
• TCL-ersättningstyp
• TCL-variabel
• TCL Expression och Operator
• TCL flödeskontroll och beslutsfattande

Hur man kör TCL

Det finns två sätt att exekvera TCL-kod

1. Windows baserad applikation finns tillgänglig här tcltutor exe-fil
2. Linux-baserad applikation

In Linux interaktiv tolk, kan vi köra TCL-skripten enligt nedan

För att komma åt den interaktiva TCL-sessionen, kör följande kommando

TCL-skript

TCL-programmet bör ha filtillägget .tcl. Varje skript i UNIX/LINUX börjar med TCL-skalsökväg

#!/usr/bin/tclsh

Exempel:-

#!/usr/bin/tclsh
Puts "Hello World"
Script execution:-
$ chmod +x helloworld.tcl
$ ./helloworld.tcl

Produktion: Hej världen

I TCL används kommandot "Puts" för att skriva ut meddelanden till konsolen. Syntax för puts är nedan

sätter?-nonewline? ?kanal-ID? sträng

• Ingen ny linje: Denna valfria parameter undertrycker nyradstecknet som standardkommando. Det sätter en ny linje till varje sträng
• Channelid: Denna parameter används för standard ingångskanal (stdin) och standardutgångskanal (stdout).

Ex:-

%puts "Hello World"
% Hello World
%puts stdout  "Hello World"
% Hello World

TCL-ersättningstyp

Det finns tre typer av substitutioner i TCL

1. Kommandosubstitution
2. Variabel substitution
3. Backslash substitution

Låt oss studera en efter en

Kommandosubstitution

Hakparenteser används för kommandosubstitution.

Exempel:-

% puts [expr 1*3]
% 3

Här utvärderas kommandot mellan hakparenteserna först. Resultaten returneras .”expr” som används för att utföra den aritmetiska beräkningen.

Variabel substitution

TCL utför variabel substitution med hjälp av $ skylt.

Exempel:-

#!/usr/bin/tclsh
set  a  10
puts  a
puts  $a 

Här skapar vi en variabel som heter "a" och sätter värdet "10" till den.

• sätter ett : Det kommer att skriva ut strängen "a" men inte värdet på "a" till konsolen
• sätter $a : Det kommer att skriva ut värdet på 'a' till konsolen

Låt oss köra och verifiera det. Du kommer att få utdata enligt nedan.

$ ./substitution.tcl

a

10

Backslash substitution

I Tcl används omvänt snedstreck för att undvika specialtecken samt för att sprida långa kommandon över flera rader. Alla tecken som följer omedelbart efter snedstrecket kommer att stå utan ersättning. I exemplet nedan kan du se specialtecknet ” ”, som finns kvar efter omvänt snedstreck.

Låt oss verifiera detta med ett exempel

#!/usr/bin/tclsh

puts "This  is my  \"car\"

$ ./backslashsubstitution.tcl
This is my "car"

NOTERA: -För att kommentera någon sträng i TCL används "#". Alla tecken efter "#" ignoreras av tclsh-skalkommandot.

TCL-variabel

En variabel är en identifierare som har ett värde. En variabel är med andra ord en referens till ett datorminne, där värdet lagras.

Variabler skapas av "set command" och alla variabelnamn är skiftlägeskänsliga. Det betyder hej, hej, HEJ alla är olika i TCL. Titta på några exempel för skiftlägeskänsliga variabler.

% set  name  Techoit
% set  Name  Technoit_1
% set  NAME  Technoit_2

Produktion:-

% puts $name
% Technoit

%puts  $Name
%Technoit_1

%puts $NAME
%Technoit_2

Skapa TCL-variabler

För att skapa variabler i TCL måste du använda "uppsättning" kommando

Sätt en 10:a

För att få värdet på variabeln måste du använda "$" symbol som

% satte $a

% 10

Så vi får värdet på variabel 'a' som 10.

TCL-kommandoinformation finns

Kommandot "set" används för att skapa och läsa variabler som visas ovan. Kommandot unset används för att förstöra en variabel. Kommandot "info exists" returnerar 1 om varName finns som en variabel (eller ett arrayelement) i det aktuella sammanhanget, annars returnerar 0. (se exempel nedan).

Det finns olika "info"-kommandon i TCL som "info existerar", "info-funktioner", "info global" och så vidare. Här kommer vi att se ett exempel på "info existerar".

Ex:-

% set a 20
% puts $a
% 20
% puts [info exists a]
% 1
% unset a
%puts [info exists a]
% 0

Olika hängslen och deras beteende

{} -> Lockiga hängslen

Lockiga klammerparenteser i TCL grupperar ord tillsammans för att bli argument. Lockiga klammerparenteser används för att definiera ett block som är uppskjutet – med andra ord kan det köras EFTER resten av kommandot på den aktuella raden. Tecken inom klammerparenteser skickas till ett kommando exakt som det är skrivet.

Några punkter att komma ihåg

1. Variabelsubstitution är inte tillåten inom {} klammerparenteser
2. Det används för att skapa listdatatyp

Exempel:-

% set x 10
% puts {$x}
% $x

%set nummer {1 2 3 4 5} -> Här är nummer en listdatatyp

% sätter $nummer

%1 2 3 4 5

[] -> fyrkantiga hängslen

Hakparenteser används för att skapa kapslade kommandon. Enkelt uttryckt, utdata från ett kommando skickas som argument till ett annat kommando. Hakparenteser används för att definiera ett block som körs FÖRE resten av kommandot på den aktuella raden, och resultatet ersätts i raden.

Ex: –

% set x 10
% puts "y : [set y [set x 10]]"
%y : 10
% puts "x : $x"
%x : 10

() -> runda hängslen

Detta kommando används för att skapa arraydatatyp och även indikera operatörsprioritet.

% set a(1) 10
% set a(2) 20

Här är "a" en array med värden 10 och 20. Se nedan kommandon för att skriva ut nycklar, nyckelvärdespar och värden för 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

För att skriva ut "N:te" värdet för array a kommer vi att använda Puts $a(N)

TCL Kommandoradsargument

Dataobjekt som skickas till ett skript från kommandoraden kallas argument. Antalet kommandoradsargument till ett Tcl-skript skickas som den globala variabeln argc . Namnet på ett Tcl-skript skickas till skriptet som den globala variabeln argv0 , och resten av kommandoradsargumenten skickas som en lista i argv.

TCL har 3 fördefinierade variabler som t.ex

$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

produktion:-

• Antal argument som skickas till skripten: 3
• Lista över argument skickas till skriptet: 10 20 30
• Namnet på skriptet är: arg-script.tcl

TCL Expression och Operator

Uttryck är konstruerat från operander och operatorer. Det utvärderas med kommandot "expr". Operators utvärderas utifrån företräde och associativitet. TCL-språket har inbyggda operatörer enligt nedan

Operator kategori	Symbol	Företräde/Associativitet
Aritmetik Operator	+ - * / %	Vänster till höger
Relations Operator	== != < > <= >=	Vänster till höger
logisk Operator	&& || !	Vänster till höger
bitvis Operator	& | ^ ~	Vänster till höger
Ternära Operator	?:	Höger till vänster
Shift Operator	<< >>	Vänster till höger
Strängjämförelse Operator	eq ne	Vänster till höger
exponentiering Operator	**	Vänster till höger
Lista Operator	I ni	Vänster till höger

Aritmetik Operator

Ett TCL-uttryck består av en kombination av operander, operatorer och parenteser. Låt oss se exempel på aritmetiska operatorer i TCL

+ Lägg till två eller fler operander

Ex:-

%set a 10 
%set b 20
%puts [expr $a + $b]
30

- Subtraherar två eller flera operander

Ex:-

%set a 20 
%set b 10
%puts [expr $a - $b]
10

*Multiplicera två eller flera operander

%set a 20 
%set b 10
%puts [expr $a * $b]
200

/ Dela täljare med täljare

%set a 20 
%set b 10
%puts [expr $a / $b]
2

% Modulus operator delar täljare med täljare men returnerar påminnelse

%set a 20 
%set b 10
%puts [expr $a % $b]
0

Relations Operator

Kontrollerar om värdet på vänster operand är större än värdet på den högra operanden. Om ja, då blir villkoret sant och returnerar 1 annars returnerar 0.

%set a 20 
%set b 10
%puts [expr $a > $b]
1

Kontrollera om värdet på vänster operand är mindre än värdet på den högra operanden. Om ja, blir villkoret sant och returnerar 1 annars returnerar 0

%set a 10 
%set b 20
%puts [expr $a < $b]
1

>= Kontrollerar om värdet på vänster operand är större än eller lika med värdet på höger operand, om ja så blir villkoret sant och returnerar 1 annars returnerar 0

%set a 20 
%set b 10
%puts [expr $a >= $b]
1

<= Kontrollerar om värdet på vänster operand är mindre än eller lika med värdet på höger operand, om ja blir villkoret sant och returnerar 1 annars returnerar 0

%set a 20 
%set b 10
%puts [expr $a <= $b]
0

!= Kontrollerar om värdena för två operander är lika eller inte, om värdena inte är lika blir villkoret sant och returnerar 1 annars returnerar 0

%set a 20 
%set b 10
%puts [expr $a != $b]
1

== Kontrollerar om värdena för två operander är lika eller inte, om ja så blir villkoret sant och returnerar 1 annars returnerar 0

%set a 20 
%set b 10
%puts [expr $a == $b]
0

logisk Operator

&& Om båda operanderna inte är noll, blir villkoret sant och returnerar 1 annars returnerar 0

%set a 20 
%set b 10
%puts [expr $a && $b]
1

|| Om någon av de två operanderna inte är noll, blir villkoret sant och returnerar 1 annars returnerar 0

%set a 0 
%set b 10
%puts [expr $a || $b]
1

! Används för att vända resultatet av ett uttryck. Här i utgången kan du se att värdet på 'a' nu har blivit 1 från 0. Medan värdet på 'b' har blivit 0 från 1.

%set a 0 
%set b 1
%puts [expr !$a]
1
%puts [expr !$b]
0

bitvis Operator

& (bitvis och) utför bit för bit operation och följ tabellen nedan för operation.

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 

| (bitvis eller) utför bit för bit operation och följ tabellen nedan

A	B	A | 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 

^ (bitvis exklusiv eller) utför bit för bit operation och följ tabellen nedan

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

~ (bitvis negation) operatorn ändrar varje 1 till 0 och 0 till 1, följ tabellen som referens

A	~A
0	1
1	0

%set A 7
%puts [expr ~$A]
-8

Ternära Operator (?:)

Syntax är

condition-expression?  expression_1: expression_2

Om villkor-exp är sant, utvärderas exp1 och resultatet returneras. Om cond-exp är falskt utvärderas exp2 och dess resultat returneras. I vårt exempel är exp1 sant eftersom värdet på A är större än 6.

%set A 7
%set result [expr $A > 6 ? true : false]
%puts $result
true

Shift Operator

Shift operatör betecknas antingen med << vänster skiftoperatör eller med >> höger skiftoperatör. För << vänsterskiftsoperator flyttas värdet för vänster operander åt vänster med antalet bitar som anges av den högra operanden.

%set A 7
%set result [expr $A << 2]
%puts $result

För högerskiftoperatorn >> flyttas det vänstra operandens värde åt höger med antalet bitar som anges av den högra operanden.

%set A 7
%set result [expr $A >> 2]
%puts $result

Strängjämförelse Operator

Strängjämförelseoperator jämför värdet av båda operanderna. Om värdet på operanden är detsamma, kommer den att returnera 1 annars returnerar 0. I exempel är värdet för både A och B 7, därför returnerar resultatet 1.

Ex:-

%set A 7 
%set B 7
%set result [expr $A eq $B]
%puts $result
1

Ne (om värdet på båda operanderna är olika kommer det att returnera 1 annars returnerar 0)

%set A 7 
%set B 8
%set result [expr $A ne $B]
%puts $result
1

Exponentieringsoperator

Pow () och ** båda är samma. Det returnerar alltid flytande värde.

** indikerar kraften till önskad operand.

Ex:-

%set A 7
%set result [expr $A ** 2]
%puts $result
49

Lista Operator

Om det önskade värdet finns i den definierade listan, returnerar det 1 annars returnerar 0. I exemplet finns värde 1 i variabeln 'a' och returnerar därför 1.

set a {1 2 3}
if {1 in $a} {
puts "ok"
} else {
puts "fail"
}
Output: ok

ni, om det önskade värdet finns i den definierade listan kommer det att returnera 0 annars returnerar 1.

Ex:-

set a {1 2 3}
if {1 ni $a} {
puts "ok"
} else {
puts "fail"
}
Output: fail

TCL flödeskontroll och beslutsfattande

Det finns olika flödeskontroll och beslutsfattande kommandon som används för att ändra flödet av ett program. Programkörningar börjar alltid från toppen av källfilen till botten.

If-satsen består av booleskt uttryck följt av ett eller flera satser.

Om ... uttalande

Syntax:-

om expr ?då? kropp

om expr utvärderas till sant, så exekveras kommandokroppen.

Ex:-

set age 10

if {$age < 20} {
puts "Age is less than 20"
}

Output: Age is less than 20

Om ... annat uttalande

Syntax:-

Om uttryck? sedan body_1 else body_2

Om uttrycket utvärderas till sant kommer det att returnera body_1 annars returnerar det 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

Kapslad if..else-sats

Det betyder en if eller else..if-sats kan läggas in i en annan if eller else..if-satser.

Syntax:-

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

Byt uttalande

Switch-satsen gör att en variabel kan testas för likhet mot en lista med värden. Den utvärderar värdelistan och returnerar resultatet av den utvärderingen. Om inga värden matchar kommer standardvärden att returneras.

Exempelvis:

#!/usr/bin/tclsh

# switch_cmd.tcl

set domain x
switch $domain {

    x { puts "x" }
    y { puts "y" }
    z { puts "z" }
    default { puts "unknown" }
}

Kapslad strömbrytare

Kapslad switch-sats betyder switch-sats inuti en switch-sats.

syntax :-

switch <switchingstring1> {
   <matchstring1> {
      body1
      switch <switchingstring2> {
        <matchstring2> {
           body2
         }
          ...
    switch <switchingstringN> {
          <matchStringN> {
           bodyN
         }
      }
   }

Exempelvis: I följande exempel är värdet på a 100, och med samma kod byter vi sats för ett annat värde på b är 200. Out kommer att visa värdet för både a och 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"
        }
     }
   }   
}

Produktion:-

Värdet på a är 100

Värdet på b är 200

TCL Loop uttalande

Loop-sats gör det möjligt att köra en sats eller grupp av satser flera gånger. Tcl tillhandahåller följande typer av looping-sats.

Medan kommando

När ett givet villkor är sant upprepas ett påstående eller en grupp av påståenden som finns i loopkroppen.

syntax:

While  {condition} {
    Statements
}

Ex:-

#!/usr/bin/tclsh

Set a 10

While {$a < 12} {
    Puts "a is $a"
    incr a
}

Produktion:-

a är 10

a är 11

I exemplet ovan används det inbyggda kommandot "incr". Det betyder att värdet på 'a' kommer att ökas med 1 till maxvärdet (<12).

För kommando

Den exekverar en sekvens av satser flera gånger baserat på ett räknarvärde. Den ökas eller minskas automatiskt under varje upprepning av slingan.

syntax :-

For {start} {test} {next} {
Body
}

Exempelvis: I exemplet nedan är värdet på 'i' satt till 0 och inkrementerat till värdet <5.

#!/usr/bin/tclsh

for {set i 0} {$i < 5} {incr i} {
put $i
}

Produktion:-

0 
1 
2 
3 
4

Sammanfattning:

• TCL är ett strängbaserat skriptspråk och även ett procedurspråk
• Språket används ofta för GUI och testning
• I TCL är allt som standard sträng
• TCL är ett skalprogram som läser TCL-kommandot från dess standardinmatning eller från en fil och ger önskade resultat.
• TCL-programmet bör ha .tcl-tillägget