tcl
Arguments de procédure

Remarques

Une procédure qui n'accepte pas les arguments

proc myproc {} {
    puts "hi"
}
myproc
# => hi

Une liste d'arguments vide (le deuxième argument après le nom de la procédure, "myproc") signifie que la procédure n'acceptera pas d'arguments.

Une procédure qui accepte deux arguments

proc myproc {alpha beta} {
    ...
    set foo $alpha
    set beta $bar     ;# note: possibly useless invocation
}

myproc 12 34          ;# alpha will be 12, beta will be 34

Si la liste d'arguments est constituée de mots, ceux-ci seront les noms des variables locales dans la procédure et leurs valeurs initiales seront égales aux valeurs d'argument sur la ligne de commande. Les arguments sont transmis par valeur et tout ce qui arrive aux valeurs des variables dans la procédure n'influencera pas l'état des données en dehors de la procédure.

Une procédure qui accepte un nombre variable d'arguments

### Definition
proc myproc {alpha {beta {}} {gamma green}} {
    puts [list $alpha $beta $gamma]
}

### Use
myproc A
# => A {} green
myproc A B
# => A B green
myproc A B C
# => A B C

Cette procédure accepte un, deux ou trois arguments: les paramètres dont le nom est le premier élément d'une liste à deux éléments sont facultatifs. Les variables de paramètre ( alpha , beta , gamma ) obtiennent autant de valeurs d’argument que disponibles, attribuées de gauche à droite. Les variables de paramètre qui n'obtiennent aucune valeur d'argument obtiennent leurs valeurs du deuxième élément de la liste dont elles faisaient partie.

Notez que les arguments facultatifs doivent figurer à la fin de la liste des arguments. Si l'argument _N-1 est facultatif, l'argument _N doit également être facultatif. Si, dans un cas, l'utilisateur a l'argument _N mais pas l'argument _N-1 , la valeur par défaut de l'argument _N-1 doit être explicitement mentionnée avant l'argument _N , lors de l'appel de la procédure.

myproc A B C D
# (ERROR) wrong # args: should be "myproc alpha ?beta? ?gamma?"

La procédure n'accepte pas plus de trois arguments: notez qu'un message d'erreur utile décrivant la syntaxe de l'argument est automatiquement créé.

Une procédure qui accepte un nombre quelconque d'arguments

proc myproc args { ... }
proc myproc {args} { ... } ;# equivalent

Si le nom du paramètre spécial args est le dernier élément de la liste d'arguments, il reçoit une liste de tous les arguments à ce stade dans la ligne de commande. S'il n'y en a pas, la liste est vide.

Il peut y avoir des arguments, y compris ceux en option, avant args :

proc myproc {alpha {beta {}} args} { ... }

Cette procédure acceptera un ou plusieurs arguments. Les deux premiers, s'ils sont présents, seront consommés par alpha et beta : la liste des autres arguments sera assignée à args .

Une procédure qui accepte un nom / une référence à une variable

proc myproc {varName alpha beta} {
    upvar 1 $varName var
    set var [expr {$var * $alpha + $beta}]
}
set foo 1
myproc foo 10 5
puts $foo
# => 15

Dans ce cas particulier, la procédure reçoit le nom d'une variable dans la portée actuelle. Dans une procédure Tcl, ces variables ne sont pas automatiquement visibles, mais la commande upvar peut créer un alias pour une variable à partir d’un autre niveau de pile: 1 signifie le niveau de pile de l’appelant, # 0 le niveau global, etc. le niveau de pile 1 et le nom foo (de la variable de paramètre varName ) permettent à upvar trouver cette variable et de créer un alias appelé var . Chaque lecture ou d' écriture sur var se trouve également foo dans le niveau de la pile de l'appelant.

La syntaxe {*}

Parfois, vous avez une liste, mais la commande que vous souhaitez transmettre aux éléments de la liste pour obtenir chaque élément en tant qu’argument distinct. Par exemple: la commande winfo children renvoie une liste de fenêtres, mais la commande destroy ne prend qu'une séquence d'arguments de nom de fenêtre.

set alpha [winfo children .]
# => .a .b .c
destroy $alpha
# (no response, no windows are destroyed)

La solution consiste à utiliser la syntaxe {*} :

destroy {*}[winfo children .]

ou

destroy {*}$alpha

La syntaxe de {*} consiste à prendre la valeur suivante (pas d’espace entre les deux!) Et à épisser les éléments de cette valeur dans la ligne de commande comme s’ils étaient des arguments individuels.

Si la valeur suivante est une liste vide, rien n'est joint:

puts [list a b {*}{} c d]
# => a b c d

S'il y a un ou plusieurs articles, ils sont insérés:

puts [list a b {*}{1 2 3} c d]
# => a b 1 2 3 c d