Tcl/TK-handledning

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 utvecklingenping Det här språket är enkelt att integrera i applikationer. Språket används ofta för grafiska gränssnitt och testning. Till exempel, snabb prototyputveckling.ping, Testning databasinteraktion, etc. I TCL är allt som standard en sträng.

Hur man kör TCL

Det finns två sätt att köra 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. Syntaxen för puts är nedan.

lägger ?-nonewline? ?channelId? strängen

• 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 inom hakparenteserna först. Resultatet returneras. ”uttryck” 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 bakåtsnedstrecket för escaping specialtecken samt för att sprida långa kommandon över flera rader. Alla tecken som följer direkt efter det omvända snedstrecket står kvar utan ersättning. I exemplet nedan kan du se specialtecknet " ", som står kvar efter det omvända snedstrecket.

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 innehåller ett värde. Med andra ord är en variabel 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 existerar som en variabel (eller ett arrayelement) i den aktuella kontexten, annars returnerar 0. (se exempel nedan).

Det finns olika ”info”-kommandon i TCL, som ”info exists”, ”info functions”, ”info global” och så vidare. Här ser vi ett exempel på ”info exists”.

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

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

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 skickas utdata från ett kommando 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 på 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

Uttrycket konstrueras 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

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

– Subtracts två eller fler 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 valfritt uttryck. Här i utdata 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.

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

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

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

%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örelseoperatorn jämför värdet på båda operanderna. Om operandens värde är samma returnerar den 1, annars returnerar den 0. I exemplet ä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 obligatoriska värdet hittas i den definierade listan returneras 1, annars returneras 0. I exemplet finns värde 1 i variabeln 'a', därför returneras 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 … annars 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
         }
      }
   }

ExempelvisI följande exempel är värdet på a 100, och med samma kod byter vi uttalande mot ett annat värde på b, som är 200. Utgången visar 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-satsen tillåter att en sats eller en grupp av satser körs flera gånger. Tcl tillhandahåller följande typer av looping uttalande.

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' ökas med 1 till det maximala värdet (<12).

För kommando

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

syntax :-

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

ExempelvisI exemplet nedan är värdet på 'i' satt till 0 och ökat tills värdet <5.

#!/usr/bin/tclsh

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

Produktion:-

0
1
2
3
4

Vanliga frågor