一、函数定义基础

1.1 函数定义语法结构

仓颉语言使用func关键字定义函数，基本语法如下：

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

完整语法要素：

• func关键字：标识函数定义的开始
• 函数名：遵循标识符命名规则，使用小驼峰命名法
• 参数列表：包含在圆括号内，多个参数用逗号分隔
• 返回值类型：可选部分，通过冒号:与参数列表分隔
• 函数体：包含在大括号{}内的代码块

1.2 函数名与命名规范

仓颉语言的函数命名遵循以下规范：

1. 小驼峰命名法：如calculateTotal
2. 动词开头：表示函数执行的操作，如getUserInfo
3. 避免下划线：不推荐使用_连接单词
4. 模块前缀：公开API推荐使用模块名前缀，如math_sqrt

命名示例：

func calculateCircleArea(radius: Float64): Float64 { return 3.14 * radius * radius } 

1.3 参数列表详解

参数列表的基本结构：

参数名: 参数类型 [= 默认值] 

参数特性：

1. 强类型：必须显式声明参数类型
2. 默认参数：支持提供默认值
3. 命名参数：调用时可指定参数名
4. 不可变参数：默认不可修改（相当于val）

示例：

func createUser( name: String, age: Int64 = 18, isAdmin: Bool = false ): User { // 函数实现 } 

二、函数参数高级特性

2.1 默认参数

仓颉支持为参数指定默认值：

func greet(name: String, greeting: String = "Hello") { println("${greeting}, ${name}!") } 

调用方式：

greet("Alice") // 使用默认greeting greet("Bob", "Hi") // 覆盖默认值 

规则限制：

1. 默认参数必须放在参数列表末尾
2. 默认值必须是编译期常量
3. 默认参数不能与可变参数同时使用

2.2 可变参数

使用...表示可变数量参数：

func sum(numbers: Int64...): Int64 { return numbers.reduce(0) { acc, x => acc + x } } 

特性：

1. 函数内作为数组使用
2. 只能有一个可变参数
3. 必须是参数列表最后一个

调用示例：

let total = sum(1, 2, 3, 4, 5) // 15 

2.3 命名参数与位置参数

命名参数调用：

func connect( host: String, port: Int64, timeout: Int64 = 5000 ) { ... } // 命名参数调用 connect(host = "localhost", port = 8080) 

混合调用规则：

1. 位置参数必须在前
2. 命名参数顺序任意
3. 不能重复指定参数

错误示例：

connect("localhost", port = 8080, 5000) // 错误：位置参数在后 

三、返回值处理

3.1 返回值类型声明

仓颉是强类型语言，返回值类型必须明确：

// 显式声明返回值 func add(a: Int64, b: Int64): Int64 { return a + b } // 无返回值 func log(message: String): Unit { println(message) } 

类型推断：
当函数体是单一表达式时，可省略返回类型：

func square(x: Int64) = x * x // 推断为Int64 

3.2 多返回值处理

通过元组实现多返回值：

func minMax(array: Array<Int64>): (min: Int64, max: Int64) { var min = array  var max = array  for num in array[1..] {  if num < min { min = num }  if num > max { max = num } }  return (min, max) } 

接收多返回值：

let (minVal, maxVal) = minMax( 

3.3 隐式返回

在仓颉中，函数体最后一个表达式的值会自动作为返回值：

func isEven(n: Int64): Bool { n % 2 == 0 // 自动返回 } 

return使用场景：

1. 提前返回
2. 在代码块中明确返回点
3. 返回Unit类型时显式使用

四、函数调用机制

4.1 基本调用方式

标准调用：

let result = add(3, 5) // 8 

命名参数调用：

let user = createUser(name: "Alice", age: 25) 

操作符调用：
仓颉中操作符实际上是特殊函数：

let sum = 3.+(5) // 等同于 3 + 5 

4.2 调用上下文

this隐式传递：
在类方法中，this作为隐式第一个参数：

class Counter { var count = 0 func increment() { count += 1 // 等同于 this.count += 1 } } 

静态调用：
使用类名直接调用静态方法：

Math.pow(2.0, 3.0) // 8.0 

4.3 尾调用优化

仓颉编译器会对尾递归函数进行优化：

func factorial(n: Int64, acc: Int64 = 1): Int64 { if n <= 1 { return acc } return factorial(n - 1, acc * n) // 尾调用 } 

优化条件：

1. 递归调用是函数最后一步操作
2. 调用后不需要执行其他计算
3. 非try/catch块内

五、函数类型与高阶函数

5.1 函数类型表示

仓颉中函数类型表示为：

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

示例：

// 接收两个Int返回Int的函数类型 type BinaryOp = (Int64, Int64) -> Int64 let add: BinaryOp = { a, b => a + b } 

5.2 高阶函数使用

函数作为参数：

func applyOperation( a: Int64, b: Int64, op: (Int64, Int64) -> Int64 ): Int64 { return op(a, b) } 

函数作为返回值：

func makeMultiplier(factor: Int64): (Int64) -> Int64 { return { x => x * factor } } 

5.3 Lambda表达式

匿名函数的简洁写法：

let square = { x: Int64 => x * x } 

特性：

1. 类型可推断时参数类型可省略
2. 单参数时可使用it简写
3. 支持闭包捕获

示例：

let numbers = [1, 2, 3] let doubled = numbers.map { it * 2 } // [2, 4, 6] 

六、函数重载与默认参数

6.1 函数重载规则

仓颉支持函数重载，条件如下：

1. 函数名相同
2. 参数类型不同或参数数量不同
3. 返回值类型不参与重载决议

示例：

func process(value: Int64) { ... } func process(value: String) { ... } func process(a: Int64, b: Int64) { ... } 

限制：

1. 不能仅靠返回值类型不同重载
2. 默认参数不产生新的重载

6.2 默认参数与重载

默认参数不是重载的替代方案：

// 不推荐：用默认参数模拟重载 func connect(host: String, port: Int64 = 8080) { ... } // 推荐：明确重载 func connect(host: String) { connect(host, 8080) } func connect(host: String, port: Int64) { ... } 

七、特殊函数类型

7.1 扩展函数

为已有类型添加扩展函数：

extend Int64 { func isEven(): Bool { this % 2 == 0 } } let even = 42.isEven() // true 

限制：

1. 不能修改原始类型
2. 不能添加存储属性
3. 优先级低于原生方法

7.2 操作符重载

重载算术操作符：

struct Vector2D { var x: Float64 var y: Float64 operator func +(other: Vector2D): Vector2D { return Vector2D(x: x + other.x, y: y + other.y) } } 

可重载操作符：

1. 算术运算符：+, -, *, /, %
2. 比较运算符：==, !=, <, >, <=, >=
3. 位运算符：&, |, ^, ~, <<, >>

7.3 内联函数

使用inline优化高阶函数：

inline func measureTime(block: () -> Unit): Float64 { let start = now() block() return now() - start } 

优化效果：

1. 减少函数调用开销
2. 生成更高效的代码
3. 可能增加代码体积

八、函数最佳实践

8.1 设计原则

1. 单一职责：每个函数只做一件事
2. 合理长度：建议不超过20行
3. 明确命名：函数名应准确描述功能
4. 最少参数：参数不宜过多（建议≤5个）
5. 无副作用：纯函数更易于测试和维护

8.2 性能优化

1. 避免嵌套过深：减少闭包捕获开销
2. 尾递归优化：适用递归场景
3. 内联小函数：高频调用的小函数
4. 批量处理：减少高频调用的开销

8.3 错误处理

返回Result类型：

func parseNumber(str: String): Result<Int64, ParseError> { // 可能失败的操作 return Ok(parsedValue) // 或 return Err(ParseError.InvalidFormat) } 

异常处理：

func riskyOperation(): Int64 throws { if badCondition { throw OperationError.BadCase } return result } try { let value = riskyOperation() } catch e: OperationError { handleError(e) } 

结语

仓颉语言的函数机制既保留了现代编程语言的通用特性，又通过精心设计的语法规则和类型系统提供了强大的表达能力和安全性。理解函数定义与调用的各种细节，掌握高阶函数和特殊函数的使用技巧，遵循函数设计的最佳实践，能够帮助开发者编写出更加模块化、可维护和高性能的仓颉代码。在实际开发中，应根据具体场景合理选择函数设计模式，平衡灵活性与类型安全，充分发挥仓颉函数式编程的优势。