Tcl/Tk bemutató

Mi az a TCL?

A TCL egy shell-alkalmazás, amely kiolvassa a TCL parancsot a szabványos bemenetéről vagy egy fájlból, és megadja a kívánt eredményt.

A TCL egy karakterlánc alapú szkriptnyelv és egyben procedurális nyelv is. John Osterhout alkotta meg 1989-ben. A fejlesztés céljaping Ez a nyelv könnyen beágyazható alkalmazásokba. A nyelvet általában grafikus felhasználói felületekhez és teszteléshez használják. Például a gyors prototípusgyártáshoz.ping, Tesztelés adatbázis interakció, stb. A TCL-ben alapértelmezés szerint minden egy karakterlánc.

Hogyan kell végrehajtani a TCL-t

A TCL kód végrehajtásának két módja van:

1. Windows alapú alkalmazás itt érhető el tcltutor exe fájl
2. Linux alapú alkalmazás

In Linux interaktív értelmező segítségével a TCL szkripteket az alábbiak szerint tudjuk végrehajtani

A TCL interaktív munkamenet eléréséhez hajtsa végre a következő parancsot

TCL szkriptek

A TCL programnak .tcl kiterjesztéssel kell rendelkeznie. Minden UNIX/LINUX parancsfájl a TCL shell elérési útjával kezdődik

#!/usr/bin/tclsh

Példa:-

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

teljesítmény: Helló Világ

A TCL-ben a „Puts” parancs segítségével üzeneteket írhatunk ki a konzolra. A puts parancs szintaxisa az alábbiakban látható.

karakterláncot helyez el a ?-nonewline? ?channelId? karakterláncban

• Nonewline: Ez az opcionális paraméter alapértelmezett parancsként elnyomja az újsor karaktert. Minden karakterlánchoz új sort ír
• Channelid: Ez a paraméter a szabványos bemeneti csatornához (stdin) és a szabványos kimeneti csatornához (stdout) használatos.

Volt:-

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

TCL helyettesítési típus

A TCL-ben háromféle helyettesítés létezik

1. Parancscsere
2. Változó helyettesítés
3. Backslash helyettesítés

Tanulmányozzuk egyenként

Parancscsere

A szögletes zárójelek a parancsok helyettesítésére szolgálnak.

Példa:-

% puts [expr 1*3]
% 3

Itt a szögletes zárójelben lévő parancs kiértékelése történik először. Az eredmény visszaadásra kerül. Az „expr” kifejezés a számtani számítás végrehajtására szolgál.

Változó helyettesítés

A TCL változóhelyettesítést hajt végre a segítségével $ jel.

Példa:-

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

Itt létrehozunk egy „a” nevű változót, és beállítjuk a „10” értéket.

• a : Kiírja az „a” karakterláncot, de nem az „a” értékét a konzolra
• $a-t tesz: Kiírja az 'a' értékét a konzolra

Végezzük el és ellenőrizzük. A kimenetet az alábbiak szerint kapja meg.

$ ./substitution.tcl

a

10

Backslash helyettesítés

A Tcl-ben a fordított perjelet az esca billentyűhöz használjuk.ping speciális karakterek, valamint hosszú parancsok több sorra történő elosztása. A fordított perjelet közvetlenül követő karakterek helyettesítés nélkül érvényben maradnak. Az alábbi példában látható, hogy a „ “ speciális karakter a fordított perjel után marad.

Erősítsük meg ezt egy példával

#!/usr/bin/tclsh

puts "This  is my  \"car\""

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

JEGYZET: -A megjegyzéshez a TCL bármely karakterláncát „#” használjuk. A „#” utáni összes karaktert figyelmen kívül hagyja a tclsh shell parancs.

TCL változó

A változó egy azonosító, amely egy értéket tárol. Más szóval, a változó egy hivatkozás a számítógép memóriájára, ahol az érték tárolódik.

A változókat a „set parancs” hozza létre, és minden változónév megkülönbözteti a kis- és nagybetűket. Azt jelenti, hello, hello, HELLO minden más a TCL-ben. Nézzünk néhány példát a kis- és nagybetűk megkülönböztetésére.

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

Kimenet:-

% puts $name
% Technoit

%puts  $Name
%Technoit_1

%puts $NAME
%Technoit_2

TCL-változók létrehozása

Változók létrehozásához a TCL-ben kell használni "készlet" parancs

Állíts be egy 10-et

A változó értékének meghatározásához „$” szimbólumot kell használni

% tesz $a

% 10

Így az 'a' változó értékét 10-nek kapjuk.

A TCL parancsinformáció létezik

A „set” parancs a fentiekben látható módon változók létrehozására és olvasására szolgál. Az unset parancs a változók megsemmisítésére szolgál. Az „info exists” parancs 1-et ad vissza, ha a varName létezik változóként (vagy tömbelemként) az aktuális kontextusban, egyébként 0-t (lásd az alábbi példát).

A TCL-ben számos „info” parancs létezik, például az „info létezik”, az „info funkciók”, az „info globális” és így tovább. Itt egy példát fogunk látni az „info létezik” parancsra.

Volt:-

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

Különböző fogszabályzók és viselkedésük

{} -> Göndör fogszabályozó

A TCL-ben a kapcsos zárójelek argumentumokat alkotva csoportosítják a szavakat. A kapcsos zárójelek egy késleltetett blokk definiálására szolgálnak – más szóval, a parancs többi része UTÁN futtatható az aktuális sorban. A zárójelek között lévő karakterek pontosan úgy kerülnek átadásra a parancsnak, ahogyan leírva vannak.

Néhány pont, amit emlékezni kell

1. A változók helyettesítése nem megengedett {} kapcsos zárójelben
2. Lista adattípus létrehozására szolgált

Példa:-

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

%set number {1 2 3 4 5} -> Itt a szám egy lista adattípus

%felteszi $számot

%1 2 3 4 5

[] -> szögletes kapcsos zárójelek

A szögletes zárójeleket beágyazott parancsok létrehozására használjuk. Egyszerűen fogalmazva, egy parancs kimenete argumentumként kerül átadásra egy másik parancsnak. A szögletes zárójeleket használjuk egy olyan blokk definiálására, amely a parancs többi része ELŐTT fut le az aktuális sorban, és az eredmény behelyettesül a sorba.

Pl.: -

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

() -> kerek fogszabályozó

Ez a parancs a tömb adattípusának létrehozására szolgál, és az operátor elsőbbségét is jelzi.

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

Itt az „a” egy 10-es és 20-as értékű tömb. Lásd lentebb a kulcsok, kulcsértékpárok és tömbértékek nyomtatására vonatkozó parancsokat.

% 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

Az a tömb „N-edik” értékének kinyomtatásához az $a(N) elhelyezést fogjuk használni.

TCL parancssori argumentumok

A parancssorból a szkriptnek átadott adatelemeket argumentumoknak nevezzük. A Tcl-szkript parancssori argumentumainak száma globális változóként kerül átadásra argc. A Tcl-szkript neve globális változóként kerül átadásra a szkriptnek argv0, és a többi parancssori argumentum listaként kerül átadásra argv.

A TCL-nek 3 előre definiált változója van, mint pl

$argc   -> indicates the number of arguments passed to the script

$argv   -> indicates list of arguments

$argv0  -> indicates the name of script

Volt:-

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

teljesítmény:-

• A szkripteknek átadott argumentumok száma: 3
• Az argumentumok listája átadásra kerül a szkriptnek: 10 20 30
• A szkript neve: arg-script.tcl

TCL kifejezés és Operator

A kifejezés operandusokból és operátorokból épül fel. Kiértékelése az „expr” paranccsal történik. Operatorokat elsőbbség és asszociativitás alapján értékelnek. A TCL nyelv beépített operátorokkal rendelkezik az alábbiak szerint

Számtan Operator

A TCL kifejezés operandusok, operátorok és zárójelek kombinációjából áll. Nézzünk példát a TCL aritmetikai operátoraira

+ Két vagy több operandus hozzáadása

Volt:-

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

– Alulírotttrackét vagy több operandus

Volt:-

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

*Két vagy több operandus szorzása

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

/ Ossza el a számlálót a számlálóval

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

% Modulus operátor osztja a számlálót a denumerátorral, de emlékeztetőt ad vissza

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

Relációs Operator

Ellenőrzi, hogy a bal oldali operandus értéke nagyobb-e, mint a jobb oldali operandusé. Ha igen, akkor a feltétel igaz lesz, és 1-et ad vissza, máskülönben 0-t.

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

Ellenőrizze, hogy a bal oldali operandus értéke kisebb-e, mint a jobb oldali operandus értéke. Ha igen, akkor a feltétel igaz lesz, és 1-et ad vissza, máskülönben 0-t

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

>= Ellenőrzi, hogy a bal oldali operandus értéke nagyobb-e vagy egyenlő-e a jobb oldali operandus értékével, ha igen, akkor a feltétel igaz lesz, és 1-et ad vissza, különben 0-t ad vissza

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

<= Ellenőrzi, hogy a bal oldali operandus értéke kisebb-e vagy egyenlő-e a jobb oldali operandus értékével, ha igen, akkor a feltétel igaz lesz, és 1-et ad vissza, különben 0-t ad vissza

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

!= Ellenőrzi, hogy két operandus értéke egyenlő-e vagy sem, ha az értékek nem egyenlőek, akkor a feltétel igaz lesz, és 1-et ad vissza.

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

== Ellenőrzi, hogy két operandus értéke egyenlő-e vagy sem, ha igen, akkor a feltétel igaz lesz, és 1-et ad vissza, különben 0-t ad vissza

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

logikus Operator

&& Ha mindkét operandus nullától eltérő, akkor a feltétel igaz lesz, és 1-et ad vissza, különben 0-t ad vissza

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

|| Ha a két operandus bármelyike ​​nem nulla, akkor a feltétel igaz lesz, és 1-et ad vissza, ellenkező esetben 0-t ad vissza

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

! Bármely kifejezés eredményének megfordítására szolgál. Itt a kimenetben látható, hogy az 'a' értéke 0-ból 1-re változott. Míg a 'b' értéke 1-ből 0-ra változott.

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

bitenkénti Operator

& (bitenkénti és) hajtsa végre a bitenkénti műveletet, és kövesse az alábbi táblázatot a művelethez.

Volt:-

%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

| (bitenkénti vagy) hajtsa végre a bitenkénti műveletet, és kövesse az alábbi táblázatot

Volt:-

%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

^ (bitenkénti kizárás vagy) hajtsa végre a bitenkénti műveletet, és kövesse az alábbi táblázatot

Volt:-

%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

A ~ (bitenkénti negáció) operátor 1-ről 0-ra és 0-ról 1-re változtat, referenciaként kövesse a táblázatot

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

Hármas Operator (?:)

A szintaxis az

condition-expression?  expression_1: expression_2

Ha a feltétel-exp igaz, az exp1 kiértékelésre kerül, és az eredményt visszaadja. Ha a cond-exp hamis, az exp2 kiértékelődik, és az eredményt adja vissza. Példánkban az exp1 igaz, mivel A értéke nagyobb, mint 6.

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

Shift Operator

Shift operátort vagy a << balra eltolás operátor, vagy a >> jobb eltolás operátor jelöli. << balra eltolás operátor esetén a bal oldali operandusok értéke balra kerül a jobb oldali operandus által megadott számú bittel.

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

A >> jobb oldali eltolás operátornál a bal oldali operandusok értéke jobbra kerül a jobb oldali operandus által meghatározott bitek számával.

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

String összehasonlítás Operator

A karakterlánc-összehasonlító operátor összehasonlítja mindkét operandus értékét. Ha az operandus értéke megegyezik, akkor 1-et ad vissza, egyébként 0-t. A példában mind az A, mind a B értéke 7, ezért az eredmény 1.

Volt:-

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

Ne (ha mindkét operandus értéke eltérő, akkor 1-et ad vissza, egyébként 0-t)

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

Hatványozási operátor

A pow () és ** ugyanaz. Mindig lebegő értéket ad vissza.

** a kívánt operandus teljesítményét jelzi.

Volt:-

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

Lista Operator

Ha a kért érték megtalálható a definiált listában, akkor 1-et ad vissza, egyébként 0-t. A példában az 1-es érték létezik az 'a' változóban, ezért 1-et fog visszaadni.

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

ni, ha a kívánt érték megtalálható a definiált listában, akkor 0-t ad vissza, különben 1-et ad vissza.

Pl.:-

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

TCL áramlásvezérlés és döntéshozatal

Különféle áramlásvezérlő és döntéshozatali parancsok léteznek, amelyek a program folyamának megváltoztatására szolgálnak. A programok végrehajtása mindig a forrásfájl tetejétől az aljáig kezdődik.

Ha az utasítás logikai kifejezésből áll, amelyet egy vagy több utasítás követ.

Ha … állítás

Szintaxis:-

ha expr ?akkor? test

ha az expr értéke igaz, akkor a parancstörzs végrehajtásra kerül.

Volt:-

set age 10

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

Output: Age is less than 20

Ha … else utasítás

Szintaxis: -

Ha kifejezés ? majd test_1 másik test_2

Ha a kifejezés kiértékelése igaz, akkor a test_1 értéket adja vissza, különben a test_2 értéket adja vissza

Volt:-

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

Beágyazott if..else nyilatkozat

Azt jelenti, hogy egy if vagy else..if utasítás behelyezhető egy másik if vagy else..if utasításba.

Szintaxis:-

If  {expression_1} {
Body_1
If {expression_2} {
Body_2
}
}

Volt:-

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

Kapcsoló nyilatkozat

A switch utasítás lehetővé teszi egy változó értéklistával való egyenlőségének tesztelését. Kiértékeli az értéklistát, és visszaadja az értékelés eredményét. Ha egyik érték sem egyezik, akkor a rendszer az alapértelmezett értékeket adja vissza.

Példa:

#!/usr/bin/tclsh

# switch_cmd.tcl

set domain x
switch $domain {

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

Beágyazott kapcsoló

A beágyazott switch utasítás a switch utasításon belüli switch utasítást jelenti.

Szintaxis :-

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

PéldaA következő példában az „a” értéke 100, és ugyanazzal a kóddal egy másik, „b” értékre állítjuk át az utasítást, amely 200. A kimenet mind az „a”, mind a „b” értékét mutatja.

#!/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"
        }
     }
   }
}

Kimenet:-

A értéke 100

A b értéke 200

TCL Loop utasítás

A ciklusutasítás lehetővé teszi egy utasítás vagy utasításcsoport többszöri végrehajtását. A Tcl a következő típusú loo-kat kínálja:ping nyilatkozat.

Parancs közben

Ha egy adott feltétel igaz, akkor egy utasítás vagy utasításcsoport megismétlődik, amelyek a ciklustörzsben találhatók.

Szintaxis:

While  {condition} {
    Statements
}

Pl.:-

#!/usr/bin/tclsh

Set a 10

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

Kimenet:-

a az 10

a az 11

A fenti példában az „incr” beépített parancsot használjuk. Ez azt jelenti, hogy az „a” értéke 1-gyel növekszik a maximális értékig (<12).

Parancsra

Egy számláló értéke alapján többször végrehajt egy utasítássorozatot. A számláló értéke automatikusan növekszik vagy csökken a ciklus minden ismétlésekor.

Szintaxis :-

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

PéldaAz alábbi példában az 'i' értéke 0, és <5 értékig növekszik.

#!/usr/bin/tclsh

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

Kimenet:-

0
1
2
3
4

GYIK