Tutoriel Tcl/Tk

Qu’est-ce que TCL ?

TCL est une application shell qui lit la commande TCL à partir de son entrée standard ou d'un fichier et donne les résultats souhaités.

TCL est un langage de script basé sur les chaînes de caractères et également un langage procédural. Il a été créé par John Osterhout en 1989. L'objectif du développementping Ce langage s'intègre facilement aux applications. Il est couramment utilisé pour les interfaces graphiques et les tests. Par exemple, le prototypage rapide.ping, Tests interaction avec la base de données, etc. Dans TCL, par défaut, tout est une chaîne.

Comment exécuter TCL

Il existe deux manières d'exécuter du code TCL :

1. Windows l'application basée est disponible ici fichier exe tcltutor
2. Application basée sur Linux

In Linux interpréteur interactif, nous pouvons exécuter les scripts TCL comme ci-dessous

Pour accéder à la session interactive TCL, exécutez la commande suivante

Scripts TCL

Le programme TCL doit avoir une extension .tcl. Chaque script sous UNIX/LINUX commence par le chemin du shell TCL

#!/usr/bin/tclsh

Exemple:-

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

Sortie: Bonjour le monde

En TCL, la commande « puts » permet d'afficher des messages sur la console. La syntaxe de puts est présentée ci-dessous.

puts ?-nonewline? ?channelId? chaîne

• Pas de nouvelle ligne: Ce paramètre facultatif supprime le caractère de nouvelle ligne par la commande par défaut. Il met une nouvelle ligne à chaque chaîne
• Identifiant de la chaine: Ce paramètre est utilisé pour le canal d'entrée standard (stdin) et le canal de sortie standard (stdout).

Ex:-

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

Type de remplacement TCL

Il existe trois types de substitutions dans TCL

1. Substitution de commandes
2. Substitution de variables
3. Substitution de barre oblique inverse

Étudions un par un

Substitution de commandes

Les crochets sont utilisés pour la substitution de commandes.

Exemple:-

% puts [expr 1*3]
% 3

La commande entre crochets est évaluée en premier. Le résultat est renvoyé. « expr » est utilisé pour effectuer le calcul arithmétique.

Substitution de variables

TCL effectue une substitution de variable à l'aide de $ signe.

Exemple:-

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

Ici, nous créons une variable appelée « a » et lui donnons la valeur « 10 ».

• met a : il affichera la chaîne "a" mais pas la valeur de "a" sur la console
• met $a : il imprimera la valeur de 'a' sur la console

Exécutons-le et vérifions-le. Vous obtiendrez le résultat comme ci-dessous.

$ ./substitution.tcl

a

10

Substitution de barre oblique inverse

En Tcl, la barre oblique inverse est utilisée pour l'échappement.ping Les caractères spéciaux, ainsi que la possibilité d'étaler les commandes longues sur plusieurs lignes, sont pris en compte. Tout caractère suivant immédiatement la barre oblique inverse est conservé sans modification. Dans l'exemple ci-dessous, le caractère spécial « », « », reste inchangé après la barre oblique inverse.

Vérifions cela avec un exemple

#!/usr/bin/tclsh

puts "This  is my  \"car\""

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

REMARQUE: -Pour commenter n'importe quelle chaîne dans TCL, « # » est utilisé. Tous les caractères après le « # » sont ignorés par la commande shell tclsh.

Variable TCL

Une variable est un identifiant qui contient une valeur. Autrement dit, une variable est une référence à la mémoire de l'ordinateur, où la valeur est stockée.

Les variables sont créées par « commande set » et tous les noms de variables sont sensibles à la casse. Cela signifie bonjour, bonjour, BONJOUR, tous sont différents en TCL. Regardez un exemple de variable sensible à la casse.

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

Production:-

% puts $name
% Technoit

%puts  $Name
%Technoit_1

%puts $NAME
%Technoit_2

Création de variables TCL

Pour créer des variables dans TCL, vous devez utiliser "ensemble" commander

lot de 10

Pour obtenir la valeur de la variable, il faut utiliser le symbole « $ » comme

% a mis $a

10%

Nous obtenons donc la valeur de la variable « a » égale à 10.

Les informations sur la commande TCL existent

La commande « set » permet de créer et de lire des variables, comme indiqué ci-dessus. La commande « unset » permet de supprimer une variable. La commande « info exists » renvoie 1 si varName existe en tant que variable (ou élément de tableau) dans le contexte actuel, sinon elle renvoie 0 (voir l’exemple ci-dessous).

En TCL, il existe différentes commandes « info », comme « info exists », « info functions », « info global », etc. Nous allons ici examiner un exemple d’utilisation de « info exists ».

Ex:-

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

Différents appareils orthodontiques et leur comportement

{} -> Accolades

En TCL, les accolades regroupent des mots pour former des arguments. Elles servent à définir un bloc différé, c'est-à-dire qu'il sera exécuté APRÈS le reste de la commande sur la ligne courante. Les caractères entre accolades sont transmis à la commande tels quels.

Quelques points à retenir

1. La substitution de variable n'est pas autorisée entre {} accolades
2. Il est utilisé pour créer un type de données de liste

Exemple:-

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

%set number {1 2 3 4 5} -> Ici, le nombre est un type de données de liste

%met un nombre $

%1 2 3 4 5

[] -> accolades

Les crochets servent à créer des commandes imbriquées. Autrement dit, le résultat d'une commande est passé comme argument à une autre. Les crochets définissent un bloc exécuté AVANT le reste de la commande sur la ligne courante, et son résultat est inséré dans cette ligne.

Ex: -

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

() -> accolades rondes

Cette commande est utilisée pour créer un type de données tableau et également indiquer la priorité des opérateurs.

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

Ici, « a » est un tableau avec les valeurs 10 et 20. Voir ci-dessous les commandes pour imprimer les clés, les paires clé-valeur et les valeurs du tableau.

% 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

Pour imprimer la « Nième » valeur du tableau a, nous utiliserons Puts $a(N)

Arguments de ligne de commande TCL

Les éléments de données transmis à un script à partir de la ligne de commande sont appelés arguments. Le nombre d'arguments de ligne de commande d'un script Tcl est transmis en tant que variable globale argc. Le nom d'un script Tcl est transmis au script en tant que variable globale argv0, et le reste des arguments de ligne de commande sont passés sous forme de liste dans argv.

TCL a 3 variables prédéfinies telles que

$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

sortie:-

• Nombre d'arguments passés aux scripts : 3
• La liste des arguments est transmise au script : 10 20 30
• Le nom du script est : arg-script.tcl

Expression TCL et Operator

Une expression est construite à partir d'opérandes et d'opérateurs. Elle est évaluée avec la commande « expr ». OperaLes opérateurs sont évalués en fonction de la priorité et de l'associativité. Le langage TCL possède des opérateurs intégrés comme ci-dessous

Arithmétique Operator

Une expression TCL consiste en une combinaison d'opérandes, d'opérateurs et de parenthèses. Voyons un exemple d'opérateurs arithmétiques dans TCL

+ Ajouter deux ou plusieurs opérandes

Ex:-

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

– Sous-marintracdeux opérandes ou plus

Ex:-

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

*Multiplier deux opérandes ou plus

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

/ Diviser le numérateur par le dénumérateur

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

L'opérateur % Module divise le numérateur par le dénumérateur mais renvoie un rappel

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

Relationnel Operator

Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit. Si oui, alors la condition devient vraie et renvoie 1, sinon renvoie 0.

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

Vérifiez si la valeur de l’opérande gauche est inférieure à la valeur de l’opérande droit. Si oui, alors la condition devient vraie et renvoie 1, sinon renvoie 0

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

>= Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui alors la condition devient vraie et renvoie 1 sinon renvoie 0

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

<= Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui alors la condition devient vraie et renvoie 1 sinon renvoie 0

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

!= Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales alors la condition devient vraie et renvoie 1 sinon renvoie 0

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

== Vérifie si les valeurs de deux opérandes sont égales ou non, si oui alors la condition devient vraie et renvoie 1 sinon renvoie 0

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

logique Operator

&& Si les deux opérandes sont différents de zéro, alors la condition devient vraie et renvoie 1, sinon renvoie 0

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

|| Si l'un des deux opérandes est différent de zéro, alors la condition devient vraie et renvoie 1, sinon renvoie 0.

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

! Permet d'inverser le résultat d'une expression. Dans le résultat, la valeur de « a » est passée de 0 à 1, tandis que celle de « b » est passée de 1 à 0.

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

Bitwise Operator

& (bit à bit et) effectuez une opération bit par bit et suivez le tableau ci-dessous pour le fonctionnement.

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

| (bit à bit ou) effectuez une opération bit par bit et suivez le tableau ci-dessous

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

^ (exclusif au niveau du bit ou) effectuez une opération bit par bit et suivez le tableau ci-dessous

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

L'opérateur ~ (négation au niveau du bit) change chacun de 1 à 0 et de 0 à 1, suivez le tableau comme référence

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

Ternaire Operator (?:)

La syntaxe est

condition-expression?  expression_1: expression_2

Si condition-exp est vraie, exp1 est évaluée et le résultat est renvoyé. Si cond-exp est faux, exp2 est évalué et son résultat est renvoyé. Dans notre exemple, exp1 est vraie car la valeur de A est supérieure à 6.

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

Shift Operator

Shift L'opérateur est indiqué soit par l'opérateur de décalage à gauche <<, soit par l'opérateur de décalage à droite >>. Pour l'opérateur de décalage à gauche <<, la valeur de l'opérande gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande droit.

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

Pour l'opérateur de décalage vers la droite >>, la valeur de l'opérande de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite.

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

Comparaison de chaînes Operator

L'opérateur de comparaison de chaînes compare les valeurs des deux opérandes. Si les valeurs sont identiques, il renvoie 1 ; sinon, il renvoie 0. Dans l'exemple, les valeurs de A et B sont toutes deux égales à 7, le résultat est donc 1.

Ex:-

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

Ne (si les valeurs des deux opérandes sont différentes, il renverra 1, sinon 0)

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

Opérateur d'exponentiation

Pow () et ** sont tous deux identiques. Il renvoie toujours une valeur flottante.

** indique la puissance de l'opérande souhaité.

Ex:-

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

Liste Operator

Si la valeur requise est trouvée dans la liste définie, la fonction renvoie 1 ; sinon, elle renvoie 0. Dans l’exemple, la valeur 1 existe dans la variable « a », donc la fonction renverra 1.

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

ni, si la valeur requise est trouvée dans la liste définie, elle renverra 0, sinon elle renverra 1.

Ex :-

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

Contrôle de flux TCL et prise de décision

Il existe diverses commandes de contrôle de flux et de prise de décision qui sont utilisées pour modifier le flux d'un programme. Les exécutions du programme commencent toujours du haut du fichier source vers le bas.

L'instruction If consiste en une expression booléenne suivie d'une ou plusieurs instructions.

Si … instruction

Syntaxe:-

si expr ?alors ? corps

si expr est évalué à vrai, alors le corps de la commande est exécuté.

Ex:-

set age 10

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

Output: Age is less than 20

instruction if…else

Syntaxe :-

Si expression ? puis body_1 sinon body_2

Si l'expression est évaluée à vrai, elle renverra body_1 sinon elle renverra 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

Instruction if..else imbriquée

Cela signifie qu'une instruction if ou else..if peut être placée dans une autre instruction if ou else..if.

Syntaxe:-

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

Instruction de commutation

L'instruction switch permet de tester l'égalité d'une variable par rapport à une liste de valeurs. Il évalue la liste de valeurs et renvoie le résultat de cette évaluation. Si aucune valeur ne correspond, les valeurs par défaut seront renvoyées.

Exemple:

#!/usr/bin/tclsh

# switch_cmd.tcl

set domain x
switch $domain {

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

Interrupteur imbriqué

L'instruction switch imbriquée signifie l'instruction switch à l'intérieur d'une instruction switch.

Syntaxe :-

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

ExempleDans l'exemple suivant, la valeur de a est 100, et avec le même code, nous utilisons une instruction switch pour une autre valeur de b, égale à 200. La sortie affichera les valeurs de a et de 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"
        }
     }
   }
}

Production:-

La valeur de a est 100

La valeur de b est 200

Instruction de boucle TCL

L'instruction de boucle permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Tcl propose les types de boucles suivants.ping déclaration.

Pendant que la commande

Lorsqu'une condition donnée est vraie, une instruction ou un groupe d'instructions se répète et se trouve dans le corps de la boucle.

Syntaxe:

While  {condition} {
    Statements
}

Ex :-

#!/usr/bin/tclsh

Set a 10

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

Production:-

a vaut 10

a vaut 11

Dans l'exemple ci-dessus, la commande intégrée « incr » est utilisée. Cela signifie que la valeur de « a » sera incrémentée de 1 jusqu'à sa valeur maximale (inférieure à 12).

Pour la commande

Elle exécute une séquence d'instructions plusieurs fois en fonction de la valeur d'un compteur. Ce dernier est automatiquement incrémenté ou décrémenté à chaque itération de la boucle.

Syntaxe :-

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

ExempleDans l'exemple ci-dessous, la valeur de 'i' est initialement fixée à 0 et incrémentée jusqu'à une valeur inférieure à 5.

#!/usr/bin/tclsh

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

Production:-

0
1
2
3
4

FAQ