一、引言

仓颉（Cangjie）是华为开发的新一代编程语言，其运算符系统设计简洁而强大。掌握运算符的使用是编写高效仓颉代码的基础。本文将全面介绍仓颉语言中的各类运算符及其使用方法。🚀

二、算术运算符

2.1 基本算术运算符

仓颉支持常见的算术运算符，用于执行数学计算：

加法运算符 +

let a = 10
let b = 20
let sum = a + b  // 结果：30

减法运算符 -

let difference = b - a  // 结果：10

乘法运算符 *

let product = a * b  // 结果：200

除法运算符 /

let quotient = b / a  // 结果：2
let floatDiv = 5.0 / 2.0  // 结果：2.5

取模运算符 %

let remainder = 23 % 5  // 结果：3

2.2 一元运算符

正号 + 和负号 -

let positive = +10  // 结果：10
let negative = -10  // 结果：-10
let x = 5
let negX = -x  // 结果：-5

2.3 复合赋值运算符

仓颉支持算术运算与赋值的组合：

var count = 10
count += 5   // 等价于 count = count + 5，结果：15
count -= 3   // 等价于 count = count - 3，结果：12
count *= 2   // 等价于 count = count * 2，结果：24
count /= 4   // 等价于 count = count / 4，结果：6
count %= 4   // 等价于 count = count % 4，结果：2

三、比较运算符

比较运算符用于比较两个值，返回布尔类型结果。

3.1 相等性比较

等于 ==

let isEqual = (5 == 5)  // 结果：true
let notEqual = (5 == 3)  // 结果：false

不等于 !=

let isDifferent = (5 != 3)  // 结果：true

3.2 大小比较

let a = 10
let b = 20

let isGreater = a > b        // 结果：false
let isLess = a < b           // 结果：true
let isGreaterOrEqual = a >= 10  // 结果：true
let isLessOrEqual = b <= 20     // 结果：true

3.3 比较运算符应用场景

func checkAge(age: Int): String {
    if (age >= 18) {
        return "成年人"
    } else {
        return "未成年人"
    }
}

四、逻辑运算符

逻辑运算符用于组合或修改布尔表达式。

4.1 逻辑与 &&

两个条件都为真时，结果才为真：

let age = 25
let hasLicense = true

let canDrive = (age >= 18) && hasLicense  // 结果：true

4.2 逻辑或 ||

只要有一个条件为真，结果就为真：

let isWeekend = true
let isHoliday = false

let canRest = isWeekend || isHoliday  // 结果：true

4.3 逻辑非 !

对布尔值取反：

let isRaining = false
let isSunny = !isRaining  // 结果：true

4.4 短路求值

仓颉的逻辑运算符支持短路求值，提高效率：

// 如果 a 为 false，b 不会被评估
let result1 = a && b

// 如果 a 为 true，b 不会被评估
let result2 = a || b

五、位运算符

位运算符直接操作整数的二进制位。

5.1 按位与 &

let a = 12  // 二进制：1100
let b = 10  // 二进制：1010
let result = a & b  // 结果：8（二进制：1000）

5.2 按位或 |

let result = a | b  // 结果：14（二进制：1110）

5.3 按位异或 ^

let result = a ^ b  // 结果：6（二进制：0110）

5.4 按位取反 ~

let a = 12
let result = ~a  // 对所有位取反

5.5 左移 << 和右移 >>

let a = 5  // 二进制：0101
let leftShift = a << 2   // 结果：20（二进制：10100）
let rightShift = a >> 1  // 结果：2（二进制：0010）

六、赋值运算符

6.1 简单赋值 =

var x = 10
var name = "张三"

6.2 复合赋值运算符

除了算术复合赋值，仓颉还支持位运算的复合赋值：

var flags = 0b1100
flags &= 0b1010  // 按位与赋值
flags |= 0b0011  // 按位或赋值
flags ^= 0b0101  // 按位异或赋值
flags <<= 2      // 左移赋值
flags >>= 1      // 右移赋值

七、其他运算符

7.1 条件运算符（三元运算符）

let age = 20
let status = age >= 18 ? "成年" : "未成年"

7.2 范围运算符

仓颉支持范围运算符用于循环和集合操作：

// 闭区间：包含两端
for (i in 1..5) {
    // i 的值：1, 2, 3, 4, 5
}

// 半开区间：不包含右端
for (i in 1..<5) {
    // i 的值：1, 2, 3, 4
}

7.3 类型检查和转换运算符

// 类型检查
if (value is Int) {
    // value 是 Int 类型
}

// 类型转换
let number = value as Int

八、运算符优先级

理解运算符优先级对编写正确的表达式至关重要。从高到低排列：

1. 一元运算符：!, ~, -, +
2. 乘除运算符：*, /, %
3. 加减运算符：+, -
4. 移位运算符：<<, >>
5. 比较运算符：<, <=, >, >=
6. 相等运算符：==, !=
7. 按位与：&
8. 按位异或：^
9. 按位或：|
10. 逻辑与：&&
11. 逻辑或：||
12. 条件运算符：? :
13. 赋值运算符：=, +=, -= 等

示例：

let result = 2 + 3 * 4  // 结果：14（先乘后加）
let result2 = (2 + 3) * 4  // 结果：20（括号改变优先级）

九、最佳实践 🌟

9.1 使用括号提高可读性

即使不改变执行顺序，适当使用括号也能提高代码可读性：

// 不够清晰
let result = a && b || c && d

// 更清晰
let result = (a && b) || (c && d)

9.2 避免过度复杂的表达式

将复杂表达式拆分为多个步骤：

// 不推荐
let result = ((a + b) * (c - d)) / ((e & f) | (g ^ h))

// 推荐
let sum = a + b
let diff = c - d
let product = sum * diff
let bitOp1 = e & f
let bitOp2 = g ^ h
let result = product / (bitOp1 | bitOp2)

9.3 注意整数除法

整数除法会截断小数部分：

let result1 = 5 / 2      // 结果：2
let result2 = 5.0 / 2.0  // 结果：2.5

9.4 小心浮点数比较

避免直接用 == 比较浮点数：

// 不推荐
let isEqual = (0.1 + 0.2 == 0.3)

// 推荐：使用误差范围
let epsilon = 0.0001
let isEqual = Math.abs((0.1 + 0.2) - 0.3) < epsilon

十、常见错误与陷阱 ⚠️

10.1 赋值与比较混淆

// 错误：使用赋值运算符而非比较
if (x = 5) {  // 这是赋值，不是比较
    // ...
}

// 正确
if (x == 5) {
    // ...
}

10.2 整数溢出

let maxInt = Int64.max
let overflow = maxInt + 1  // 可能导致溢出

10.3 除零错误

let a = 10
let b = 0
// let result = a / b  // 运行时错误！

// 应该先检查
if (b != 0) {
    let result = a / b
}

十一、实战案例 💡

案例1：计算器功能

func calculate(a: Float64, b: Float64, operator: String): Float64 {
    switch (operator) {
        case "+":
            return a + b
        case "-":
            return a - b
        case "*":
            return a * b
        case "/":
            if (b != 0) {
                return a / b
            } else {
                throw Exception("除数不能为零")
            }
        default:
            throw Exception("不支持的运算符")
    }
}

案例2：权限检查（位运算）

const READ_PERMISSION = 0b001
const WRITE_PERMISSION = 0b010
const EXECUTE_PERMISSION = 0b100

func hasPermission(userPermissions: Int, requiredPermission: Int): Bool {
    return (userPermissions & requiredPermission) == requiredPermission
}

var userPerms = READ_PERMISSION | WRITE_PERMISSION
let canRead = hasPermission(userPerms, READ_PERMISSION)  // true
let canExecute = hasPermission(userPerms, EXECUTE_PERMISSION)  // false

案例3：范围验证

func isValidScore(score: Int): Bool {
    return score >= 0 && score <= 100
}

func getGrade(score: Int): String {
    if (!isValidScore(score)) {
        return "无效分数"
    }
    
    return score >= 90 ? "优秀" :
           score >= 80 ? "良好" :
           score >= 60 ? "及格" : "不及格"
}

十二、总结

仓颉语言的运算符系统设计合理、功能完善。通过本文的学习，您应该已经掌握了：

✅ 各类运算符的基本用法
✅ 运算符的优先级规则
✅ 常见陷阱与最佳实践
✅ 实际应用场景

熟练运用这些运算符，将帮助您编写更加高效、优雅的仓颉代码！继续实践，不断精进！💪🎉