Tutoriel TCL TK : Langage de commande d'outil

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 des chaînes et également un langage procédural. Il a été créé pour la première fois par John Osterhout en 1989. Le but du développement de ce langage est de faciliter l'intégration d'applications inti ( ). Le langage est couramment utilisé pour les interfaces graphiques et les tests. Par exemple, le prototypage rapide, Essais interaction avec la base de données, etc. Dans TCL, par défaut, tout est une chaîne.

Dans ce tutoriel, vous apprendrez-

Comment exécuter TCL

Il existe deux façons 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/Unix interpréteur interactif, nous pouvons exécuter les scripts TCL comme ci-dessous

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

Tutoriel TCL : Langage de commande d'outil

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

Dans TCL, la commande « Puts » est utilisée pour imprimer des messages sur la console. La syntaxe des puts est ci-dessous

met ?-pas de nouvelle ligne ? ?Identifiant de la chaine? 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

Carré brackets sont utilisés pour la substitution de commandes.

Exemple:-

% puts [expr 1*3]
% 3

Ici la commande entre le carré brackets est évalué en premier. Les résultats sont renvoyés ..”expr” 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 échapper les caractères spéciaux ainsi que pour répartir les commandes longues sur plusieurs lignes. N'importe quel personnage suit immédiatementwing la barre oblique inverse restera sans substitution. Dans l'exemple ci-dessous, vous pouvez voir le caractère spécial « » qui reste 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. En d’autres termes, une variable est une référence à une mémoire d’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 » est utilisée pour créer et lire des variables comme indiqué ci-dessus. La commande unset est utilisée pour détruire une variable. La commande « info existe » renvoie 1 si varName existe en tant que variable (ou élément de tableau) dans le contexte actuel, autrewise renvoie 0. (voir exemple ci-dessous).

Il existe diverses commandes « info » dans TCL telles que « info existe », « fonctions d'information », « info globale », etc. Nous verrons ici un exemple de « l'information existe ».

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

Les accolades en TCL regroupent les mots pour devenir des arguments. Les accolades sont utilisées pour définir un bloc différé – en d'autres termes, il peut être exécuté APRÈS le reste de la commande sur la ligne actuelle. Les caractères entre accolades sont transmis à une commande exactement tels qu’ils sont écrits.

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

Carré brackets sont utilisés pour créer une commande imbriquée. En termes simples, sortie d'une commande passée en argument à une autre commande. Carré brackets sont utilisés pour définir un bloc qui est exécuté AVANT le reste de la commande sur la ligne actuelle, et le résultat est substitué dans la 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 et opérateur TCL

L'expression est construite à partir d'opérandes et d'opérateurs. Il est évalué avec la commande "expr". Les opérateurs sont évalués en fonction de la priorité et de l'associativité. Le langage TCL a des opérateurs intégrés comme ci-dessous

Catégorie d'opérateur Symbole Priorité/Associativité
Opérateur arithmétique + - * / % De gauche à droite
Opérateur relationnel == != < > <= >= De gauche à droite
Opérateur logique && || ! De gauche à droite
Bitwise Opérateur & | ^ ~ De gauche à droite
Opérateur ternaire ?: De droite à gauche
Opérateur de quart << >> De gauche à droite
Opérateur de comparaison de chaînes équivalence De gauche à droite
Opérateur d'exponentiation ** De gauche à droite
Opérateur de liste En ni De gauche à droite

Opérateur arithmétique

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

- Soustrait deux ou plusieurs opérandes

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

Opérateur relationnel

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

Opérateur logique

&& 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

! Utilisé pour inverser le résultat de n’importe quelle expression. Ici, dans la sortie, vous pouvez voir que la valeur de « a » est maintenant passée de 1 à 0. Alors que la valeur de « b » est passée de 0 à 1.

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

Bitwise Opérateur

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

A B A & B
0 0 0
0 1 0
1 1 1
1 0 0

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 

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

A B Un | B
0 0 0
0 1 1
1 1 1
1 0 1

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 

^ (un peuwise exclusif ou) effectuez une opération bit par bit et suivez le tableau ci-dessous

A B UNE ^ B
0 0 0
0 1 1
1 1 0
1 0 1

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

~ (peuwise négation) l'opérateur change chaque 1 en 0 et 0 en 1, suivez le tableau comme référence

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

Opérateur ternaire (?:)

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

Opérateur de quart

L'opérateur de décalage est désigné soit par << opérateur de décalage à gauche, soit par l'opérateur de décalage >> à droite. Pour l'opérateur << gauche shift), 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

Opérateur de comparaison de chaînes

Opérateur de comparaison de chaînes compares la valeur des deux opérandes. Si la valeur de l'opérande est la même, alors il renverra 1, sinon 0. Dans l'exemple, la valeur pour A et B est 7, donc le résultat renvoie 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

Opérateur de liste

Si la valeur requise est trouvée dans la liste définie, elle renvoie 1, sinon elle renvoie 0. Dans l'exemple, la valeur 1 existe dans la variable « a », elle renverra donc 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... déclaration

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

Si ... sinon déclaration

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
         }
      }
   }

Exemple: Dans la suitewing Par exemple, la valeur de a est 100, et avec le même code, nous changeons d'instruction pour une autre valeur de b est 200. La sortie affichera la valeur pour a et 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 Loop permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Tcl fournit le suivantwing types d'instructions en boucle.

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 augmentée de 1 jusqu'à la valeur maximale (<12).

Pour la commande

Il exécute une séquence d'instructions plusieurs fois en fonction d'une valeur de compteur. Il est automatiquement augmenté ou diminué à chaque répétition de la boucle.

Syntaxe :-

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

Exemple: Dans l'exemple ci-dessous, la valeur de « i » est définie sur 0 et incrémentée jusqu'à la valeur <5.

#!/usr/bin/tclsh

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

Production:-

0 
1 
2 
3 
4

Résumé :

  • TCL est un langage de script basé sur des chaînes et également un langage procédural
  • Le langage est couramment utilisé pour les interfaces graphiques et les tests
  • Dans TCL, par défaut, tout est une chaîne
  • 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.
  • Le programme TCL devrait avoir l'extension .tcl