TCL TK -opetusohjelma: Työkalun komentokieli
Mikä on TCL?
TCL on shell-sovellus, joka lukee TCL-komennon vakiosyötteestä tai tiedostosta ja antaa halutut tulokset.
TCL on merkkijonopohjainen komentosarjakieli ja myös proseduurikieli. Sen loi ensimmäisenä John Osterhout vuonna 1989. Tämän kielen kehittämisen tarkoituksena on helposti upotettavat inti ( ) -sovellukset. Kieltä käytetään yleisesti graafisissa käyttöliittymissä ja testauksessa. Esimerkiksi nopea prototyyppien valmistus, Testaus tietokantavuorovaikutus jne. TCL:ssä oletusarvoisesti kaikki on merkkijonoa.
Tässä opetusohjelmassa opit -
- Mikä on TCL
- Kuinka suorittaa TCL
- TCL-skriptit
- TCL-korvaustyyppi
- TCL-muuttuja
- TCL-lauseke ja OperaTor
- TCL-virtauksen ohjaus ja päätöksenteko
Kuinka suorittaa TCL
TCL-koodin suorittamiseen on kaksi tapaa
- Windows pohjainen sovellus löytyy täältä tcltutor exe-tiedosto
- Linux-pohjainen sovellus
In Linux interaktiivinen tulkki, voimme suorittaa TCL-komentosarjat alla
Päästäksesi interaktiiviseen TCL-istuntoon, suorita seuraava komento
TCL-skriptit
TCL-ohjelmalla tulee olla .tcl-tunniste. Jokainen UNIX/LINUXin komentosarja alkaa TCL-kuoren polulla
#!/usr/bin/tclsh
Esimerkki: -
#!/usr/bin/tclsh Puts "Hello World" Script execution:- $ chmod +x helloworld.tcl $ ./helloworld.tcl
ulostulo: Hei maailma
TCL:ssä "Puts"-komentoa käytetään viestien tulostamiseen konsoliin. Puts-syntaksi on alla
laittaa?-nonewline? ?channelId? merkkijono
- Ei uusi rivi: Tämä valinnainen parametri estää rivinvaihdon oletuskomennon. Se asettaa rivinvaihdon jokaiseen merkkijonoon
- Channelid: Tätä parametria käytetään vakiotulokanavalle (stdin) ja vakiolähtökanavalle (stdout).
Esim:-
%puts "Hello World" % Hello World %puts stdout "Hello World" % Hello World
TCL-korvaustyyppi
TCL:ssä on kolmenlaisia korvauksia
- Komennon korvaaminen
- Muuttuva korvaus
- Kenoviivan vaihto
Opiskellaan yksi kerrallaan
Komennon korvaaminen
Hakasulkeita käytetään komentojen korvaamiseen.
Esimerkki: -
% puts [expr 1*3] % 3
Tässä hakasulkujen välissä oleva komento arvioidaan ensin. Tulokset palautetaan aritmeettisen laskutoimituksen suorittamiseen käytettynä ”lauseena”.
Muuttuva korvaus
TCL suorittaa muuttujan korvaamisen avulla $ merkki.
Esimerkki: -
#!/usr/bin/tclsh set a 10 puts a puts $a
Täällä luomme muuttujan nimeltä "a" ja asetamme sille arvon "10".
- laittaa a: Se tulostaa merkkijonon "a", mutta ei "a":n arvoa konsoliin
- laittaa $a: Se tulostaa 'a':n arvon konsoliin
Suoritetaan ja tarkistetaan se. Saat tulosteen alla olevan mukaisesti.
$ ./substitution.tcl
a
10
Kenoviivan vaihto
Tcl:ssä kenoviivaa käytetään erikoismerkkien välttämiseen sekä pitkien komentojen jakamiseen useille riveille. Mikä tahansa kenoviivaa välittömästi seuraava merkki on voimassa ilman vaihtoa. Alla olevassa esimerkissä näet erikoismerkin " ", joka jää kenoviivan jälkeen.
Varmistetaan tämä esimerkillä
#!/usr/bin/tclsh puts "This is my \"car\" $ ./backslashsubstitution.tcl This is my "car"
HUOMAUTUS: -Kommentoimiseen käytetään mitä tahansa merkkijonoa TCL:ssä "#". Tclsh shell -komento ohittaa kaikki "#":n jälkeiset merkit.
TCL-muuttuja
Muuttuja on tunniste, joka sisältää arvon. Toisin sanoen muuttuja on viittaus tietokoneen muistiin, johon arvo on tallennettu.
Muuttujat luodaan "set-komennolla", ja kaikki muuttujien nimet ovat kirjainkoolla. Se tarkoittaa hei, hei, hei kaikki ovat erilaisia TCL:ssä. Katso esimerkkiä isot ja pienet kirjaimet vaihtelevasta muuttujasta.
% set name Techoit % set Name Technoit_1 % set NAME Technoit_2
Lähtö: -
% puts $name % Technoit %puts $Name %Technoit_1 %puts $NAME %Technoit_2
TCL-muuttujien luominen
Jos haluat luoda muuttujia TCL:ssä, sinun on käytettävä "aseta" komento
Aseta 10
Muuttujan arvon saamiseksi on käytettävä "$" symbolia kuten
% laittaa $a
% 10
Joten saamme muuttujan 'a' arvoksi 10.
TCL-komentotiedot ovat olemassa
"set"-komentoa käytetään muuttujien luomiseen ja lukemiseen yllä olevan kuvan mukaisesti. Unset-komentoa käytetään muuttujan tuhoamiseen. Komento "info létezik" palauttaa arvon 1, jos varName on olemassa muuttujana (tai taulukkoelementtinä) nykyisessä kontekstissa, muussa tapauksessa palauttaa arvon 0. (katso esimerkki alla).
TCL:ssä on erilaisia "info"-komentoja, kuten "info olemassa", "infofunktiot", "info globaali" ja niin edelleen. Tässä näemme esimerkin "tietoa on olemassa".
Esim:-
% set a 20 % puts $a % 20 % puts [info exists a] % 1 % unset a %puts [info exists a] % 0
Erilaiset henkselit ja niiden käyttäytyminen
{} -> Kiharat henkselit
TCL:n kiharat aaltosulut ryhmittelevät sanat yhteen argumenteiksi. Aaltosulkeiden avulla määritetään lykätty lohko – toisin sanoen se voidaan suorittaa nykyisen rivin muun komennon JÄLKEEN. Aaltosulkeissa olevat merkit välitetään komennolle täsmälleen kirjoitetulla tavalla.
Muutama huomio muistettavana
- Muuttujien korvaaminen ei ole sallittu {} aaltosulkeissa
- Sitä käytettiin luettelotietotyypin luomiseen
Esimerkki: -
% set x 10 % puts {$x} % $x
%set number {1 2 3 4 5} -> Tässä numero on luettelotietotyyppi
% laittaa $numeron
%1 2 3 4 5
[] -> hakasulkeet
Hakasulkeilla luodaan sisäkkäisiä komentoja. Yksinkertaisesti sanottuna yhden komennon tulos välitetään argumenttina toiselle komennolle. Hakasulkeilla määritetään lohko, joka suoritetaan ENNEN nykyisen rivin muuta komentoa, ja tulos korvataan rivillä.
Esim: -
% set x 10 % puts "y : [set y [set x 10]]" %y : 10 % puts "x : $x" %x : 10
() -> pyöreät olkaimet
Tätä komentoa käytetään taulukon tietotyypin luomiseen ja myös operaattorin ensisijaisuuden osoittamiseen.
% set a(1) 10 % set a(2) 20
Tässä "a" on taulukko, jonka arvot ovat 10 ja 20. Katso alla komennot avainten, avainarvoparien ja taulukon arvojen tulostamiseksi.
% 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
Tulostettaessa taulukon a "N:s" arvoa käytetään Puts $a(N)
TCL-komentorivin argumentit
Komentoriviltä komentosarjalle välitetyt tiedot tunnetaan argumenteina. Tcl-komentosarjan komentoriviargumenttien määrä välitetään yleisenä muuttujana arg . Tcl-komentosarjan nimi välitetään komentosarjalle globaalina muuttujana argv0 , ja loput komentorivin argumentit välitetään luettelona sisään argv.
TCL:ssä on 3 ennalta määritettyä muuttujaa, kuten
$argc -> indicates the number of arguments passed to the script $argv -> indicates list of arguments $argv0 -> indicates the name of script
Esim:-
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
ulostulo:-
- Skripteille välitettyjen argumenttien määrä: 3
- Argumenttien luettelo välitetään skriptille: 10 20 30
- Skriptin nimi on: arg-script.tcl
TCL-lauseke ja OperaTor
Lauseke muodostetaan operandeista ja operaattoreista. Se arvioidaan "expr"-komennolla. Operatorit arvioidaan ensisijaisuuden ja assosiatiivisuuden perusteella. TCL-kielessä on sisäänrakennetut operaattorit, kuten alla
Operator luokkaan | Symboli | Ensisijaisuus/assosiaatio |
---|---|---|
Aritmeettinen OperaTor | + - * / % | Vasemmalta oikealle |
omainen OperaTor | == != < > <= >= | Vasemmalta oikealle |
looginen OperaTor | && || ! | Vasemmalta oikealle |
biteittäin OperaTor | & | ^ ~ | Vasemmalta oikealle |
Kolmiosainen OperaTor | ?: | Oikealta vasemmalle |
Shift OperaTor | << >> | Vasemmalta oikealle |
Merkkijonojen vertailu OperaTor | eq ne | Vasemmalta oikealle |
Potenssiinkorotus OperaTor | ** | Vasemmalta oikealle |
Lista OperaTor | Vuonna ni | Vasemmalta oikealle |
Aritmeettinen OperaTor
TCL-lauseke koostuu operandien, operaattoreiden ja sulkeiden yhdistelmästä. Katsotaanpa esimerkkiä TCL:n aritmeettisista operaattoreista
+ Lisää kaksi tai useampi operandi
Esim:-
%set a 10 %set b 20 %puts [expr $a + $b] 30
- Vähentää kaksi tai useampi operandi
Esim:-
%set a 20 %set b 10 %puts [expr $a - $b] 10
*Kerro kaksi tai useampi operandi
%set a 20 %set b 10 %puts [expr $a * $b] 200
/ Jaa osoittaja osoittajalla
%set a 20 %set b 10 %puts [expr $a / $b] 2
% Modulus-operaattori jakaa osoittajan de-osoittajalla, mutta palauttaa muistutuksen
%set a 20 %set b 10 %puts [expr $a % $b] 0
omainen OperaTor
Tarkistaa, onko vasemman operandin arvo suurempi kuin oikean operandin arvo. Jos kyllä, niin ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0.
%set a 20 %set b 10 %puts [expr $a > $b] 1
Tarkista, onko vasemman operandin arvo pienempi kuin oikean operandin arvo. Jos kyllä, niin ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 10 %set b 20 %puts [expr $a < $b] 1
>= Tarkistaa onko vasemman operandin arvo suurempi tai yhtä suuri kuin oikean operaandin arvo, jos kyllä, niin ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 20 %set b 10 %puts [expr $a >= $b] 1
<= Tarkistaa onko vasemman operandin arvo pienempi tai yhtä suuri kuin oikean operandin arvo, jos kyllä, niin ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 20 %set b 10 %puts [expr $a <= $b] 0
!= Tarkistaa ovatko kahden operandin arvot samat vai eivät, jos arvot eivät ole yhtä suuret, ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 20 %set b 10 %puts [expr $a != $b] 1
== Tarkistaa ovatko kahden operandin arvot yhtä suuret vai eivät, jos kyllä niin ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 20 %set b 10 %puts [expr $a == $b] 0
looginen OperaTor
&& Jos molemmat operandit eivät ole nollia, ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 20 %set b 10 %puts [expr $a && $b] 1
|| Jos jokin kahdesta operandista on muu kuin nolla, ehdosta tulee tosi ja palauttaa 1 muuten palauttaa 0
%set a 0 %set b 10 %puts [expr $a || $b] 1
! Käytetään minkä tahansa lausekkeen tuloksen kääntämiseen. Tässä tulosteessa näet, että 'a':n arvo on nyt tullut 1 arvosta 0. Kun taas 'b':n arvo on tullut 0:sta 1.
%set a 0 %set b 1 %puts [expr !$a] 1 %puts [expr !$b] 0
biteittäin OperaTor
& (bittisesti ja) suorita bitti bitiltä -toiminto ja noudata alla olevaa taulukkoa.
A | B | A & B |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 1 | 1 |
1 | 0 | 0 |
Esim:-
%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
| (bitti kerrallaan tai) suorita bitti bitiltä -toiminto ja noudata alla olevaa taulukkoa
A | B | A | B |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 1 | 1 |
1 | 0 | 1 |
Esim:-
%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
^ (bittittäin poissulkeva tai) suorita bitti bitiltä -toiminto ja noudata alla olevaa taulukkoa
A | B | A^B |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 1 | 0 |
1 | 0 | 1 |
Esim:-
%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
~ (bittikohtainen negaatio) -operaattori muuttaa kunkin 1:stä 0:ksi ja 0:sta 1:ksi, seuraa taulukkoa viitteenä
A | ~A |
---|---|
0 | 1 |
1 | 0 |
%set A 7 %puts [expr ~$A] -8
Kolmiosainen Operator (?:)
Syntaksi on
condition-expression? expression_1: expression_2
Jos ehto-exp on tosi, exp1 arvioidaan ja tulos palautetaan. Jos cond-exp on epätosi, exp2 arvioidaan ja sen tulos palautetaan. Esimerkissämme exp1 on tosi, koska A:n arvo on suurempi kuin 6.
%set A 7 %set result [expr $A > 6 ? true : false] %puts $result true
Shift OperaTor
Shift operaattoria merkitään joko << vasemman siirtooperaattorilla tai >> oikealla siirtooperaattorilla. << vasemmalle siirtooperaattorille vasemman operandin arvoa siirretään vasemmalle oikean operandin määrittämän bittien lukumäärän verran.
%set A 7 %set result [expr $A << 2] %puts $result
>> right shift -operaattorille vasen operandiarvo siirretään oikealle oikean operandin määrittämän bittimäärän verran.
%set A 7 %set result [expr $A >> 2] %puts $result
Merkkijonojen vertailu OperaTor
Merkkijonojen vertailuoperaattori vertaa molempien operandien arvoa. Jos operandin arvot ovat samat, se palauttaa 1 muuten palauttaa 0. Esimerkissä arvo sekä A:lle että B:lle on 7, joten tulos palauttaa 1.
Esim:-
%set A 7 %set B 7 %set result [expr $A eq $B] %puts $result 1
Ei (jos molempien operandien arvot ovat erilaiset, se palauttaa 1 muuten palauttaa 0)
%set A 7 %set B 8 %set result [expr $A ne $B] %puts $result 1
Eksponenttioperaattori
Pow () ja ** ovat molemmat samat. Se palauttaa aina kelluvan arvon.
** osoittaa tehon haluttuun operandiin.
Esim:-
%set A 7 %set result [expr $A ** 2] %puts $result 49
Lista OperaTor
Jos vaadittu arvo löytyy määritellystä luettelosta, se palauttaa 1 else return 0. Esimerkissä arvo 1 on muuttujassa 'a', joten se palauttaa arvon 1.
set a {1 2 3} if {1 in $a} { puts "ok" } else { puts "fail" } Output: ok
ni, jos vaadittu arvo löytyy määritellystä luettelosta, se palauttaa 0, muuten palauttaa 1.
Esim:-
set a {1 2 3} if {1 ni $a} { puts "ok" } else { puts "fail" } Output: fail
TCL-virtauksen ohjaus ja päätöksenteko
Ohjelman kulun muuttamiseen käytetään erilaisia vuonohjaus- ja päätöksentekokomentoja. Ohjelman suoritukset alkavat aina lähdetiedoston ylhäältä alas.
Jos lauseke koostuu Boolen lausekkeesta, jota seuraa yksi tai useampi lause.
Jos ... lausunto
Syntaksi:-
jos expr ?niin? kehon
jos expr arvioidaan tosi, niin komentokappale suoritetaan.
Esim:-
set age 10 if {$age < 20} { puts "Age is less than 20" } Output: Age is less than 20
Jos... muuten lausunto
Syntaksi :-
Jos ilmaisu ? sitten body_1 muu body_2
Jos lausekkeen arvo on tosi, se palauttaa body_1, muuten se palauttaa body_2
Esim: --
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
Sisäkkäinen if..else lauseke
Se tarkoittaa yhtä if tai else..if -lauseketta voidaan laittaa toiseen if tai else..if -lauseeseen.
Syntaksi:-
If {expression_1} { Body_1 If {expression_2} { Body_2 } }
Esim: --
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
Vaihda lausunto
Switch-käsky mahdollistaa muuttujan tasa-arvon testaamisen arvoluetteloa vastaan. Se arvioi arvoluettelon ja palauttaa arvioinnin tuloksen. Jos arvot eivät täsmää, palautetaan oletusarvot.
esimerkki:
#!/usr/bin/tclsh # switch_cmd.tcl set domain x switch $domain { x { puts "x" } y { puts "y" } z { puts "z" } default { puts "unknown" } }
Sisäkkäinen kytkin
Sisäkkäinen kytkinlause tarkoittaa kytkinkäskyn sisällä olevaa kytkinlausetta.
Syntaksi :-
switch <switchingstring1> { <matchstring1> { body1 switch <switchingstring2> { <matchstring2> { body2 } ... switch <switchingstringN> { <matchStringN> { bodyN } } }
esimerkki: Seuraavassa esimerkissä a:n arvo on 100, ja samalla koodilla vaihdamme käskyä toiselle b:lle arvolle 200. Out näyttää sekä a:n että b:n arvon.
#!/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" } } } }
Lähtö: -
A:n arvo on 100
B:n arvo on 200
TCL Loop -lause
Silmukkakäsky mahdollistaa lauseen tai käskyryhmän suorittamisen useita kertoja. Tcl tarjoaa seuraavan tyyppiset silmukkalausekkeet.
Vaikka komento
Kun annettu ehto on tosi, lause tai lauseryhmä toistaa, jotka ovat silmukan rungossa.
Syntaksi:
While {condition} { Statements }
Esim:-
#!/usr/bin/tclsh Set a 10 While {$a < 12} { Puts "a is $a" incr a }
Lähtö: -
a on 10
a on 11
Yllä olevassa esimerkissä käytetään sisäänrakennettua komentoa "incr". Se tarkoittaa, että 'a':n arvoa kasvatetaan yhdellä maksimiarvoon (<1).
Komentoa varten
Se suorittaa lausesarjan useita kertoja laskurin arvon perusteella. Se kasvaa tai pienenee automaattisesti jokaisen silmukan toiston aikana.
Syntaksi :-
For {start} {test} {next} { Body }
esimerkki: Alla olevassa esimerkissä i:n arvoksi on asetettu 0 ja sitä lisätään arvoon <5 asti.
#!/usr/bin/tclsh for {set i 0} {$i < 5} {incr i} { put $i }
Lähtö: -
0 1 2 3 4
Yhteenveto:
- TCL on merkkijonopohjainen komentosarjakieli ja myös proseduurikieli
- Kieltä käytetään yleisesti graafisissa käyttöliittymissä ja testauksessa
- TCL:ssä oletusarvoisesti kaikki on merkkijonoa
- TCL on shell-sovellus, joka lukee TCL-komennon vakiosyötteestä tai tiedostosta ja antaa halutut tulokset.
- TCL-ohjelmassa tulee olla .tcl-tunniste