仓颉函数定义详解:从 func 语法到参数列表、返回值类型与函数体

原创2026-10-14 23:11:081,936 阅读
文章标签:文档教程

仓颉函数定义详解:从 func 语法到参数列表、返回值类型与函数体

函数是仓颉编程语言中组织逻辑、复用代码的核心单元。本文基于仓颉官方开发者文档中定义函数章节,系统讲解 func 函数定义的整体语法、非命名参数与命名参数的区别与约束、返回值类型的显式声明与编译器推导、以及函数体的类型规则与作用域行为,并结合本仓库中调用函数、嵌套函数、函数重载等配套章节,帮助你从定义到调用、从编译到运行完整掌握仓颉的函数机制。读完本文,你将能够写出符合仓颉语法规范、可编译可运行的函数定义,并理解编译器对返回值推导、参数可变性与作用域遮盖等规则的具体行为。

函数定义的整体语法

仓颉使用关键字 func 表示函数定义的开始。func 之后依次是函数名、参数列表、可选的函数返回值类型和函数体:

  • 函数名:可以是任意的合法标识符。关于标识符的具体规则(普通标识符与原始标识符)可参见标识符章节;
  • 参数列表:定义在一对圆括号 () 内,多个参数之间使用逗号分隔;
  • 返回值类型:参数列表和返回值类型(如果存在)之间使用冒号 : 分隔;
  • 函数体:定义在一对花括号 {} 内。

一个最典型的函数定义示例如下:

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

上例定义了一个名为 add 的函数:参数列表由两个 Int64 类型的参数 a 和 b 组成,函数返回值类型为 Int64,函数体将 a 与 b 相加并返回。

在仓颉的程序结构中,定义在源文件(扩展名为 .cj)顶层作用域的函数被称为全局函数,定义在函数体内的函数被称为局部函数(即下文提到的嵌套函数);而定义在 class、struct 等自定义类型中的函数则被称为成员函数。关于顶层作用域与 main 入口函数的约定,可参见程序结构章节。

下面依次对函数定义中的参数列表、函数返回值类型和函数体作深入介绍。

参数列表

一个函数可以拥有 0 个或多个参数,这些参数均定义在参数列表中。根据函数调用时是否需要给定参数名,参数分为两类:非命名参数和命名参数。

非命名参数

非命名参数的定义方式是 p: T,其中 p 表示参数名,T 表示参数 p 的类型,参数名和类型之间使用冒号连接。例如上文 add 函数的两个参数 a 和 b 均为非命名参数:

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

命名参数

命名参数的定义方式是 p!: T,与非命名参数的区别在于参数名 p 之后多了一个 !。将上例 add 函数的两个非命名参数修改为命名参数:

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

命名参数的默认值

命名参数还可以设置默认值,通过 p!: T = e 的方式将参数 p 的默认值设置为表达式 e 的值。例如,将上述 add 函数的两个参数的默认值都设置为 1:

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

注意:

只能为命名参数设置默认值,不能为非命名参数设置默认值。

参数的排列顺序约束

参数列表中可以同时定义非命名参数和命名参数,但非命名参数只能定义在命名参数之前,命名参数之后不能再出现非命名参数。例如,下例中 add 函数的参数列表定义是不合法的:

func add(a!: Int64, b: Int64): Int64 { // Error, named parameter 'a' must be defined after non-named parameter 'b'
    return a + b
}

非命名参数和命名参数的主要差异在于调用时传参方式的不同:非命名参数对应的实参是一个普通表达式;命名参数对应的实参需要使用 p: e 的形式,其中 p 是命名参数的名字,e 是传递给参数 p 的值。完整的调用规则与示例(包括多个命名参数传参顺序可调换、默认值生效与失效等)可参见调用函数章节,例如命名参数调用时可以打乱传参顺序:

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

main() {
    let x = 1
    let y = 2
    let r = add(b: y, a: x) // 命名参数传参顺序与定义顺序不同,依然合法
    println("The sum of x and y is ${r}")
}

参数的不可变性

函数参数均为不可变变量,在函数定义内不能对其赋值:

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

参数的作用域

函数参数的作用域从定义处起至函数体结束,因此在函数体内不能重新定义与参数同名的变量:

func add(a: Int64, b: Int64): Int64 {
    var a_ = a // OK
    var b = b // Error, redefinition of declaration 'b'
    return a
}

这一行为与仓颉的作用域规则一致:内层作用域可以使用外层作用域中的名字重新定义绑定关系,从而“遮盖”外层同名定义,但同一作用域内不允许重复定义同名元素。关于作用域的详细规则,可参见程序结构章节中的"作用域"小节。

函数返回值类型

函数返回值类型是函数被调用后得到的值的类型。在函数定义时,返回值类型是可选的:既可以显式定义(定义在参数列表和函数体之间),也可以省略交由编译器推导。

显式声明返回值类型

当显式声明返回值类型时,要求函数体的类型(确定方式见下文"函数体"小节)、以及函数体中所有 return e 表达式中 e 的类型,都必须是返回值类型的子类型。例如,若将 add 函数的 return a + b 修改为 return (a, b),元组类型与 Int64 不匹配,编译将报错:

// Error, the type of the expression after return does not match the return type of the function
func add(a: Int64, b: Int64): Int64 {
    return (a, b)
}

由编译器推导返回值类型

如果函数定义时未显式声明返回值类型,编译器将根据函数体的类型以及函数体中所有的 return 表达式共同推导出函数的返回值类型。例如,下例中 add 函数的返回值类型虽然被省略,但编译器可以根据 return a + b 推导出返回值类型为 Int64:

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

注意:

函数的返回值类型并不是任何情况下都可以被推导出来的,如果返回值类型推导失败,编译器会报错。

返回值类型为 Unit 时的特殊行为

指定返回类型为 Unit 时,编译器会在函数体中所有可能返回的地方自动插入表达式 return (),使得函数的返回类型总是为 Unit。Unit 是仓颉中用于表达"只关心副作用、不关心值"的类型,它只有一个值 (),print 函数调用、赋值表达式、循环表达式等的类型都是 Unit,详见Unit 类型章节。

函数体

函数体定义了函数被调用时执行的操作,通常包含一系列的变量定义和表达式,也可以包含新的函数定义(即嵌套函数)。例如,下面 add 函数的函数体首先定义了 Int64 类型的变量 r(初始值为 0),接着将 a + b 的值赋值给 r,最后将 r 的值返回:

func add(a: Int64, b: Int64) {
    var r = 0
    r = a + b
    return r
}

return 表达式的两种形式

在函数体的任意位置都可以使用 return 表达式来终止函数的执行并返回。return 表达式有两种形式:return 和 return expr(expr 是一个表达式)。

形式一:return expr

要求 expr 的类型与函数定义的返回值类型保持一致。例如,下例中因为 return 100 中 100 的类型(Int64)和函数 foo 的返回值类型(String)不同而报错:

// Error, cannot convert an integer literal to type 'Struct-String'
func foo(): String {
    return 100
}

形式二:return

return 等价于 return (),因此要求函数的返回值类型为 Unit:

func add(a: Int64, b: Int64) {
    var r = 0
    r = a + b
    return r
}

func foo(): Unit {
    add(1, 2)
    return
}

注意:

return 表达式作为一个整体,其类型并不由后面跟随的表达式决定,而是 Nothing 类型。Nothing 是仓颉中一种不包含任何值的特殊类型,它是所有类型的子类型(包括 Unit),break、continue、return、throw 表达式的类型均为 Nothing,详见Nothing 类型章节。

局部变量、作用域与"遮盖"

在函数体内定义的变量属于局部变量(如上例中的 r),其作用域从其定义之后开始,到函数体结束。仓颉允许在局部变量的外层作用域中定义同名变量,此时在局部变量的作用域内,局部变量会"遮盖"外层作用域的同名变量。例如:

let r = 0

func add(a: Int64, b: Int64) {
    var r = 0
    r = a + b
    return r
}

上例中,add 函数之前定义了 Int64 类型的全局变量 r,同时 add 函数体内定义了同名的局部变量 r。在函数体内,所有使用变量 r 的地方(如 r = a + b)用到的都是局部变量 r,即局部变量 r"遮盖"了全局变量 r。

函数体的类型

函数体本身也是有类型的:函数体的类型是函数体内最后一"项"的类型——

  • 若最后一项为表达式,则函数体的类型是此表达式的类型;
  • 若最后一项为变量定义或函数声明,或函数体为空,则函数体的类型为 Unit。

例如,下例中函数体的最后一"项"是 Int64 类型的表达式 a + b,所以函数体的类型也是 Int64,与函数定义的返回值类型匹配:

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

又如,下例中函数体的最后一项是 print 函数调用,其类型为 Unit,同样与函数定义的返回值类型匹配:

func foo(): Unit {
    let s = "Hello"
    print(s)
}

理解"函数体最后一'项'决定函数体类型"这一规则,有助于掌握仓颉"表达式式"的编程风格:在函数体中直接以最后一个表达式作为返回值,是仓颉函数定义中非常常见的写法。

深入理解:函数定义与相关特性的协同

函数定义并非孤立存在,它与仓颉的诸多语言特性紧密协同。以下结合本仓库中函数目录下的配套文档,梳理几组关键关联。

嵌套函数

定义在函数体内的函数被称为嵌套函数,其作用域仅限于所在的外部函数,但可以访问外部函数的变量和参数,也可以被外部函数调用或返回。例如:

func foo() {
    func nestAdd(a: Int64, b: Int64) {
        a + b + 3
    }

    println(nestAdd(1, 2)) // 6

    return nestAdd
}

main() {
    let f = foo()
    let x = f(1, 2)
    println("result: ${x}")
}

程序输出:

6
result: 6

注意:嵌套函数的生命周期与外部函数紧密相关,每次外部函数调用时嵌套函数被创建;若嵌套函数被返回并作为闭包使用,可能捕获外部函数的变量,需关注内存管理问题。详见嵌套函数与闭包章节。

函数重载与函数类型

  • 函数重载:在同一作用域中,一个函数名对应多个函数定义即为函数重载(如参数个数不同,或参数个数相同但参数类型不同)。函数重载的判定与决议规则(作用域级别优先、最匹配优先等)详见函数重载章节;
  • 函数类型(一等公民):仓颉中函数是一等公民,可以赋值给变量、作为参数或返回值。函数本身也有类型,由参数类型和返回类型组成,如 add 函数的类型为 (Int64, Int64) -> Int64。当函数被重载时,直接使用函数名作为表达式可能产生歧义而报错,此时需要通过标注变量类型消歧。详见函数类型章节;
  • Lambda 表达式:Lambda 是匿名函数,参数名的作用域与普通函数相同(即函数体部分),且其返回类型与函数返回值类型一样,既可由上下文推断,也可根据 Lambda 体中所有 return 表达式的类型与 Lambda 体的类型共同推导。详见Lambda 表达式章节;
  • const 函数:const 函数是一类可以在编译时求值的特殊函数,其参数类型和返回类型没有特殊规定,但函数内的表达式必须是 const 表达式(const init 除外)。详见const 函数和常量求值章节。

编译与运行

编写好的仓颉函数可以保存在 .cj 源文件中,使用仓颉编译命令 cjc 编译。默认情况下,cjc 会将给定源代码文件编译成可执行文件并命名为 main:

$ cjc hello.cj

关于 cjc 的更多编译选项(如整包编译、指定输出文件名等),可参见cjc 使用及编译选项章节。

小结

仓颉的函数定义围绕 func 关键字展开,核心要点可归纳为:

  1. 语法骨架:func 函数名(参数列表): 返回值类型 { 函数体 },返回值类型可选;
  2. 参数列表:支持非命名参数 p: T 与命名参数 p!: T,命名参数可设默认值 p!: T = e;非命名参数必须位于命名参数之前;参数不可变,其作用域从定义处至函数体结束;
  3. 返回值类型:可显式声明(要求函数体类型与 return expr 中 expr 的类型是其子类型),也可交由编译器推导;指定为 Unit 时编译器会自动补全 return ();
  4. 函数体:以 return / return expr 终止执行;函数体的类型由最后一"项"决定(表达式为其类型,否则为 Unit);局部变量可遮盖外层同名变量。

掌握这些规则,是后续理解函数调用、重载决议、闭包捕获、高阶函数与泛型函数等进阶特性的基础。本文内容对应的官方文档原文位于定义函数,英文版可参考 Defining Functions。

登录后查看全文
cangjie_docs