仓颉之函数的魔法宝典
1 概述
1.1 背景介绍
仓颉编程语言作为一款面向全场景应用开发的现代编程语言，通过现代语言特性的集成、全方位的编译优化和运行时实现、以及开箱即用的 IDE工具链支持，为开发者打造友好开发体验和卓越程序性能。
案例结合代码体验，让大家更直观的了解仓颉语言中的函数。
1.2 适用对象
- 个人开发者
- 高校学生
1.3 案例时间
本案例总时长预计50分钟。
1.4 案例流程
说明：
① 进入华为开发者空间，登录云主机；
② 使用CodeArts IDE for Cangjie编程和运行仓颉代码。
1.5 资源总览
| 资源名称 | 规格 | 单价（元） | 时长（分钟） |
|---|---|---|---|
| 开发者空间 - 云主机 | 鲲鹏通用计算增强型 kc2 | 4vCPUs | 8G | Ubuntu | 免费 | 50 |
最新案例动态，请查阅 仓颉之函数的魔法宝典。小伙伴快来领取华为开发者空间，进入云主机桌面版实操吧！
2 运行测试环境准备
2.1 开发者空间配置
面向广大开发者群体，华为开发者空间提供一个随时访问的“开发桌面云主机”、丰富的“预配置工具集合”和灵活使用的“场景化资源池”，开发者开箱即用，快速体验华为根技术和资源。
领取云主机后可以直接进入华为开发者空间工作台界面，点击进入桌面连接云主机。没有领取在开发者空间根据指引领取配置云主机即可，云主机配置参考1.5资源总览。
2.2 创建仓颉程序
点击桌面CodeArts IDE for Cangjie，打开编辑器，点击新建工程，保持默认配置，点击创建。
产物类型说明：
- executable，可执行文件；
- static，静态库，是一组预先编译好的目标文件的集合；
- dynamic，动态库，是一种在程序运行时才被加载到内存中的库文件，多个程序共享一个动态库副本，而不是像静态库那样每个程序都包含一份完整的副本。
2.3 运行仓颉工程
创建完成后，打开src/main.cj，参考下面代码简单修改后，点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
package demo
// 第一个仓颉程序
main(): Int64 {
println("hello world")
println("你好，仓颉！")
return 0
}
（* 注意：后续替换main.cj文件代码时，package demo保留）
（* 仓颉注释语法：// 符号之后写单行注释，也可以在一对 /* 和 */ 符号之间写多行注释）
到这里，我们第一个仓颉程序就运行成功啦！后面案例中的示例代码都可以放到main.cj文件中进行执行，接下来我们继续探索仓颉语言。
3 仓颉中的函数
3.1 定义函数
仓颉使用关键字 func 来表示函数定义的开始，func 之后依次是函数名、参数列表、可选的函数返回值类型、函数体。
函数定义举例，具体代码如下：
// 定义了一个名为add的函数
// 参数列表由两个Int64类型的参数a和b组成
// 函数返回值类型为Int64
// 函数体中将a和b相加并返回
func add(a: Int64, b: Int64): Int64 {
return a + b
}
main():Int64 {
return 0
}
参数列表：
一个函数可以有0个或者多个参数。根据函数调用时是否需要给定参数名，可以将参数列表中的参数分为两类：非命名参数和命名参数。
非命名参数的定义方式是 p: T，其中 p 表示参数名，T 表示参数 p 的类型，参数名和其类型间使用冒号连接。
命名参数的定义方式是 p!: T，与非命名参数的不同是在参数名 p 之后多了一个感叹号!。
非命名参数定义举例，具体代码如下：
// add函数的参数列表，定义了两个非命名参数
// 参数名a，参数类型Int64
// 参数名b，参数类型Int64
func add(a: Int64, b: Int64): Int64 {
return a + b
}
main():Int64 {
return 0
}
命名参数定义举例，具体代码如下：
// add函数的参数列表，定义了两个命名参数
// 命名参数a，参数类型Int64，并设置默认值
// 命名参数b，参数类型Int64，并设置默认值
func add(a!: Int64 = 1, b!: Int64 = 1): Int64 {
return a + b
}
main():Int64 {
return 0
}
非命名参数和命名参数使用注意事项：
- 只能为命名参数设置默认值，不能为非命名参数设置默认值；
- 参数列表中可以同时定义非命名参数和命名参数，非命名参数只能定义在命名参数之前；
- 函数参数均为不可变变量，在函数定义内不能对其赋值。
函数返回值类型：
函数返回值类型是函数被调用后得到的值的类型。函数定义时，返回值类型是可选的：可以显式地定义返回值类型，也可以不定义返回值类型，交由编译器推导确定。
函数返回值类型举例，具体代码如下：
// 定义了一个名为add的函数
// 函数返回值类型为Int64
func add(a: Int64, b: Int64): Int64 {
return a + b
}
main():Int64 {
return 0
}
函数体：
函数体中定义了函数被调用时执行的操作，通常包含一系列的变量定义和表达式，也可以包含新的函数定义（即嵌套函数）。如下 add 函数的函数体中首先定义了 Int64 类型的变量 r（初始值为 0），接着将 a + b 的值赋值给 r，最后将 r 的值返回。
有关函数体的举例，具体代码如下：
func add(a: Int64, b: Int64) {
var r = 0
r = a + b
return r
}
main():Int64 {
return 0
}
3.2 调用函数
非命名参数调用举例，具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// add函数，参数为非命名参数
func add(a: Int64, b: Int64) {
return a + b
}
main() {
let x = 1
let y = 2
// 调用add函数
let r = add(x, y)
println("The sum of x and y is ${r}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
命名参数调用举例，具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// add函数，非命名参数a，命名参数b
func add(a: Int64, b!: Int64) {
return a + b
}
main() {
let x = 1
let y = 2
// 调用函数
let r = add(x, b: y)
println("The sum of x and y is ${r}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
对于多个命名参数，调用时的传参顺序可以和定义时的参数顺序不同。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 两个参数都是命名参数
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}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
对于拥有默认值的命名参数，调用时如果没有传实参，那么此参数将使用默认值作为实参的值，具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 函数add，非命名参数a，命名参数b，b有默认值
func add(a: Int64, b!: Int64 = 9) {
return a + b
}
main() {
let x = 1
// 调用时没有传实参，以默认值作为实参的值
let r = add(x)
println("The sum of x and y is ${r}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
对于拥有默认值的命名参数，调用时也可以为其传递新的实参，此时命名参数的值等于新的实参的值，即定义时的默认值将失效。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 函数add，非命名参数a，命名参数b，b有默认值
func add(a: Int64, b!: Int64 = 9) {
return a + b
}
main() {
let x = 5
// 调用时，传递新的实参，默认值将失效
let r = add(x, b: 20)
println("The sum of x and y is ${r}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
3.3 函数类型
仓颉编程语言中，函数是一等公民，可以作为函数的参数或返回值，也可以赋值给变量。因此函数本身也有类型，称之为函数类型。
函数类型由函数的参数类型和返回类型组成，参数类型和返回类型之间使用 -> 连接。
函数类型举例，具体代码如下：
func hello(): Unit {
println("Hello!")
}
上述示例定义了一个函数，函数名为 hello，其类型是 () -> Unit，表示该函数没有参数，返回类型为 Unit。
函数类型另外示例，具体代码如下：
func add(a: Int64, b: Int64): Int64 {
a + b
}
函数名为 add，其类型是 (Int64, Int64) -> Int64，表示该函数有两个参数，两个参数类型均为 Int64，返回类型为 Int64。
函数类型的类型参数：
可以为函数类型标记显式的类型参数名，下面例子中的 name 和 price 就是类型参数名。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
/*
函数名：showFruitPrice
参数：name 和 price
函数返回值类型是：Unit
*/
func showFruitPrice(name: String, price: Int64) {
println("fruit: ${name} price: ${price} yuan")
}
main() {
// 定义变量 fruitPriceHandler
// 变量类型为函数类型：(name: String, price: Int64) -> Unit
let fruitPriceHandler: (name: String, price: Int64) -> Unit
// 赋值
fruitPriceHandler = showFruitPrice
// 调用函数
fruitPriceHandler("banana", 10)
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
注意：对于一个函数类型，只允许统一写类型参数名，或者统一不写类型参数名，不能交替存在。
函数类型作为参数类型：
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 表示该函数有两个参数，两个参数类型均为Int64，返回类型为Int64
func add(a: Int64, b: Int64): Int64 {
a + b
}
/*
函数名为：printAdd
其类型是：((Int64, Int64) -> Int64, Int64, Int64) -> Unit
表示该函数有三个参数，参数类型分别为函数类型 (Int64, Int64) -> Int64和两个Int64，返回类型为Unit
*/
func printAdd(add: (Int64, Int64) -> Int64, a: Int64, b: Int64): Unit {
println(add(a, b))
}
main() {
// 函数调用
printAdd(add,5,5)
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
函数类型作为返回值类型：
函数名为 returnAdd，其类型是 () -> (Int64, Int64) -> Int64，表示该函数无参数，返回类型为函数类型 (Int64, Int64) -> Int64。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
func add(a: Int64, b: Int64): Int64 {
a + b
}
/*
函数名：returnAdd
无参数
返回类型为函数类型：(Int64, Int64) -> Int64
*/
func returnAdd(): (Int64, Int64) -> Int64 {
add
}
main() {
var x = returnAdd()
println(x(1,2))
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
3.4 嵌套函数
定义在源文件顶层的函数被称为全局函数。定义在函数体内的函数被称为嵌套函数。
函数 foo 内定义了一个嵌套函数 nestAdd，可以在 foo 内调用该嵌套函数 nestAdd，也可以将嵌套函数 nestAdd 作为返回值返回，在 foo 外对其进行调用。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
func foo() {
func nestAdd(a: Int64, b: Int64) {
a + b + 3
}
println(nestAdd(1, 2))
return nestAdd
}
main() {
let f = foo()
let x = f(1, 2)
println("result: ${x}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
3.5 Lambda表达式
Lambda 表达式定义：
Lambda 表达式的语法为如下形式： { p1: T1, ..., pn: Tn => expressions | declarations }。
其中，=> 之前为参数列表，多个参数之间使用 , 分隔，每个参数名和参数类型之间使用 : 分隔。=> 之前也可以没有参数。=> 之后为 lambda 表达式体，是一组表达式或声明序列。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
main() {
// 定义Lambda表达式，直接调用
let r1 = { a: Int64, b: Int64 => a * b }(1, 2)
println("result: ${r1}")
// 赋值给变量，通过变量名进行调用
let r2 = { a: Int64, b: Int64 => a + b }
let r3 = r2(1,2)
println("result: ${r3}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
3.6 闭包
一个函数或 lambda 从定义它的静态作用域中捕获了变量，函数或 lambda 和捕获的变量一起被称为一个闭包，这样即使脱离了闭包定义所在的作用域，闭包也能正常运行。
闭包 add，捕获了 let 声明的局部变量 num，之后通过返回值返回到 num 定义的作用域之外，调用 add 时仍可正常访问 num。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 定义函数 returnAddNum，返回值类型是一个函数
func returnAddNum(): (Int64) -> Int64 {
let num: Int64 = 10
func add(a: Int64) {
return a + num
}
add
}
main() {
let f = returnAddNum()
println(f(10))
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
3.7 函数调用语法糖
流操作符包括两种：表示数据流向的中缀操作符 |> （称为 pipeline）和表示函数组合的中缀操作符 ~> （称为 composition）。
尾随 lambda：
尾随 lambda 可以使函数的调用看起来像是语言内置的语法一样，增加语言的可扩展性。
当函数最后一个形参是函数类型，并且函数调用对应的实参是 lambda 时，可以使用尾随 lambda 语法，将 lambda 放在函数调用的尾部，圆括号外面。
下例中定义了一个 myIf 函数，它的第一个参数是 Bool 类型，第二个参数是函数类型。当第一个参数的值为 true 时，返回第二个参数调用后的值，否则返回 0。调用 myIf 时可以像普通函数一样调用，也可以使用尾随 lambda 的方式调用。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 定义函数myIf，第一个参数是Bool类型，第二个参数是函数类型
func myIf(a: Bool, fn: () -> Int64) {
if(a) {
fn()
} else {
0
}
}
func test() {
// 普通函数调用
let a = myIf(true, { => 100 })
println("result: ${a}")
// 尾随 lambda 的方式调用
let b = myIf(true) {10}
println("result: ${b}")
}
main() {
test()
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
Pipeline表达式：
当需要对输入数据做一系列的处理时，可以使用 pipeline 表达式来简化描述。pipeline 表达式的语法形式如下：e1 |> e2。等价于如下形式的语法糖：let v = e1; e2(v) 。
其中 e2 是函数类型的表达式，e1 的类型是 e2 的参数类型的子类型。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
// 数组中的每个元素都加1
func inc(x: Array<Int64>): Array<Int64> {
let s = x.size
var i = 0
for (e in x where i < s) {
x[i] = e + 1
i++
}
x
}
// 数组元素求和
func sum(y: Array<Int64>): Int64 {
var s = 0
for (j in y) {
s += j
}
s
}
main() {
let arr: Array<Int64> = Array<Int64>([1, 3, 5])
// pipeline 表达式
// 等价于，先把arr传入inc函数，再把inc函数的返回值传入sum函数
let res = arr |> inc |> sum
println("result: ${res}")
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
composition表达式：
composition 表达式表示两个单参函数的组合。composition 表达式语法如下： f ~> g。等价于如下形式： { x => g(f(x)) }。
其中 f，g 均为只有一个参数的函数类型的表达式。
f 和 g 组合，则要求 f(x) 的返回类型是 g(...) 的参数类型的子类型。
具体代码如下：
func f(x: Int64): Float64 {
Float64(x)
}
func g(x: Float64): Float64 {
x
}
main() {
// The same as { x: Int64 => g(f(x)) }
var fg = f ~> g
}
3.8 函数重载
函数重载定义？
在仓颉编程语言中，如果一个作用域中，一个函数名对应多个函数定义，这种现象称为函数重载。
- 函数名相同，函数参数不同的两个函数构成重载。
具体代码如下：
// 函数名相同，函数参数不同,构成重载
func f(a: Int64): Unit {
}
func f(a: Float64): Unit {
}
func f(a: Int64, b: Float64): Unit {
}
- 同一个类内的两个构造函数参数不同，构成重载。
具体代码如下：
// 两个构造函数参数不同，构成重载
class C {
var a: Int64
var b: Float64
public init(a: Int64, b: Float64) {
this.a = a
this.b = b
}
public init(a: Int64) {
b = 0.0
this.a = a
}
}
- 同一个类内的主构造函数和 init 构造函数参数不同，构成重载。
具体代码如下：
// 同一个类内的主构造函数和 init 构造函数参数不同，构成重载
class C {
C(var a!: Int64, var b!: Float64) {
this.a = a
this.b = b
}
public init(a: Int64) {
b = 0.0
this.a = a
}
}
- 两个函数名相同，参数不同的函数定义在不同的作用域，在两个函数都可见的作用域中构成重载。
具体代码如下：
// 两个函数名相同，参数不同的函数定义在不同的作用域，在两个函数都可见的作用域中构成重载
func f(a: Int64): Unit {
}
func g() {
func f(a: Float64): Unit {
}
}
- 如果子类中存在与父类同名的函数，并且函数的参数类型不同，则构成函数重载。
具体代码如下：
// 子类中存在与父类同名的函数，并且函数的参数类型不同，则构成函数重载
open class Base {
public func f(a: Int64): Unit {
}
}
class Sub <: Base {
public func f(a: Float64): Unit {
}
}
函数重载决议
函数调用时，所有可被调用的函数构成候选集，候选集中有多个函数，究竟选择候选集中哪个函数，需要进行函数重载决议，有如下规则：
- 优先选择作用域级别高的作用域内的函数；
- 如果作用域级别相对最高的仍有多个函数，则需要选择最匹配的函数；
- 子类和父类认为是同一作用域，选择更匹配的父类中定义的函数
3.9 const函数
const 函数是一类特殊的函数，这些函数具备了可以在编译时求值的能力。在 const 上下文中调用这种函数时，这些函数会在编译时执行计算。而在其它非 const 上下文，const 函数会和普通函数一样在运行时执行。
下例是一个计算平面上两点距离的 const 函数，distance 中使用 let 定义了两个局部变量 dx 和 dy。
具体代码操作如下：
Step1：复制以下代码，替换main.cj文件中的代码。（保留package）
结构类型struct的定义以关键字struct开头，后跟struct的名字，接着是定义在一对花括号中的 struct 定义体。struct 定义体中可以定义一系列的成员变量、成员属性、静态初始化器、构造函数和成员函数。
struct Point {
const Point(let x: Float64, let y: Float64) {}
}
const func distance(a: Point, b: Point) {
let dx = a.x - b.x
let dy = a.y - b.y
(dx**2 + dy**2)**0.5
}
main() {
const a = Point(3.0, 0.0)
const b = Point(0.0, 4.0)
const d = distance(a, b)
println(d)
}
Step2：点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。
至此，仓颉之函数的魔法宝典案例内容已全部完成。
如果想了解更多仓颉编程语言知识可以访问：https://cangjie-lang.cn/
