tcl
Structures de contrôle

Syntaxe

• si expr1? alors? body1 elseif expr2? alors? body2 ...? sinon? ? bodyN?
• pour tester le prochain corps
• tout en test corps
• foreach varlist1 list1? varlist2 list2 ...? corps

Remarques

Ajout d'une nouvelle structure de contrôle à Tcl

Dans Tcl, une structure de contrôle est simplement une autre commande. C'est une mise en œuvre possible de do ... while / do ... until la structure de contrôle.

proc do {body keyword expression} {
    uplevel 1 $body
    switch $keyword {
        while {uplevel 1 [list while $expression $body]}
        until {uplevel 1 [list while !($expression) $body]}
        default {
            return -code error "unknown keyword \"$keyword\": must be until or while"
        }
    }
}

Ce qui est commun aux deux types de do Loops, c'est que le script nommé body sera toujours exécuté au moins une fois, donc nous le faisons tout de suite. L'invocation uplevel 1 $body signifie "exécuter le script au niveau de la pile de l'appelant". De cette façon, toutes les variables utilisées par le script seront visibles et tous les résultats produits resteront au niveau de l'appelant. Le script sélectionne ensuite, en fonction du paramètre de keyword - keyword , s'il convient d'itérer lorsqu'une condition est vraie ou jusqu'à ce qu'elle soit fausse, ce qui équivaut à une itération alors que la négation logique de la condition est vraie. Si un mot-clé inattendu est donné, un message d'erreur est généré.

si / pendant / pour

si expr1 ? alors? body1 elseif expr2 ? alors? body2 ...? sinon? ? bodyN?

exprN est une expression qui donne une valeur booléenne. bodyN est une liste de commandes.

set i 5
if {$i < 10} {
  puts {hello world}
} elseif {$i < 70} {
  puts {enjoy world}
} else {
  puts {goodbye world}
}

pour tester le prochain corps

start , next et body sont des listes de commandes. test est une expression qui donne une valeur booléenne.

La commande break va sortir de la boucle. La commande continue passera à la prochaine itération de la boucle.

L'utilisation commune est:

for {set i 0} {$i < 5} {incr i} {
  puts "$i: hello world"
}

Puisque start et next sont des listes de commandes, toutes les commandes peuvent être présentes.

for {set i 0; set j 5} {$i < 5} {incr i; incr j -1} {
  puts "i:$i j:$j"
}

tout en test corps

Le test est une expression qui donne une valeur booléenne. Tant que le test est vrai, le corps est exécuté.

set x 0
while {$x < 5} {
  puts "hello world"
  incr x
}

La commande break va sortir de la boucle. La commande continue passera à la prochaine itération de la boucle.

set lineCount 0
while {[gets stdin line] >= 0} {
  puts "[incr lineCount]: $line"
  if { $line eq "exit" } {
    break
  }  
}

Itération de liste: foreach

foreach varlist1 list1 ? varlist2 liste2 ...? corps

foreach est une structure de contrôle puissante qui permet de parcourir une liste ou plusieurs listes.

set alpha [list a b c d e f]
foreach {key} $alpha {
   puts "key: $key"
}

Plusieurs noms de variables peuvent être spécifiés.

set alphaindexes [list a 1 b 2 c 3 d 4 e 5 f 6]
foreach {key num} $alphaindexes {
   puts "key:$key num:$num"
}

Plusieurs listes peuvent être répétées en même temps.

set alpha [list a b c d e f]
set indexes [list 1 2 3 4 5 6]
foreach {key} $alpha {idx} $indexes {
   puts "key: $key idx:$idx"
}