仓颉编程入门 -- 循环语句详解

仓颉编程入门 – 循环语句

一 . while 表达式

while 表达式的基本形式为：

while (条件) {
  循环体
}

在while循环中，“条件”是一个必须被评估为布尔类型（true或false）的表达式，而“循环体”则是一个将被重复执行的代码块。while循环的执行流程遵循以下规则：

首先，计算“条件”表达式的值。如果结果为true，则执行第2步；如果结果为false，则直接跳转到第3步。
一旦条件为true，即执行“循环体”中的代码。执行完毕后，自动返回到第1步，重新评估“条件”表达式的值。
如果在某次评估中，“条件”表达式的值为false，则不再执行“循环体”中的代码，而是跳出循环，继续执行紧跟在while循环之后的代码。
重要的是要注意，while表达式中的条件必须能够明确地评估为布尔类型（bool），即它必须是一个能够直接返回true或false的表达式。如果条件表达式无法被评估为布尔类型，或者其值在逻辑上不是布尔值（例如，返回了一个数字、字符串或其他非布尔类型），那么这样的while循环在大多数编程语言中是不合法的，或者会导致运行时错误。

var a:Int = 10
    while(a){
        a--
        println()
    }

必须确保括号中的表达式结果为bool类型

var a:Int = 10
    while(a>0){
        a--
        println(a)
    }

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

main() {
    var root = 0.0
    var min = 1.0
    var max = 2.0
    var error = 1.0
    let tolerance = 0.1 ** 10

    while (error ** 2 > tolerance) {
        root = (min + max) / 2.0
        error = root ** 2 - 2.0
        if (error > 0.0) {
            max = root
        } else {
            min = root
        }
    }
    println("2 的平方根约等于：${root}")
}

二. do-while 表达式表达式

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

do {
  循环体
} while (条件)

您准确地描述了do-while循环的行为。do-while循环与while循环的主要区别在于，do-while循环至少会执行一次循环体，无论条件表达式在首次检查时的结果如何。以下是您描述的do-while循环执行规则的重新表述，保持了大意的一致性：

do-while循环：

在do-while循环中，“条件”是一个布尔类型表达式，用于在每次循环迭代结束时判断是否继续执行循环体；“循环体”则是每次迭代都要执行的代码块。do-while循环的执行流程遵循以下规则：

首先，无条件地执行一次“循环体”中的代码。
执行完毕后，计算“条件”表达式的值。如果结果为true，则返回到第1步，再次执行循环体；如果结果为false，则继续执行do-while循环之后的代码，结束循环。
这种结构确保了循环体至少会被执行一次，因为条件检查是在循环体执行之后才进行的。这与while循环不同，后者在每次迭代开始前都会检查条件，如果条件一开始就是false，则循环体内的代码根本不会执行。

import std.random.*

main() {
    let random = Random()
    var totalPoints = 0
    var hitPoints = 0

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

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

三. for-in 表达式

for-in 表达式可以遍历那些扩展了迭代器接口 Iterable 的类型实例。for-in 表达式的基本形式为：

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

在for-in循环中，我们有一个“序列”表达式，它可以是一个数组、元组或其他任何实现了迭代器接口Iterable<T>的可迭代对象。此外，我们还定义了“迭代变量”，它用于在每轮遍历中接收迭代器指向的数据，并作为局部变量在“循环体”中使用。for-in循环的执行流程如下：

1. 初始化遍历：首先，计算“序列”表达式的值，得到一个可迭代对象。然后，为该对象初始化一个迭代器，准备开始遍历过程。
2. 迭代过程：进入迭代循环，首先尝试通过迭代器获取下一个元素。如果迭代器返回了一个元素，说明遍历尚未结束，继续执行；如果迭代器指示遍历已完成（例如，在Python中通过抛出StopIteration异常，在其他语言中可能通过不同机制表示），则跳转到步骤4。
3. 执行循环体：在每次迭代中，将迭代器当前指向的元素（或元素的多个部分，如果迭代变量是元组）与“迭代变量”绑定。然后，执行“循环体”中的代码。执行完毕后，返回步骤2，继续下一次迭代。
4. 结束循环：当迭代器指示遍历已完成，且最后一次循环体的执行也已完成后，for-in循环结束。控制流随后继续执行for-in表达式之后的代码。

main() {
    let metaArray = [r'甲', r'乙', r'丙', r'丁', r'戊',
        r'己', r'庚', r'辛', r'壬', r'癸']
    let noumenonArray = [r'寅', r'卯', r'辰', r'巳', r'午', r'未',
        r'申', r'酉', r'戌', r'亥', r'子', r'丑']
    let year = 2024
    // 年份对应的天干索引
    let metaOfYear = ((year % 10) + 10 - 4) % 10
    // 此年首月对应的天干索引
    var index = (2 * metaOfYear + 3) % 10 - 1
    println("农历 2024 年各月干支：")
    for (noumenon in noumenonArray) {
        print("${metaArray[index]}${noumenon} ")
        index = (index + 1) % 10
    }
}

输出结果

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

四. 遍历区间

格式 : 起始值 … 终止值

仓颉的遍历区间类似于python的range()

for ( i in 1..100){
        println(i)
    }

其中1…100便是遍历区间的表达方法