函数定义与多返回值

本章导读

第 8 章的 grade 函数、第 10 章的 work 函数，我们已经悄悄用过函数了。本卷（第 11–15 章）把函数系统讲透，本章是第一块基石：怎么定义、怎么传参、怎么返回——包括 xlang 一个讨喜的特性：一个函数可以返回多个值，商和余数一次拿回，不用再借道输出参数。

函数是程序组织的分水岭：此前你写"脚本"，此后你写"系统"。本章的每个知识点都会在此后 47 章里反复使用。

11.1 func 基本形态

函数定义的完整骨架：func 名字(参数列表) as 返回类型 ... end。

func add(int a, int b) as int
    return a + b
end

println(string(add(3, 4)))    // 7

拆解四个部分：

• 参数列表：每个参数写类型，int a、string name；无参就空括号 ()；
• as 返回类型：声明这个函数承诺返回什么；
• 函数体：换行开始，遵守块级作用域（参数与体内变量都只在函数内有效）；
• end：与 if/while 同款的显式收尾。

return 把值交还给调用方并立即结束函数。第 8 章的守卫子句模式在这里名正言顺：

func grade(int s) as string
    if s >= 90 then
        return "A"
    elseif s >= 60 then
        return "B"
    else
        return "C"
    end
end

一个当前版本的形态限制：函数不能嵌套定义——func 体内再写 func 是语法错误。所有函数都定义在顶层，彼此平级。想在一处逻辑里"藏"一个小函数？第 13 章的匿名函数与闭包才是正解。

11.2 参数与类型检查

xlang 的函数调用是静态检查的：实参的数量和类型都必须与形参匹配，不匹配在编译期就被拦下，错误信息直白：

注意"重载签名"这个措辞——xlang 支持同名函数的重载（第 14 章专题），编译器按实参找匹配签名，找不到才报错。本章先记住：调用不匹配的函数，错误在编译期暴露，不会拖到运行时。

参数在函数体内是普通局部变量，遵守第 4 章的作用域规则，且不能再同名声明：

参数传递的细节——值传递还是引用传递、byval/byref/out——内容较多，第 12 章参数体系专题讲解，本章先用最普通的传法。

11.3 无返回值的函数

不写 as 子句，函数就没有返回值——它因副作用而存在（打印、写文件、改全局状态）：

func hello()
    println("hello")
end

hello()

无返回值函数里写 return 值 会被编译器拒绝（expected 0, actual 1，见坑 3）；反之，声明了 as T 的函数，每条 return 都必须带够值。

一个需要警惕的实测行为：声明了 as 却没有 return 的函数，会静默返回零值（int 得 0），编译器目前不警告：

func answer() as int
    // 忘写 return
end
println(string(answer()))    // 输出 0——不是报错！

这是 RC0 的已知粗糙处（详见拾遗 2）。纪律：写完 as 函数立即检查每条路径都有 return——编译器暂时不替你盯这件事。

11.4 多返回值与解构

xlang 的招牌特性之一：函数可以返回多个值，用 as (T1, T2) 声明，return 时用逗号列出：

func divmod(int a, int b) as (int, int)
    return a / b, a % b
end

auto q, r = divmod(17, 5)
println(string(q) + " ... " + string(r))

接收侧的规矩（每条都有实测报错撑腰）：

• 必须多值接收——auto a = divmod(...) 单变量接多返回，报 [sem] 多返回值函数调用必须使用多值接收；
• 数量必须相等——auto a, b, c = divmod(...) 报 [sem] 多返回值声明数量和函数返回值数量不匹配: expected 2, actual 3；
• 用 auto 解构——第 3 章已确立：auto q, r = f() 合法，而 auto q, r = 1, 2 这类并列字面量非法。解构专为多返回值设计。

解构出的 q、r 类型分别推断为声明的返回类型（int、int），此后就是普通变量。

多返回值的经典用武之地：同时给结果和状态（商与余数、值与是否成功、解析结果与错误描述）。第 10 章的异常负责"意外"，多返回值负责"预期内的多路输出"——两者互补而非竞争。

11.5 声明顺序与前向引用

变量必须"先声明后使用"（第 4 章），函数不受此限——调用可以写在定义之前：

println(string(later(2, 3)))    // 6：此处 later 还没定义

func later(int a, int b) as int
    return a * b
end

原因在编译模型：编译器第一遍收集全部顶层函数签名，第二遍才解析函数体——所以函数彼此"同时可见"，互相调用、环形调用（A 调 B、B 调 A）都合法，这也是递归（下节）能写的前提。变量则不同：顶层变量按顺序初始化，顺序错了照样报 undeclared。

工程建议：虽然顺序自由，还是按"自底向上"或"入口在前、细节在后"的固定风格组织文件——读者不该为找函数定义翻遍全文。

11.6 递归

函数调用自己，就是递归。两要素：基例（不再递归的终止分支）与递推（向基例收缩的自调用）。

func fact(int n) as int
    if n <= 1 then
        return 1                    // 基例
    end
    return n * fact(n - 1)        // 递推
end
println(string(fact(10)))         // 3628800

func fib(int n) as int
    if n < 2 then
        return n
    end
    return fib(n - 1) + fib(n - 2)
end
println(string(fib(25)))          // 75025

递归深度的边界必须实测才知道：笔者用"每层只加 1 的裸递归"探测，本机 5500 层正常返回，6000 层进程崩溃（退出码 127，无任何诊断信息）——没有 Python 那种 RecursionError，栈耗尽就是硬着陆。

工程推论：

• 业务递归（树遍历、分治）深度通常几十层，放心用；
• 深度与输入规模线性相关的算法（如"处理 n 层嵌套数据"），深递归改迭代（第 9 章循环 + 显式栈），别赌输入不会变长；
• fib 这种指数级重复计算的递归只是教学演示，实战请写循环版——第 9 章练习 1 你写过。

11.7 main 入口的特殊性

第 2 章说过：顶层语句本身就是程序入口。xlang 还支持显式入口函数 main，但它的形态有强制规定：

func main(...) as int
    println("argc=" + string(arg.length))
    return 42
end

三条特殊性：

• 参数必须是 ...（可变参数，第 12 章详解），写成 func main() as int 报 [sem] main 入口参数必须是 ...，由 arg 接收 argc/argv；
• 命令行参数经 arg 数组访问——arg[0] 是脚本路径（第 5 章已实测），所以上例 3 个用户参数对应 argc=4；
• main 的 return 值就是进程退出码——上例退出码恰为 42。写命令行工具时，0 表示成功、非 0 表示失败的惯例就靠它落地。

顶层语句与 main 的关系：两者都是入口形态，小程序用顶层语句足够；需要规范退出码或系统处理命令行参数时，显式 main 更正式。

深入细节

⚠️ 常见错误

以下报错全部来自真实编译器输出（文件路径已缩短）。

本章小结

复习题

编程练习