Tcl/Tk Tutorial

Was ist TCL?

TCL ist eine Shell-Anwendung, die TCL-Befehle aus ihrer Standardeingabe oder aus einer Datei liest und die gewünschten Ergebnisse liefert.

TCL ist eine stringbasierte Skriptsprache und gleichzeitig eine prozedurale Sprache. Sie wurde 1989 von John Osterhout entwickelt.ping Diese Sprache lässt sich leicht in Anwendungen einbetten. Sie wird häufig für grafische Benutzeroberflächen (GUIs) und Tests verwendet. Zum Beispiel für Rapid Prototyping.ping, Tests Datenbankinteraktion usw. In TCL ist standardmäßig alles eine Zeichenfolge.

So führen Sie TCL aus

Es gibt zwei Möglichkeiten, TCL-Code auszuführen:

1. Windows Die entsprechende Anwendung finden Sie hier tcltutor exe-Datei
2. Linux-basierte Anwendung

In Linux Mit dem interaktiven Interpreter können wir die TCL-Skripte wie folgt ausführen

Um auf die interaktive TCL-Sitzung zuzugreifen, führen Sie den folgenden Befehl aus

TCL-Skripte

Das TCL-Programm sollte die Erweiterung .tcl haben. Jedes Skript unter UNIX/LINUX beginnt mit dem TCL-Shell-Pfad

#!/usr/bin/tclsh

Beispiel:-

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

Ausgang: Hallo Welt

In TCL wird der Befehl „puts“ verwendet, um Meldungen auf der Konsole auszugeben. Die Syntax von puts ist unten aufgeführt.

puts ?-nonewline? ?channelId? string

• Keine neue Zeile: Dieser optionale Parameter unterdrückt standardmäßig das Newline-Zeichen. Es fügt jeder Zeichenfolge eine neue Zeile hinzu
• Kanal ID: Dieser Parameter wird für den Standardeingabekanal (stdin) und den Standardausgabekanal (stdout) verwendet.

Ex:-

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

TCL-Ersetzungstyp

In TCL gibt es drei Arten von Ersetzungen

1. Befehlsersetzung
2. Variablensubstitution
3. Backslash-Ersetzung

Lasst uns einzeln lernen

Befehlsersetzung

Zur Befehlsersetzung werden eckige Klammern verwendet.

Beispiel:-

% puts [expr 1*3]
% 3

Hier wird zuerst der Befehl in den eckigen Klammern ausgewertet. Das Ergebnis wird zurückgegeben. „expr“ wird für die arithmetische Berechnung verwendet.

Variablensubstitution

TCL führt die Variablensubstitution mithilfe von durch $ Schild.

Beispiel:-

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

Hier erstellen wir eine Variable namens „a“ und setzen den Wert „10“ darauf.

• puts a: Es wird die Zeichenfolge „a“, aber nicht der Wert von „a“ an die Konsole ausgegeben
• puts $a: Der Wert von „a“ wird auf der Konsole ausgegeben

Lassen Sie es uns ausführen und überprüfen. Sie erhalten die folgende Ausgabe.

$ ./substitution.tcl

a

10

Backslash-Ersetzung

In Tcl wird der Backslash zur Eskalation verwendet.ping Sonderzeichen werden verwendet, um längere Befehle über mehrere Zeilen zu verteilen. Jedes Zeichen, das unmittelbar auf den Backslash folgt, bleibt unverändert. Im folgenden Beispiel sehen Sie, dass das Sonderzeichen " “ nach dem Backslash erhalten bleibt.

Lassen Sie uns dies anhand eines Beispiels überprüfen

#!/usr/bin/tclsh

puts "This  is my  \"car\""

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

HINWEIS: -Zum Kommentieren einer beliebigen Zeichenfolge in TCL wird „#“ verwendet. Alle Zeichen nach dem „#“ werden vom Shell-Befehl tclsh ignoriert.

TCL-Variable

Eine Variable ist ein Bezeichner, der einen Wert speichert. Anders ausgedrückt: Eine Variable ist ein Verweis auf einen Speicherbereich im Computer, in dem der Wert gespeichert ist.

Variablen werden mit „set command“ erstellt und bei allen Variablennamen muss die Groß-/Kleinschreibung beachtet werden. Es bedeutet Hallo, Hallo, HALLO, in TCL sind alle unterschiedlich. Schauen Sie sich ein Beispiel für eine Variable an, bei der die Groß-/Kleinschreibung beachtet wird.

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

Ausgabe:-

% puts $name
% Technoit

%puts  $Name
%Technoit_1

%puts $NAME
%Technoit_2

Erstellen von TCL-Variablen

Um Variablen in TCL zu erstellen, müssen Sie verwenden "einstellen" Befehl

Legen Sie eine 10 fest

Um den Wert der Variablen zu erhalten, müssen Sie das Symbol „$“ verwenden

% legte $a

10%

Wir erhalten also den Wert der Variablen „a“ als 10.

TCL-Befehlsinformationen vorhanden

Der Befehl „set“ dient zum Erstellen und Lesen von Variablen, wie oben gezeigt. Der Befehl „unset“ dient zum Löschen einer Variablen. Der Befehl „info exists“ gibt 1 zurück, wenn varName im aktuellen Kontext als Variable (oder Array-Element) existiert, andernfalls 0 (siehe Beispiel unten).

In TCL gibt es verschiedene „info“-Befehle wie „info exists“, „info functions“, „info global“ usw. Hier sehen wir ein Beispiel für „info exists“.

Ex:-

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

Verschiedene Zahnspangen und ihr Verhalten

{} -> Geschweifte Klammern

Geschweifte Klammern in TCL gruppieren Wörter zu Argumenten. Sie definieren einen Block, der verzögert ausgeführt wird – er wird also erst nach dem Rest des Befehls in der aktuellen Zeile ausgeführt. Zeichen innerhalb der Klammern werden exakt so an den Befehl übergeben, wie sie geschrieben sind.

Einige Punkte, die Sie beachten sollten

1. Das Ersetzen von Variablen innerhalb von {}-Klammern ist nicht zulässig
2. Es wurde zum Erstellen des Listendatentyps verwendet

Beispiel:-

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

%set number {1 2 3 4 5} -> Hier ist number ein Listendatentyp

%puts $number

%1 2 3 4 5

[] -> eckige Klammern

Eckige Klammern dienen zur Erstellung verschachtelter Befehle. Vereinfacht gesagt: Die Ausgabe eines Befehls wird als Argument an einen anderen Befehl übergeben. Eckige Klammern definieren einen Block, der VOR dem restlichen Befehl in der aktuellen Zeile ausgeführt wird. Das Ergebnis wird dann in die Zeile eingefügt.

Ex: -

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

() -> runde Klammern

Mit diesem Befehl wird der Array-Datentyp erstellt und die Operatorpriorität angegeben.

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

Hier ist „a“ ein Array mit den Werten 10 und 20. Siehe unten Befehle zum Drucken von Schlüsseln, Schlüsselwertpaaren und Arraywerten.

% 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

Um den „N-ten“ Wert des Arrays a auszugeben, verwenden wir Puts $a(N)

TCL-Befehlszeilenargumente

Datenelemente, die über die Befehlszeile an ein Skript übergeben werden, werden als Argumente bezeichnet. Die Anzahl der Befehlszeilenargumente an ein Tcl-Skript wird als globale Variable übergeben Argc. Der Name eines Tcl-Skripts wird als globale Variable an das Skript übergeben argv0, und die restlichen Befehlszeilenargumente werden als Liste übergeben argv.

TCL verfügt über 3 vordefinierte Variablen, z

$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

Möglichkeiten für das Ausgangssignal::-

• Anzahl der an die Skripte übergebenen Argumente: 3
• Liste der Argumente, die an das Skript übergeben werden: 10 20 30
• Der Name des Skripts lautet: arg-script.tcl

TCL-Ausdruck und OperaDo.

Ein Ausdruck wird aus Operanden und Operatoren gebildet. Er wird mit dem Befehl „expr“ ausgewertet. Operators werden basierend auf Vorrang und Assoziativität ausgewertet. Die TCL-Sprache hat integrierte Operatoren wie unten

Arithmetik OperaDo.

Ein TCL-Ausdruck besteht aus einer Kombination von Operanden, Operatoren und Klammern. Sehen wir uns ein Beispiel für arithmetische Operatoren in TCL an

+ Zwei oder mehr Operanden hinzufügen

Ex:-

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

– Subtracts zwei oder mehr Operanden

Ex:-

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

*Multiplizieren Sie zwei oder mehr Operanden

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

/ Zähler durch Nenner dividieren

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

% Der Modulo-Operator dividiert den Zähler durch den Nenner, gibt aber eine Erinnerung zurück

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

Relational OperaDo.

Überprüft, ob der Wert des linken Operanden größer ist als der Wert des rechten Operanden. Wenn ja, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

Überprüfen Sie, ob der Wert des linken Operanden kleiner ist als der Wert des rechten Operanden. Wenn ja, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

>= Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

<= Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

!= Überprüft, ob die Werte der beiden Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

== Überprüft, ob die Werte der beiden Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0.

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

logisch OperaDo.

&& Wenn beide Operanden ungleich Null sind, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls 0

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

|| Wenn einer der beiden Operanden ungleich Null ist, wird die Bedingung erfüllt und es wird 1 zurückgegeben, andernfalls wird 0 zurückgegeben.

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

Das Ausrufezeichen (!) kehrt das Ergebnis eines Ausdrucks um. In der Ausgabe sehen Sie, dass der Wert von 'a' von 0 auf 1 geändert wurde, während der Wert von 'b' von 1 auf 0 geändert wurde.

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

Bitweise OperaDo.

& (bitweises Und) führt die Operation Bit für Bit durch und folgt für die Operation der folgenden Tabelle.

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

| (bitweises Oder) Führen Sie die Operation Bit für Bit durch und folgen Sie der folgenden Tabelle

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

^ (bitweises Exklusiv-Oder) Führen Sie die Bit-für-Bit-Operation durch und folgen Sie der folgenden Tabelle

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

~ (bitweise Negation) Der Operator ändert jeweils 1 in 0 und 0 in 1, folgen Sie der Tabelle als Referenz

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

Ternary Operator ( ?:)

Syntax ist

condition-expression?  expression_1: expression_2

Wenn „condition-exp“ wahr ist, wird exp1 ausgewertet und das Ergebnis zurückgegeben. Wenn cond-exp falsch ist, wird exp2 ausgewertet und das Ergebnis zurückgegeben. In unserem Beispiel ist exp1 wahr, da der Wert von A größer als 6 ist.

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

Shift OperaDo.

Shift Der Operator wird entweder durch den Linksschiebeoperator << oder durch den Rechtsschiebeoperator >> gekennzeichnet. Beim Linksschiebeoperator << wird der Wert des linken Operanden um die Anzahl der Bits nach links verschoben, die durch den rechten Operanden angegeben wird.

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

Beim Rechtsverschiebungsoperator >> wird der Wert des linken Operanden um die durch den rechten Operanden angegebene Anzahl Bits nach rechts verschoben.

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

String-Vergleich OperaDo.

Der Stringvergleichsoperator vergleicht die Werte beider Operanden. Sind die Werte gleich, gibt er 1 zurück, andernfalls 0. Im Beispiel ist der Wert von A und B jeweils 7, daher ist das Ergebnis 1.

Ex:-

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

Ne (wenn die Werte beider Operanden unterschiedlich sind, wird 1 zurückgegeben, andernfalls 0)

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

Potenzierungsoperator

Pow() und ** sind beide gleich. Es gibt immer einen Gleitkommawert zurück.

** gibt die Potenz des gewünschten Operanden an.

Ex:-

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

Liste OperaDo.

Wird der gesuchte Wert in der definierten Liste gefunden, wird 1 zurückgegeben, andernfalls 0. Im Beispiel existiert der Wert 1 in der Variable 'a', daher wird 1 zurückgegeben.

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

ni, wenn der erforderliche Wert in der definierten Liste gefunden wird, wird 0 zurückgegeben, andernfalls wird 1 zurückgegeben.

Ex :-

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

TCL-Flusskontrolle und Entscheidungsfindung

Es gibt verschiedene Befehle zur Flusskontrolle und Entscheidungsfindung, mit denen der Fluss eines Programms geändert werden kann. Programmausführungen beginnen immer von oben nach unten in der Quelldatei.

Die If-Anweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.

Wenn … Aussage

Syntax:-

wenn expr ?dann? Körper

Wenn expr als wahr ausgewertet wird, wird der Befehlstext ausgeführt.

Ex:-

set age 10

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

Output: Age is less than 20

Wenn … sonst-Anweisung

Syntax :-

Wenn Ausdruck? dann body_1, sonst body_2

Wenn der Ausdruck als wahr ausgewertet wird, wird body_1 zurückgegeben, andernfalls wird body_2 zurückgegeben

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

Verschachtelte if..else-Anweisung

Es bedeutet, dass eine if- oder else..if-Anweisung in eine andere if- oder else..if-Anweisung eingefügt werden kann.

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

Switch-Anweisung

Mit der switch-Anweisung kann eine Variable anhand einer Liste von Werten auf Gleichheit getestet werden. Es wertet die Werteliste aus und gibt das Ergebnis dieser Bewertung zurück. Wenn keine Werte übereinstimmen, werden Standardwerte zurückgegeben.

Beispiel:

#!/usr/bin/tclsh

# switch_cmd.tcl

set domain x
switch $domain {

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

Verschachtelter Schalter

Eine verschachtelte Switch-Anweisung bedeutet eine Switch-Anweisung innerhalb einer Switch-Anweisung.

Syntax :-

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

BeispielIm folgenden Beispiel hat a den Wert 100, und mit demselben Code verwenden wir eine Switch-Anweisung, um den Wert von b auf 200 zu ändern. Die Ausgabe zeigt die Werte für a und b an.

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

Ausgabe:-

Der Wert von a ist 100

Der Wert von b beträgt 200

TCL-Loop-Anweisung

Die Schleifenanweisung ermöglicht die mehrfache Ausführung einer Anweisung oder einer Gruppe von Anweisungen. Tcl bietet die folgenden Arten von Schleifen:ping Aussage.

Während Befehl

Wenn eine bestimmte Bedingung wahr ist, wird eine Anweisung oder eine Gruppe von Anweisungen wiederholt, die sich im Schleifenkörper befinden.

Syntax:

While  {condition} {
    Statements
}

Ex :-

#!/usr/bin/tclsh

Set a 10

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

Ausgabe:-

a ist 10

a ist 11

Im obigen Beispiel wird der integrierte Befehl „incr“ verwendet. Das bedeutet, dass der Wert von „a“ schrittweise um 1 erhöht wird, bis der Maximalwert (<12) erreicht ist.

Für Befehl

Es führt eine Abfolge von Anweisungen mehrmals basierend auf einem Zählerwert aus. Dieser wird bei jeder Schleifendurchlauf automatisch erhöht oder verringert.

Syntax :-

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

BeispielIm folgenden Beispiel wird der Wert von 'i' auf 0 gesetzt und so lange erhöht, bis der Wert <5 ist.

#!/usr/bin/tclsh

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

Ausgabe:-

0
1
2
3
4

Häufig gestellte Fragen