tcl
Argumentos de procedimiento

Observaciones

Un procedimiento que no acepta argumentos.

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

Una lista de argumentos vacía (el segundo argumento después del nombre del procedimiento, "myproc") significa que el procedimiento no aceptará argumentos.

Un procedimiento que acepta dos argumentos.

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 lista de argumentos consta de palabras, esos serán los nombres de las variables locales en el procedimiento y sus valores iniciales serán iguales a los valores de los argumentos en la línea de comando. Los argumentos se pasan por valor y lo que suceda con los valores de las variables dentro del procedimiento no influirá en el estado de los datos fuera del procedimiento.

Un procedimiento que acepta un número variable de argumentos.

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

Este procedimiento acepta uno, dos o tres argumentos: aquellos parámetros cuyos nombres son el primer elemento en una lista de dos elementos son opcionales. Las variables de parámetros ( alpha , beta , gamma ) obtienen tantos valores de argumento como están disponibles, asignados de izquierda a derecha. Las variables de parámetros que no obtienen ningún valor de argumento obtienen sus valores del segundo elemento de la lista de la que formaban parte.

Tenga en cuenta que los argumentos opcionales deben aparecer al final de la lista de argumentos. Si el argumento _N-1 es opcional, el argumento _{N también} debe ser opcional. Si en un caso, donde el usuario tiene el argumento _N pero no el argumento _N-1 , el valor predeterminado del argumento _N-1 debe mencionarse explícitamente antes del argumento _N , mientras se llama al procedimiento.

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

El procedimiento no acepta más de tres argumentos: tenga en cuenta que se crea automáticamente un mensaje de error útil que describe la sintaxis del argumento.

Un procedimiento que acepta cualquier número de argumentos.

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

Si el nombre de parámetro especial args es el último elemento en la lista de argumentos, recibe una lista de todos los argumentos en ese punto en la línea de comando. Si no hay ninguno, la lista está vacía.

Puede haber argumentos, incluidos los opcionales, antes de args :

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

Este procedimiento aceptará uno o más argumentos. Los primeros dos, si están presentes, serán consumidos por alpha y beta : la lista del resto de los argumentos se asignará a args .

Un procedimiento que acepta un nombre / referencia a una 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

En este caso particular, al procedimiento se le da el nombre de una variable en el alcance actual. Dentro de un procedimiento Tcl, tales variables no son visibles automáticamente, pero el comando upvar puede crear un alias para una variable de otro nivel de pila: 1 significa el nivel de pila de la persona que llama, # 0 significa el nivel global, etc. En este caso, el nivel 1 de la pila y el nombre foo (de la variable de parámetro varName ) permiten que upvar encuentre esa variable y cree un alias llamado var . Cada operación de lectura o escritura en var también pasa a foo en el nivel de pila de la persona que llama.

La sintaxis {*}

A veces, lo que tiene es una lista, pero el comando que desea pasar a los elementos de la lista exige que se obtenga cada elemento como un argumento separado. Por ejemplo: el comando winfo children devuelve una lista de ventanas, pero el comando destroy solo tomará una secuencia de argumentos de nombre de ventana.

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

La solución es usar la sintaxis {*} :

destroy {*}[winfo children .]

o

destroy {*}$alpha

Lo que hace la sintaxis {*} es tomar el siguiente valor (¡sin espacios en blanco entre ellos!) Y empalmar los elementos de ese valor en la línea de comandos como si fueran argumentos individuales.

Si el siguiente valor es una lista vacía, nada se empalma en:

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

Si hay uno o más elementos, se insertan:

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