Tcl 中的过程

最后修改于 2024 年 9 月 25 日

在本教程的这一部分，我们将介绍 Tcl 过程。

过程是一个包含一系列命令的代码块。 过程在许多编程语言中被称为函数。 过程只执行一个特定的任务是一种良好的编程实践。 过程为程序带来了模块化。 正确使用过程带来了以下优势：

• 减少代码重复
• 将复杂问题分解为更简单的部分
• 提高代码清晰度
• 代码重用
• 信息隐藏

有两种基本类型：内置过程和用户定义过程。 内置过程是 Tcl 核心语言的一部分。 例如，rand、sin 和 exp 是内置过程。 用户定义的过程是使用 proc 关键字创建的过程。

proc 关键字用于创建新的 Tcl 命令。 术语过程和命令通常可以互换使用。

我们从一个简单的示例开始。

#!/usr/bin/tclsh

proc tclver {} {

    set v [info tclversion]
    puts "This is Tcl version $v"
}

tclver

在本脚本中，我们创建一个简单的 tclver 过程。 该过程打印 Tcl 语言的版本。

proc tclver {} {

新过程是使用 proc 命令创建的。 {} 字符表明该过程不接受任何参数。

    {

    set v [info tclversion]
    puts "This is Tcl version $v"
}

这是 tclver 过程的主体。 当我们执行 tclver 命令时，它将被执行。 命令的主体位于大括号之间。

tclver

通过指定其名称来调用该过程。

$ ./version.tcl 
This is Tcl version 8.6

示例输出。

过程参数

参数是传递给过程的值。 过程可以接受一个或多个参数。 如果过程处理数据，我们必须将数据传递给过程。

在下面的示例中，我们有一个接受一个参数的过程。

proc ftc {f} {

    return [expr ($f - 32) * 5/9 ]
}

puts [ftc 100]
puts [ftc 0]
puts [ftc 30]

我们创建一个 ftc 过程，将华氏温度转换为摄氏温度。

proc ftc {f} {

该过程接受一个参数。 它的名称 f 将在过程的主体中使用。

return [expr ($f - 32) * 5/9 ]

我们计算摄氏温度的值。 return 命令将值返回给调用者。 如果该过程没有执行显式的 return，则其返回值是该过程主体中执行的最后一个命令的值。

puts [ftc 100]

执行 ftc 过程。 它接受 100 作为参数。 这是华氏温度。 返回值由 puts 命令使用，该命令将其打印到控制台。

$ ./fahrenheit.tcl
37
-18
-2

接下来，我们有一个接受两个参数的过程。

#!/usr/bin/tclsh

proc maximum {x y} {
    
    if {$x > $y} {

        return $x
    } else {
        
        return $y
    }
}

set a 23
set b 32

set val [maximum $a $b]
puts "The max of $a, $b is $val"

maximum 过程返回两个值的最大值。

proc maximum {x y} {

该方法接受两个参数。

if {$x > $y} {

    return $x
} else {
    
    return $y
}

在这里，我们计算哪个数字更大。

set a 23
set b 32

我们定义了两个要比较的变量。

set val [maximum $a $b]

我们计算这两个变量的最大值。

$ ./maximum.tcl
The max of 23, 32 is 32

可变数量的参数

过程可以接受和处理可变数量的参数。 为此，我们使用特殊的 args 参数。

#!/usr/bin/tclsh

proc sum {args} {

    set s 0

    foreach arg $args {

        incr s $arg
    }

    return $s
}

puts [sum 1 2 3 4]
puts [sum 1 2]
puts [sum 4]

我们定义一个 sum 过程，它将所有参数相加。

proc sum {args} {

sum 过程有一个特殊的 args 参数。 它有一个传递给该过程的所有值的列表。

foreach arg $args {

    incr s $arg
}

我们遍历列表并计算总和。

puts [sum 1 2 3 4]
puts [sum 1 2]
puts [sum 4]

我们调用 sum 过程三次。 在第一种情况下，它接受 4 个参数，在第二种情况下接受 2 个参数，在最后一种情况下接受 1 个参数。

$ ./variable.tcl
10
3
4

隐式参数

Tcl 过程中的参数可能具有隐式值。 如果未提供显式值，则使用隐式值。

#!/usr/bin/tclsh

proc power {a {b 2}} {

    if {$b == 2} {
        return [expr $a * $a]
    }

    set value 1

    for {set i 0} {$i<$b} {incr i} {

        set value [expr $value * $a]
    }

    return $value
}

set v1 [power 5]
set v2 [power 5 4]

puts "5^2 is $v1"
puts "5^4 is $v2"

在这里，我们创建一个 power 过程。 该过程有一个带隐式值的参数。 我们可以使用一个或两个参数来调用该过程。

proc power {a {b 2}} {

第二个参数 b 具有隐式值 2。 如果我们只提供一个参数，则 power 过程将返回 a 的 2 次方的值。

set v1 [power 5]
set v2 [power 5 4]

我们使用一个和两个参数调用 power 过程。 第一行计算 5 的 2 次方的值。 第二行计算 5 的 4 次方的值。

$ ./implicit.tcl
5^2 is 25
5^4 is 625

返回多个值

return 命令将一个值传递给调用者。 通常需要返回多个值。 在这种情况下，我们可以返回一个列表。

#!/usr/bin/tclsh

proc tworandoms {} {

    set r1 [expr round(rand()*10)]
    set r2 [expr round(rand()*10)]

    return [list $r1 $r2]
}


puts [tworandoms]
puts [tworandoms]
puts [tworandoms]
puts [tworandoms]

我们有一个 tworandoms 过程。 它返回 1 到 10 之间的两个随机整数。

set r1 [expr round(rand()*10)]

计算一个随机整数并将其设置为 r1 变量。

return [list $r1 $r2]

在 list 命令的帮助下，返回两个值。

$ ./tworandoms.tcl 
3 7
1 3
8 7
9 9

一个示例输出。

递归

递归，在数学和计算机科学中，是一种定义函数的方法，其中正在定义的函数在其自身的定义中被应用。 换句话说，递归函数调用自身来完成其工作。 递归是解决许多编程任务的广泛使用的方法。 递归是函数式语言（如 Scheme、OCalm 或 Clojure）中的基本方法。

Tcl 中的递归调用有限制。 不能超过 1000 次递归调用。

递归的一个典型例子是阶乘的计算。 阶乘 n! 是小于或等于 n 的所有正整数的乘积。

#!/usr/bin/tclsh

proc factorial n {

    if {$n==0} {

        return 1
    } else {

        return [expr $n * [factorial [expr $n - 1]]]
    }
}

# Stack limit between 800 and 1000 levels

puts [factorial 4]
puts [factorial 10]
puts [factorial 18]

在此代码示例中，我们计算了三个数字的阶乘。

return [expr $n * [factorial [expr $n - 1]]]

在 factorial 过程的主体内，我们使用修改后的参数调用 factorial 过程。 该过程调用自身。

$ ./recursion.tcl
24
3628800
6402373705728000

这些是结果。 如果我们尝试计算 100 的阶乘，我们将收到“嵌套计算过多”错误。

范围

在过程内部声明的变量具有过程作用域。 名称的 *作用域* 是程序文本的一个区域，在该区域内，可以引用由该名称声明的实体，而无需限定该名称。 在过程内部声明的变量具有过程作用域；它也被称为局部作用域。 然后，该变量仅在此特定过程中有效。

#!/usr/bin/tclsh

proc test {} {

    puts "inside procedure"
    #puts "x is $x"
    set x 4
    puts "x is $x"
}

set x 1

puts "outside procedure"
puts "x is $x"

test

puts "outside procedure"
puts "x is $x"

在前面的示例中，我们在 test 过程的外部和内部都定义了一个 x 变量。

set x 4
puts "x is $x"

在 test 过程内部，我们定义了一个 x 变量。 该变量具有局部作用域，仅在此过程中有效。

set x 1

puts "outside procedure"
puts "x is $x"

我们在过程外部定义一个 x 变量。 它具有全局作用域。 这些变量不会冲突，因为它们具有不同的作用域。

$ ./scope.tcl
outside procedure
x is 1
inside procedure
x is 4
outside procedure
x is 1

可以在过程内部更改全局变量。

#!/usr/bin/tclsh

proc test {} {

    upvar x y
    puts "inside procedure"
    puts "y is $y"
    set y 4
    puts "y is $y"
}

set x 1

puts "outside procedure"
puts "x is $x"

test

puts "outside procedure"
puts "x is $x"

我们定义一个全局 x 变量。 我们在 test 过程内部更改该变量。

upvar x y

我们通过 upvar 命令使用名称 y 引用全局 x 变量。

set y 4

我们将一个值分配给局部 y 变量，并更改全局 x 变量的值。

$ ./scope2.tcl
outside procedure
x is 1
inside procedure
y is 1
y is 4
outside procedure
x is 4

从输出中，我们可以看到 test 过程已经更改了 x 变量。

使用 global 命令，我们可以从过程中引用全局变量。

#!/usr/bin/tclsh

proc test {} {

    global x 
    puts "inside test procedure x is $x"

    proc nested {} {
        global x
        puts "inside nested x is $x"
    }
}

set x 1

test
nested

puts "outside x is $x"

在上面的示例中，我们有一个 test 过程和一个在 test 过程内定义的嵌套过程。 我们从这两个过程中引用全局 x 变量。

global x 
puts "inside test procedure x is $x"

使用 global 命令，我们引用在 test 过程外部定义的全局 x 变量。

proc nested {} {
    global x
    puts "inside nested x is $x"
}

可以创建嵌套过程。 这些是在其他过程内部定义的过程。 我们使用 global 命令引用全局 x 变量。

test
nested

我们调用 test 过程及其嵌套过程。

$ ./scope3.tcl
inside test procedure x is 1
inside nested x is 1
outside x is 1

在本 Tcl 教程的这一部分，我们介绍了 Tcl 过程。