跟我一起学“仓颉”编程语言—作用域、函数重载和递归函数

本章为大家详细的介绍了仓颉编程语言中函数的作用域、函数重载、递归函数的内容。

Cool_foolisher

1225人浏览 · 2025-05-15 22:25:22

Cool_foolisher · 2025-05-15 22:25:22 发布

一、作用域

在程序中声明的变量或创建的函数，它们只在一定范围内起作用，那么把这些可以起作用的范围，叫做作用域。

全局作用域

在仓颉源文件顶层定义的变量或者函数，称为全局变量或全局函数，全局作用域是包内可见的。

package Study

var num = 2

func fun1() {
    num++
    return num
}

func fun2() {
    num--
    return num
}

main(): Int64 {
    println(num)
    println(fun1())
    println(fun2())
    return 0
}

局部作用域

package Study

// 函数的局部作用域
func fun1() {
    let x = 5
    println(x)
}

println(x) // 错误代码

main(): Int64 {
    println(x) // 错误代码

    // 模板字符串的局部作用域
    println("${var a = 3; var b = 4}")
    println(a) // 错误代码

    // 分支结构的局部作用域
    if (true) {
        let num = 5
        println(num)
    }
    println(num) // 错误代码

    // 循环结构的局部作用域
    var i = 0
    while(i < 1) {
        var b = 2
        println(b)
    }
    println(b) // 错误代码
    
    return 0
}

同名变量

没有相交（交集）作用域的同名变量

package Study

func fun(num!:Int64) {
    return num
}

main(): Int64 {
    var num = 5
    println(num)
    println(fun(num: 1))
    return 0
}

有相交（交集）作用域的同名变量

package Study

var num = 2

main(): Int64 {
    println(num)
    var num = 5
    println(num)
    return 0
}

注意：在有相交（交集）作用域的同名变量，优先访问作用域小的变量，作用域小的变量覆盖了作用域大的变量。

二、函数重载

有时同一种功能的函数，有多种实现方式。在同一作用域中，定义了多个函数，这些函数有以下特点：

函数名相同；
函数参数类型不同；
函数参数个数不同；

就把这些函数称为：函数重载

package Study

func add(x: Int64, y: Int64) {
    return x + y
}

func add(x: Float64, y: Float64) {
    return x + y
}

func add(x: Int64) {
    return x + 1
}

main(): Int64 {
    println(add(1, 1))
    println(add(1.2, 0.8))
    println(add(1))
    return 0
}

注意：如果是改变函数参数的变量名，则不算函数重载。

package Study

func add(x: Int64, y: Int64) {
    return x + y
}

func add(a: Int64, b: Int64) {
    return a + b
}

main(): Int64 {
    println(add(1, 1))
    println(add(1, 2))
    return 0
}

三、递归函数

如果在函数体内调用了该函数本身，则称该函数是递归函数。数学中最著名的递归是斐波那契数列和汉诺塔游戏。

package Study

func fun(n: Int64): Int64 {
    if (n > 0) {
        println(n)
        return fun(n - 1)
    } else {
        return 0
    }
}

main(): Int64 {
    println(fun(3))
    return 0
}

注意：递归函数必须有一个明确的结束条件。