if表达式#

if表达式的基本形式为:

1
if (条件) {
2
  分支 1
3
} else {
4
  分支 2
5
}

其中”条件”可以是一个布尔类型的表达式, 或者一个 “let pattern” (语法糖), 或者多个 “let pattern” 和布尔类型的表达式之间 通过 逻辑与 或 逻辑或 直接连接形成的表达式

涉及 “let pattern” 的介绍和示例, 参照涉及 “let pattern” 的”条件”示例

仓颉中的if表达式, 与C/C++中的if从结构上看, 长得一样

但仓颉的if表达式的条件, 必须是Bool类型的表达式 或let pattern(模式匹配的一种语法糖), 当然也可以通过&&和||连接

当表达式和模式匹配成功时, 该模式匹配的值为true, 此时执行if分支对应的代码块; 反之, 为false, 执行else分支代码块, else分支可以不存在

“分支 1”和”分支 2”是两个代码块

if表达式将按如下规则执行:

1. 计算”条件”表达式, 如果值为true则转到第2步, 值为false则转到第3步

2. 执行”分支 1”, 并转到第4步

3. 执行”分支 2”, 并转到第4步

4. 继续执行if表达式后面的代码

在一些场景中, 可能只关注条件成立时该做些什么, 所以else和对应的代码块是允许省略的

如下程序演示了if表达式的基本用法:

1
import std.random.*
2

3
main() {
4
    let number: Int8 = Random().nextInt8()
5
    println(number)
6
    if (number % 2 == 0) {
7
        println("偶数")
8
    } else {
9
        println("奇数")
10
    }
11
}

在这段程序中, 使用仓颉标准库的random包生成了一个随机整数, 然后使用if表达式判断这个整数是否能被2整除, 并在不同的条件分支中打印”偶数”或”奇数”

if表达式的条件, 最终值类型一定要是Bool, 执行的规则与C/C++一致, if(条件)条件是true就执行if的代码块, 否则执行之后else代码块

仓颉的else分支也可以省略, 可以只存在if分支

仓颉编程语言是强类型的, if表达式的条件只能是布尔类型, 不能使用整数或浮点数等类型

和 C 语言等不同, 仓颉不以条件取值是否为 0 作为分支选择依据, 例如以下程序将编译报错(此外, 后文的错误的表达式示例补充了更多错误的表达式用例场景, 可对比参照):

1
main() {
2
    let number = 1
3
    if (number) {           // 编译错误, 类型不匹配
4
        println("非零数")
5
    }
6
}

仓颉是强类型语言, 仓颉的基础数据类型之间, 不允许类型转换, 即 不存在0当作false, 非0当作true使用的情况, 就如上面的这个例子中所示

甚至, 如果都是整数类型, 不同大小范围的整数类型之间也禁止出现类型转换, 甚至禁止相互赋值, 比如:

1
main() {
2
    var int8: Int8 = 0
3
    var int16: Int16 = 0
4

5
    int8 = int16
6
    int16 = int8
7
}

这个例子, 也会报错: 类型不匹配, Int8类型的变量 和Int16类型的变量之间是无法赋值的

即使范围不会溢出, 但 仓颉是强类型语言, 认为Int8和Int16是两个完全不同的类型

这在C/C++这种弱类型语言上 根本无法想象

在许多场景中, 当一个条件不成立时, 可能还要判断另一个或多个条件, 再执行对应的动作

仓颉允许在else之后跟随新的if表达式, 由此支持多级条件判断和分支执行, 例如:

1
import std.random.*
2

3
main() {
4
    let speed = Random().nextFloat64() * 20.0
5
    println("${speed} km/s")
6
    if (speed > 16.7) {
7
        println("第三宇宙速度, 鹊桥相会")
8
    } else if (speed > 11.2) {
9
        println("第二宇宙速度, 嫦娥奔月")
10
    } else if (speed > 7.9) {
11
        println("第一宇宙速度, 腾云驾雾")
12
    } else {
13
        println("脚踏实地, 仰望星空")
14
    }
15
}

仓颉也存在else if, 用来在首个if条件不满足时, 另外判断多个条件 并执行相应的代码块

if表达式的值与类型, 需要根据使用形式与场景来确定:

• 当含else分支的if表达式被求值时, 需要根据求值上下文确定if表达式的类型:

  • 如果上下文明确要求值类型为T, 则if表达式各分支代码块的类型必须是T的子类型, 这时if表达式的类型被确定为T, 如果不满足子类型约束, 编译会报错

  • 如果上下文没有明确的类型要求, 则if表达式的类型是其各分支代码块类型的最小公共父类型, 如果最小公共父类型不存在, 编译会报错

  如果编译通过, 则if表达式的值就是所执行分支代码块的值

• 如果含else分支的if表达式没有被求值, 在这种场景里, 开发者一般只想在不同分支里做不同操作, 不会关注各分支最后一个表达式的值与类型, 为了不让上述类型检查规则影响这一思维习惯, 仓颉规定这种场景下的if表达式类型为Unit、值为(), 且各分支不参与上述类型检查

• 对于不含else分支的if表达式, 由于if分支也可能不被执行, 所以规定这类if表达式的类型为Unit、值为()

例如, 以下程序基于if表达式求值, 模拟一次简单的模数转换过程:

1
main() {
2
    let zero: Int8 = 0
3
    let one: Int8 = 1
4
    let voltage = 5.0
5
    let bit = if (voltage < 2.5) {
6
        zero
7
    } else {
8
        one
9
    }
10
}

在以上程序中, if表达式作为变量定义的初值使用, 由于变量bit没有被标注类型、需要从初值中推导, 所以if表达式的类型取为两个分支代码块类型的最小公共父类型

根据前文对”代码块”的介绍, 可知两个分支代码块类型都是Int8, 所以if表达式的类型被确定为Int8, 其值为所执行分支即else分支代码块的值, 所以变量bit的类型为Int8、值为1

求if表达式的类型和值的方式, 根据下面这两种情况 再具体分析

1. 是否被求值, 即 是否需要使用if表达式的值, 比如 是否要将if表达式的值 赋值给某个变量 或 当作实参传参等

2. 是否含else分支

具体是这样的:

1. 如果不含else分支, 无论被不被求值, 因为if分支可能并不被执行, 所以此时, if表达式的类型和值 恒为Unit和()

2. 如果不被求值, 则表示 不在意if表达式的类型和值, 此时, if表达式类型和值 恒为Unit和()

3. 如果被求值, 则根据上下文的目标类型, 来对if表达式做类型检查

   上下文的目标类型, 举例子就是: 要赋值的变量的类型 或 函数调用形参的类型等

   此时, 又分两种情况:

   1. 上下文指定目标类型, 比如:let res: Bool或func cal(param: Int64)等

      此时, if表达式的所有分支的代码块, 都必须要为目标类型的子类型, if表达式的最终类型会被转换为目标类型, 值还是最终执行的代码块的值

      如果存在分支的代码块, 不为目标类型的子类型, 则编译报错

   2. 上下文没有指定目标类型

      此时, if表达式的所有分支的代码块, 需要存在一个最小公共父类型, 即 存在一个共同祖先类型, if表达式的最终类型会被转换为这个最小共父类型, 值还是最终执行的代码块的值 如果, if表达式的所有分支的代码块不存在最小公共夫类型, 则编译报错

其实也并不复杂, 各分支代码块的类型和值, 满足要求就可以

while表达式#

while表达式的基本形式为:

1
while (条件) {
2
  循环体
3
}

其中”条件”同if表达式的”条件”, “循环体”是一个代码块

while表达式将按如下规则执行:

1. 计算”条件”表达式, 如果值为true则转第2步, 值为false转第3步

2. 执行”循环体”, 并转第1步

3. 结束循环, 继续执行while表达式后面的代码

例如, 以下程序使用while表达式, 基于二分法, 近似计算数字2的平方根:

1
main() {
2
    var root = 0.0
3
    var min = 1.0
4
    var max = 2.0
5
    var error = 1.0
6
    let tolerance = 0.1 ** 10
7

8
    while (error ** 2 > tolerance) {
9
        root = (min + max) / 2.0
10
        error = root ** 2 - 2.0
11
        if (error > 0.0) {
12
            max = root
13
        } else {
14
            min = root
15
        }
16
    }
17
    println("2 的平方根约等于: ${root}")
18
}

运行以上程序, 将输出:

1
2 的平方根约等于: 1.414215

while(条件)表达式, 条件与if(条件)表达式的条件规则保持一致

while表达式需要先对条件进行判断

而且, while表达式也是条件成立时, 才执行代码块的内容, 条件成立即为true

但不同的是, while是循环判断条件是否成立, 如果成立也就是循环执行代码块

do-while表达式#

do-while表达式的基本形式为:

1
do {
2
  循环体
3
} while (条件)

其中”条件”是布尔类型表达式, “循环体”是一个代码块

do-while表达式将按如下规则执行:

1. 执行”循环体”, 转第2步.

2. 计算”条件”表达式, 如果值为true则转第1步, 值为false转第3步

3. 结束循环, 继续执行do-while表达式后面的代码

例如, 以下程序使用do-while表达式, 基于蒙特卡洛算法, 近似计算圆周率的值:

1
import std.random.*
2

3
main() {
4
    let random = Random()
5
    var totalPoints = 0
6
    var hitPoints = 0
7

8
    do {
9
        // 在 ((0, 0), (1, 1)) 这个正方形中随机取点
10
        let x = random.nextFloat64()
11
        let y = random.nextFloat64()
12
        // 判断是否落在正方形内接圆里
13
        if ((x - 0.5) ** 2 + (y - 0.5) ** 2 < 0.25) {
14
            hitPoints++
15
        }
16
        totalPoints++
17
    } while (totalPoints < 1000000)
18

19
    let pi = 4.0 * Float64(hitPoints) / Float64(totalPoints)
20
    println("圆周率近似值为: ${pi}")
21
}

运行以上程序, 将输出:

1
圆周率近似值为: 3.141872

说明:

由于算法涉及随机数, 所以每次运行程序输出的数值可能都不同, 但都会约等于3.14

do-while表达式也是一个循环表达式

但do-while与while不同, do-while是先执行一遍代码块之后, 在判断条件是否成立 是否继续进行下一次循环

也是因为此, do-while的条件中不允许存在匹配模式, 只能是Bool类型的表达式

for-in表达式#

for-in表达式可以遍历那些扩展了迭代器接口Iterable<T>的类型实例

for-in表达式的基本形式为:

1
for (迭代变量 in 序列) {
2
  循环体
3
}

其中”循环体”是一个代码块

“迭代变量”是单个标识符或由多个标识符构成的元组, 用于绑定每轮遍历中由迭代器指向的数据, 可以作为”循环体”中的局部变量使用

“序列”是一个表达式, 它只会被计算一次, 遍历是针对此表达式的值进行的, 其类型必须扩展了迭代器接口Iterable<T>

for-in表达式将按如下规则执行:

1. 计算”序列”表达式, 将其值作为遍历对象, 并初始化遍历对象的迭代器

2. 更新迭代器, 如果迭代器终止, 转第4步, 否则转第3步

3. 将当前迭代器指向的数据与”迭代变量”绑定, 并执行”循环体”, 转第2步

4. 结束循环, 继续执行for-in表达式后面的代码

说明:

仓颉内置的区间和数组等类型已经扩展了Iterable<T>接口

例如, 以下程序使用for-in表达式, 遍历中国地支字符构成的数组noumenonArray, 输出农历 2024 年各月的干支纪法:

1
main() {
2
    let metaArray = [r'甲', r'乙', r'丙', r'丁', r'戊', r'己', r'庚', r'辛', r'壬', r'癸']
3
    let noumenonArray = [r'寅', r'卯', r'辰', r'巳', r'午', r'未', r'申', r'酉', r'戌', r'亥', r'子', r'丑']
4
    let year = 2024
5

6
    // 年份对应的天干索引
7
    let metaOfYear = ((year % 10) + 10 - 4) % 10
8
    // 此年首月对应的天干索引
9
    var index = (2 * metaOfYear + 3) % 10 - 1
10

11
    println("农历 2024 年各月干支: ")
12
    for (noumenon in noumenonArray) {
13
        print("${metaArray[index]}${noumenon} ")
14
        index = (index + 1) % 10
15
    }
16
}

其中r开头的字符表示字符类型字面量

运行以上程序, 将输出:

1
农历 2024 年各月干支:
2
丙寅 丁卯 戊辰 己巳 庚午 辛未 壬申 癸酉 甲戌 乙亥 丙子 丁丑

仓颉for-in是遍历/迭代循环, 完整为for (迭代变量 in 序列) {}, 序列即为迭代目标

for-in的功能, 是从序列的头开始, 逐个元素迭代/遍历, 到序列的尾结束

每次迭代, 序列的当前元素都会被拷贝/引用到迭代变量, 通过迭代变量就可以访问到当前迭代到的元素值

拷贝或引用, 当然取决于元素的实际类型

举个更简单一些的例子:

1
main() {
2
    for (elem in 0..=20) {
3
        print("${elem} ")
4
    }
5
    println()
6
}

从一个序列的头0开始, 一直迭代到序列的尾20结束

for-in迭代的序列, 必须要实现Iterable<T>接口, 此接口从名字上来看, 就是可迭代的意思

for-in类似C++中的范围for, 均为迭代器迭代有限的序列

1
main() {
2
    for (elem in 0..=10:2) {
3
        println(elem)
4
    }
5
}

break和continue表达式#

在循环结构的程序中, 有时需要根据特定条件提前结束循环或跳过本轮循环, 为此仓颉引入了break与continue表达式, 它们可以出现在循环表达式的循环体中

break用于终止当前循环表达式的执行、转去执行循环表达式之后的代码, continue用于提前结束本轮循环、进入下一轮循环

break与continue表达式的类型都是 Nothing

例如, 以下程序使用for-in表达式和break表达式, 在给定的整数数组中, 找到第一个能被5整除的数字:

1
main() {
2
    let numbers = [12, 18, 25, 36, 49, 55]
3
    for (number in numbers) {
4
        if (number % 5 == 0) {
5
            println(number)
6
            break
7
        }
8
    }
9
}

当for-in迭代至numbers数组的第三个数25时, 由于25可以被5整除, 所以将执行if分支中的println和break, break将终止for-in循环, numbers中的后续数字不会被遍历到

因此运行以上程序, 将输出:

1
25

以下程序使用for-in表达式和continue表达式, 将给定整数数组中的奇数打印出来:

1
main() {
2
    let numbers = [12, 18, 25, 36, 49, 55]
3
    for (number in numbers) {
4
        if (number % 2 == 0) {
5
            continue
6
        }
7
        println(number)
8
    }
9
}

在循环迭代中, 当number是偶数时, continue将被执行, 这会提前结束本轮循环, 进入下一轮循环, println不会被执行. 因此运行以上程序, 将输出:

1
25
2
49
3
55

如果你已经接触过其他的编程语言, 那么这仓颉中的两个表达式 大概率不会存在什么问题

break和continue都可以出现在任意循环体中:

break被执行时, 会直接结束循环

continue被执行时, 会跳过本趟循环, 直接进入下一趟循环

break和continue的类型恒是Nothing