华为仓颉语言的函数初步

函数是一段完成特定任务的独立代码片段，可以通过函数名字来标识，这个名字可以被用来调用函数。

要特别注意，与C/C++、Python等语言不同，仓颉禁止参数重新赋值——函数参数均为不可变（immutable）变量，在函数定义内不能对其赋值。也就是说，仓颉函数参数与 let 声明的变量一样，只能读取，不能再次赋值。例如：
func demo(x: Int64): Int64 {
x = x + 1 // ❌ 编译错误
return x
}

如果需要修改，只能引入新的局部变量：
func demo(x: Int64): Int64 {
let y = x + 1 // ✅ 正确
return y
}

这说明，仓颉语言语言设计决策强化对不可变性和函数式编程范式的偏好。

函数定义

基本语法：仓颉语言使用func关键字来定义函数，后跟函数名、参数列表、可选的返回值类型以及函数体。其基本语法为：

func 函数名(参数列表): 返回值类型 {

// 函数体

return 返回值

}

参数列表：函数可以有 0 个或多个参数，参数分为非命名参数和命名参数。非命名参数定义为p: T，如a: Int64；命名参数定义为p!: T，如a!: Int64，且只能为命名参数设置默认值，非命名参数不能设置默认值，参数列表中非命名参数只能定义在命名参数之前。

返回值类型：必须显式写出返回类型，除非返回Unit（可以省略）。

函数体定义在一对花括号内。函数体中定义了函数被调用时执行的操作，通常包含一系列的变量定义和表达式，也可以包含新的函数定义（即嵌套函数）。

函数定义示例

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

如果函数体是单个表达式，仓颉也支持隐式返回（省略 return 关键字）：

func add(a: Int64, b: Int64): Int64 {
a + b // 最后一行表达式的值即为返回值
}

函数参数示例

非命名参数 (Non-named Parameters): 即普通参数，调用时按顺序传递。非命名参数必须定义在命名参数之前。例如：

// 定义一个包含两个非命名参数的函数
func multiply(a: Int64, b: Int64): Int64 {return a * b
}main() {// 调用函数（必须按顺序传递参数，无需指定参数名）let result = multiply(3, 4)  // 正确调用，返回12println(result) 
}

命名参数 (Named Parameters): 在参数名后加 !，调用时需指定参数名，并可提供默认值，提高了代码可读性和灵活性。例如：

// 定义包含命名参数的函数（带默认值）
func calculateTotal(price: Int64, quantity!: Int64 = 1, discount!: Float64 = 0.0): Int64 {
let total = Float64(price * quantity) // 先转成 Float64
let discounted = total * (1.0 - discount) // 浮点运算
return Int64(discounted) // 再转回整数
}

注意：

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

参数列表中可以同时定义非命名参数和命名参数，但是需要注意的是，非命名参数只能定义在命名参数之前，也就意味着命名参数之后不能再出现非命名参数。例如，下例中 add 函数的参数列表定义是不合法的：

func add(a!: Int64, b: Int64): Int64 { // 错误！
return a + b
}

调用函数规则

a.非命名参数调用

调用规则：必须按定义顺序传递，不能指定参数名。

b.命名参数调用

必须用参数名: 值形式传递，顺序可任意调整，且支持使用默认值。

c.混合参数调用（非命名 + 命名）

非命名参数必须先定义、先传递，命名参数在后，且命名参数必须指定参数名。

示例：

// 定义包含命名参数的函数（带默认值）
func calculateTotal(price: Int64, quantity!: Int64 = 1, discount!: Float64 = 0.0): Int64 {let total = Float64(price * quantity)      // 先转成 Float64let discounted = total * (1.0 - discount)    // 浮点运算return Int64(discounted)                     // 再转回整数
}main() {// 调用方式1：只传非命名参数（price），命名参数用默认值let total1 = calculateTotal(100)  // quantity默认1，discount默认0 → 结果100println(total1)// 调用方式2：指定部分命名参数（可调整顺序）let total2 = calculateTotal(100, discount: 0.2, quantity: 2)  // 计算：100 * 2 * (1-0.2) = 160 → 结果160println(total2)// 调用方式3：显式指定所有参数名let total3 = calculateTotal(200, quantity: 3, discount: 0.1)  // 计算：200 * 3 * 0.9 = 540 → 结果540println(total3)
}

返回值类型的说明

在仓颉语言（Cangjie）的正式规范中：

必须显式写出返回类型，当返回类型为 Unit 时可省略 -> Unit。

// ✅ 合法

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

// ❌ 不合法- 函数体中有返回值的表达式时必须声明返回类型

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

如果函数没有有意义的返回值（即返回 Unit），可以写成 : Unit，也可以直接省略返回类型部分。

// 等价写法

func log(msg: String) { println(msg) } // 省略 : Unit

func log(msg: String): Unit { println(msg) } // 显式 : Unit

log("你好") //调用

单值返回和多值返回（Tuple）

单值返回示例：

// 返回单个 Int64
func square(n: Int64): Int64 {return n * n
}main(): Unit {let s = square(7)   println("square = ${s}")  //square = 49
}

多值返回（Tuple）示例：

// 返回一个二元组 (Int64, Int64)
func divmod(a: Int64, b: Int64): (Int64, Int64) {return (a / b, a % b)
}main(): Unit {let (q, r) = divmod(10, 3)   // q = 3, r = 1println("quotient = ${q}, remainder = ${r}")  //quotient = 3, remainder = 1
}

函数类型（Function Type）

仓颉编程语言中，函数是一等公民（first-class citizens），可以作为函数的参数或返回值，也可以赋值给变量。因此函数本身也有类型，称之为函数类型。

函数类型由函数的参数类型和返回类型组成，参数类型和返回类型之间使用 -> 连接。参数类型使用圆括号 () 括起来，可以有 0 个或多个参数，如果参数超过一个，参数类型之间使用逗号（,）分隔。

函数类型是编程中一个比较抽象但极其强大的概念，是函数式编程范式（FP）的核心基石之一。

函数类型的语法非常直观，遵循以下格式：

(参数1类型, 参数2类型, ...) -> 返回值类型

解释一下：

• 括号 ()：里面放置函数的参数类型列表。如果没有参数，就空着 ()。

• 箭头 ->：连接参数和返回值，读作“返回”。

• 返回值类型：在箭头后面，指定函数返回的数据类型。

例如：

没参数也要空括号：() -> Unit

多个参数逗号隔：(Int, String) -> Bool

返回元组括号包：(Int, Int) -> (Int, Int)

函数类型既可以根据函数定义隐式存在，也可以由程序员在代码中显式地书写出来。

1. 隐式的函数类型 (由函数定义产生)

例子：

// 【函数定义】

// 程序员写的是具体的实现

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

return a + b

}

// 【隐式的函数类型】

// 编译器会自动识别出这个函数有一个类型：(Int64, Int64) -> Int64

// 这个类型是“依据函数定义存在的”，程序员没有显式写出 `(Int64, Int64) -> Int64` 这几个字。

2. 显式的函数类型 (由程序员主动书写)

你完全可以先写出类型，再去找或定义一个符合该类型的函数（甚至用变量、lambda、函数值等）。

例子

// 1. 【显式地用于变量声明】

// 程序员主动写下了类型注解 `: (Int64, Int64) -> Int64`

let myMathOperator: (Int64, Int64) -> Int64 = add // 将函数`add`赋值给变量

// 2. 【显式地用于函数参数】

// 程序员定义了一个高阶函数，它接受一个函数作为参数

// 参数 `operation` 的类型被显式地定义为 `(Int64, Int64) -> Int64`

func calculate(operation: (Int64, Int64) -> Int64, x: Int64, y: Int64) -> Int64 {

return operation(x, y)

}

// 3. 【显式地用于解决重载歧义】

func add(i: Int64, j: Int64) -> Int64 { i + j }

func add(i: Float64, j: Float64) -> Float64 { i + j }

// 这里直接写 `add` 编译器不知道选哪个，产生歧义

// let f = add // Error!

// 程序员通过【显式地书写类型】来告诉编译器需要哪个函数

let f: (Int64, Int64) -> Int64 = add // OK

函数类型的核心用途

1. 声明函数类型的变量

在仓颉中，声明变量必须显式或通过初始化值来表明类型。

// 定义一个函数
func add(a: Int64, b: Int64): Int64 {return a + b
}main() {// 正确声明1: 显式指定变量类型，再赋值函数let operation: (Int64, Int64) -> Int64 // 声明一个函数类型的变量operation = add // 将函数赋值给变量// 正确声明2: 声明的同时初始化（类型由编译器推断）let anotherOperation = add // 编译器能推断出anotherOperation的类型是 (Int64, Int64) -> Int64//现在，operation或anotherOperation就代表了 add 函数let result = operation(5, 3)println(result) // 输出 8let result2 = anotherOperation(5, 3)println(result2) // 输出 8
}

2. 作为函数的参数（高阶函数）

// 导入标准库中的集合包
import std.collection.ArrayList // 使用ArrayList// 高阶函数的参数类型使用函数类型 (Int64) -> String
// 输入和输出使用 ArrayList 类型
func processNumbers(numbers: ArrayList<Int64>, transform: (Int64) -> String): ArrayList<String> {// 创建一个新的 ArrayList 来存放结果let results = ArrayList<String>()// 遍历输入的 ArrayList - 使用 for-in 循环for(num in numbers) {// 调用传入的 transform 函数处理每个元素let transformedValue = transform(num)// 将结果添加到新的集合中results.add(transformedValue)}return results
}// 处理行为的函数定义不变
func intToString(num: Int64): String {return "Number: ${num}"
}main() {// 使用 ArrayList 而不是原生数组let myNumbers = ArrayList<Int64>([1, 2, 3, 4, 5])// 调用方式完全一样，传递函数名let resultList = processNumbers(myNumbers, intToString)// 遍历结果 ArrayList - 使用 for-in 循环for (str in resultList) {println(str)}// 同样可以使用 Lambda 表达式let squaredList = processNumbers(myNumbers, { n => "Squared: ${n * n}" })// 遍历 squaredListfor (str in squaredList) {println(str)}
}

3. 作为函数的返回值

// 这个函数返回一个 () -> String 类型的函数
func getGreeter(prefix: String): () -> String {// 在内部定义一个函数，它捕获了参数 `prefix`func greeter(): String {return "${prefix}, Hello!" }return greeter // 返回这个内部函数
}main() {// getGreeter 返回的是一个函数let casualGreet = getGreeter("Hi")let formalGreet = getGreeter("Good morning")// 调用返回的函数println(casualGreet()) // 输出: Hi, Hello!println(formalGreet()) // 输出: Good morning, Hello!
}

顺便提示，先把函数定义好，再传递函数名。也可可以用Lambda 表达式（匿名函数），下面示例对比：

import std.collection.ArrayList // 使用ArrayList// 高阶函数的参数类型使用函数类型 (Int64) -> String
// 输入和输出使用 ArrayList 类型
func processNumbers(numbers: ArrayList<Int64>, transform: (Int64) -> String): ArrayList<String> {// 创建一个新的 ArrayList 来存放结果let results = ArrayList<String>()// 遍历输入的 ArrayList - 使用 for-in 循环for(num in numbers) {// 调用传入的 transform 函数处理每个元素let transformedValue = transform(num)// 将结果添加到新的集合中results.add(transformedValue)}return results
}main() {// 使用 ArrayList 而不是原生数组let myNumbers = ArrayList<Int64>([1, 2, 3, 4, 5])// ---------1.具名函数（普通写法）------------    // 先写一个具名函数func multiply10(num: Int64): String {return "Value is: ${num * 10}"}// 把函数名当参数传进去let result = processNumbers(myNumbers, multiply10)    // 遍历结果for(str in result) {println(str)}println("-----------")// ---------2.Lambda 表达式（匿名写法）------------ // Lambda 表达式写法let result2 = processNumbers(myNumbers, { num => "Value is: ${num * 10}" })    // 遍历结果for(str in result2) {println(str)}
}

特别提示，可给函数类型的参数标记显式名称（仅用于标识，不影响类型匹配），且需统一写或统一不写，不能混合。

示例：

// 首先定义 showFruitPrice 函数
func showFruitPrice(name: String, price: Int64): Unit {println("Fruit: ${name}, Price: ${price}")
}main() {// 1. 全部写名字 —— 合法let handler1: (name: String, price: Int64) -> Unit = showFruitPrice// 2. 全部不写名字 —— 合法  let handler2: (String, Int64) -> Unit = showFruitPrice// 3. 混写 —— 非法，编译时报错// let handler3: (name: String, Int64) -> Unit   // Error: 必须统一写或统一不写参数名// 调用函数handler1("apple", 5)   // 正确handler2("apple", 5)   // 同样正确
}