仓颉语言实战——3.表达式

仓颉语言实战——3.表达式

在编程语言中，表达式是最小的可执行单元，决定了程序的计算能力和逻辑控制。仓颉语言（Cangjie Language）以简洁而灵活的语法为特色，其表达式支持丰富的类型和操作，是构建复杂逻辑的基础。

本篇文章将详细介绍仓颉语言中的表达式，包括基础表达式、复合表达式、控制流表达式和用户自定义表达式，并通过精炼的代码示例，展示如何高效地运用这些特性完成各种任务。

官方网站：仓颉官网

可在线体验哦

一、表达式的基本概念

在仓颉语言中，表达式是一个能够被求值并返回值的语法结构。表达式可以是一个单独的值（如字面量或变量），也可以是更复杂的结构（如函数调用或逻辑操作）。

1. 基本表达式

基本表达式包括字面量、变量和简单的运算操作。

代码示例：基本表达式

# 字面量
let a= 42
let b= 3
let c = "Hello, Cangjie!"

# 简单运算
let sum = a + b
let message = c + " Welcome!"

print(sum)      # 输出: 45
print(message)  # 输出: Hello, Cangjie! Welcome!

在上述代码中，42、3 和 "Hello, Cangjie!" 是字面量，它们通过赋值表达式绑定到变量。

二、运算符与操作表达式

1. 算术运算符

仓颉语言支持常见的算术运算符，包括加法（+）、减法（-）、乘法（*）、除法（/）和取余（%）。

代码示例：算术运算

let x= 10
let y= 3

# 算术运算
let addition = x + y          # 加法
let subtraction = x - y       # 减法
let multiplication = x * y    # 乘法
let division = x / y          # 除法
let modulus = x % y           # 取余

print(addition)        # 输出: 13
print(subtraction)     # 输出: 7
print(multiplication)  # 输出: 30
print(division)        # 输出: 3
print(modulus)         # 输出: 1

2. 比较运算符

比较运算符用于比较两个值，返回布尔值 true 或 false。

代码示例：比较运算

let a = 5
let b = 10

# 比较运算
let equal = a == b       # 是否相等
let not_equal = a != b   # 是否不等
let greater = a > b      # 是否大于
let less = a < b         # 是否小于
let ge = a >= b          # 是否大于等于
let le = a <= b          # 是否小于等于

print(equal)       # 输出: false
print(not_equal)   # 输出: true
print(greater)     # 输出: false
print(less)        # 输出: true
print(ge)          # 输出: false
print(le)          # 输出: true

3. 逻辑运算符

逻辑运算符用于布尔值的组合操作，包括与（&&）、或（||）和非（!）。

代码示例：逻辑运算

let x = true
let y= false

# 逻辑运算
let and_op = x && y      # 与运算
let or_op = x || y       # 或运算
let not_op = !x          # 非运算

print(and_op)    # 输出: false
print(or_op)     # 输出: true
print(not_op)    # 输出: false

三、复合表达式

复合表达式是由多个简单表达式组合而成的复杂结构。它们可以包含函数调用、三元表达式等。

1. 函数调用表达式

函数调用是一种重要的表达式类型，用于执行特定的功能并返回结果。

代码示例：函数调用

func add(x: int, y: int) -> int {
    return x + y
}

let result = add(10, 20)
print(result)  # 输出: 30

2. 三元表达式

三元表达式（condition ? true_value : false_value）根据条件返回不同的值。

代码示例：三元表达式

let age= 18
let category = (age >= 18) ? "Adult" : "Minor"

print(category)  # 输出: Adult

四、控制流表达式

控制流表达式包括条件判断和循环结构，它们可以用作表达式返回值。

1. 条件表达式

条件表达式使用 if-else 语句，根据条件返回值。

代码示例：条件表达式

let score = 85
let grade = if (score >= 90) {
    "A"
} else if (score >= 80) {
    "B"
} else {
    "C"
}

print(grade)  # 输出: B

2. 循环表达式

仓颉语言的循环表达式支持 for 和 while，可用于返回计算结果。

代码示例：循环表达式

# 使用 for 循环计算数组元素的和
let numbers: list[int] = [1, 2, 3, 4, 5]
let sum = for (num in numbers) {
    let acc = 0
    acc += num
}
print(sum)  # 输出: 15

五、用户自定义表达式

用户可以通过自定义函数和嵌套表达式，实现特定功能。

代码示例：递归表达式

以下代码展示了使用递归实现阶乘的计算。

func factorial(n: int) -> int {
    return if (n <= 1) {
        1
    } else {
        n * factorial(n - 1)
    }
}

let result = factorial(5)
print(result)  # 输出: 120

六、高阶表达式与应用

仓颉语言支持高阶表达式，如匿名函数和闭包，用于更灵活的表达式定义。

代码示例：匿名函数与闭包

# 匿名函数
let square = (x: int) -> int {
    return x * x
}
print(square(4))  # 输出: 16

# 闭包
func make_multiplier(factor: int) -> (int -> int) {
    return (x: int) -> int {
        return x * factor
    }
}

let double = make_multiplier(2)
print(double(5))  # 输出: 10

常使用的 while、do-while、break、continue 和 return 表达式介绍

在程序控制结构中，while 和 do-while 循环常用于重复执行某些操作，直到满足特定条件。而 break 和 continue 提供了更灵活的控制流跳转机制，return 则是函数中常用的控制流表达式，用于返回结果或提前终止函数执行。

一、while 循环

while 是一种前置条件判断的循环表达式，它在每次迭代开始之前都会检查条件，只有条件为 true 时，循环体才会执行。

语法

while (条件) {
    循环体
}

代码示例：计算数字总和

以下代码使用 while 循环计算从 1 到 10 的数字总和：

var n = 1
var total = 0

while (n <= 10) {
    total += n
    n += 1
}

print(total)  # 输出: 55

解释：

• 初始条件为 n = 1。
• 在每次循环中，当前的 n 值被累加到 total 中，n 自增 1。
• 当 n > 10 时，循环结束。

二、do-while 循环

do-while 是一种后置条件判断的循环表达式，它会先执行一次循环体，然后再检查条件是否成立。

语法

do {
    循环体
} while (条件)

代码示例：确保用户输入合法数字

以下代码使用 do-while 循环确保用户输入的值在指定范围内：

let input: int

do {
    print("请输入一个 1 到 10 的数字：")
    input = get_input()  # 假设 get_input() 是一个接受用户输入的函数
} while (input < 1 || input > 10)

print("您输入的数字是：", input)

解释：

• 循环体至少执行一次，用户输入会在循环中进行验证。
• 如果输入不合法（如不在 1 到 10 的范围内），循环会继续提示用户输入。

三、break 表达式

break 用于提前终止循环。无论循环的条件是否满足，break 都会直接跳出当前循环。

语法

break

代码示例：查找数组中的指定值

以下代码演示如何使用 break 终止查找操作：

let numbers: list[int] = [1, 2, 3, 4, 5]
let target = 3
let found= false

for (num in numbers) {
    if (num == target) {
        found = true
        break
    }
}

print(found)  # 输出: true

解释：

• 当数组中找到目标值时，break 跳出循环，避免不必要的检查。

四、continue 表达式

continue 用于跳过当前循环的剩余部分，并直接进入下一次迭代。

语法

continue

代码示例：跳过奇数，只处理偶数

以下代码使用 continue 跳过数组中的奇数，仅处理偶数：

let numbers = [1, 2, 3, 4, 5]
let even_numbers= []

for (num in numbers) {
    if (num % 2 != 0) {
        continue
    }
    even_numbers.append(num)
}

print(even_numbers)  # 输出: [2, 4]

解释：

• 当遇到奇数时，continue 直接跳过本次循环，不执行后续的 append 操作。

五、return 表达式

return 用于从函数中返回结果或提前退出函数。

语法

return [返回值]

代码示例 1：简单函数返回值

以下代码定义一个函数，通过 return 返回两数之和：

func add(a: int, b: int) -> int {
    return a + b
}

let result = add(5, 7)
print(result)  # 输出: 12

解释：

• return 将 a + b 的结果返回给调用者。

代码示例 2：提前终止函数

在某些情况下，return 可用于提前终止函数，避免不必要的计算。

func check_positive(num: int) -> string {
    if (num < 0) {
        return "负数"
    }
    return "正数或零"
}

print(check_positive(-5))  # 输出: 负数
print(check_positive(10))  # 输出: 正数或零

解释：

• 如果 num < 0，函数立即返回字符串 "负数"，不会执行后续代码。

六、综合案例：结合多种控制流表达式

以下是一个结合了 while、break 和 continue 的综合案例，计算所有小于 50 的正整数中，能够被 3 整除但不能被 5 整除的数字之和。

代码示例：综合控制流应用

let n = 1
let total= 0

while (n < 50) {
    if (n % 5 == 0) {
        # 跳过能被5整除的数字
        n += 1
        continue
    }
    if (n % 3 == 0) {
        total += n
    }
    n += 1
}

print(total)  # 输出: 468

解释：

• while 控制循环范围。
• continue 跳过能被 5 整除的数字。
• 只有能被 3 整除的数字会累加到 total 中。

七、最佳实践与建议

1. 避免无限循环：

   • 使用 while 时，确保条件能够正确终止，否则可能陷入死循环。
   • 在需要时通过 break 提前终止循环。

2. 优化循环效率：

   • 使用 continue 跳过不必要的计算。
   • 在确定条件后，尽早退出循环（如使用 break）。

3. 合理使用 return：

   • 如果函数中需要多个 return，确保代码逻辑清晰，避免混乱。
   • 仅在需要提前返回或计算结果时使用 return。

八、总结

仓颉语言中的 while、do-while、break、continue 和 return 表达式提供了灵活的控制流管理工具，使得复杂逻辑的实现更加高效和清晰。通过熟练运用这些表达式，开发者可以编写更简洁、更高效的代码。

希望本文的详细解析和代码示例能帮助您更好地掌握这些控制流表达式。如果您有任何疑问或想要讨论的内容，欢迎留言！