本课目标· 掌握仓颉的算术、关系、逻辑、位运算符及其优先级。· 理解赋值表达式与复合赋值运算符的特殊性。· 掌握数值类型之间的显式转换以及 is 和 as 操作符的用法。· 理解条件表达式 if 的返回值特性。· 掌握 while、do-while、for-in 三种循环以及 break、continue 的使用。· 掌握函数重载、命名参数、默认值和尾随 lambda。· 认识元组、数组、字符串三种常见复合类型的创建与访问。· 能独立完成本课全部习题。一、运算符详解算术运算符仓颉的算术运算符包括一元负号 - 和六个二元运算符、-、*、/、%、**。main() { // 程序入口 let a: Int64 10 // 定义整数 a let b: Int64 3 // 定义整数 b println(a b) // 加法13 println(a - b) // 减法7 println(a * b) // 乘法30 println(a / b) // 整数除法3截断小数 println(a % b) // 取模1 println(a ** b) // 幂运算10 的 3 次方 1000 println(-a) // 一元负号-10 } // main 结束重要规则仓颉的大部分二元运算符要求参与运算的两个操作数必须是相同类型否则编译器报错。例如 Int64 Int32 是不合法的必须先将其中一个显式转换。关系运算符关系运算符用于比较两个值返回 Bool 类型。包括 、、、、、!。main() { // 程序入口 let x: Int64 5 // 定义变量 x let y: Int64 8 // 定义变量 y println(x y) // true println(x y) // true println(x y) // false println(x y) // false println(x y) // false println(x ! y) // true } // main 结束注意关系运算符不支持连续使用例如 a b c 是编译错误。需要使用 连接a b b c。逻辑运算符仓颉提供 逻辑与、||逻辑或和 !逻辑非。 和 || 都支持短路求值。main() { // 程序入口 var ic 10 // 定义可变变量 ic let r1 (ic ic) (ic 12 0) // 左为 true执行右ic 变为 12 println(${r1} ${ic}) // true 12 let r2 (ic ! ic) (ic 99 0) // 左为 false短路右不执行 println(${r2} ${ic}) // false 12 let r3 true || (ic 0 0) // 左为 true短路右不执行 println(${r3} ${ic}) // true 12 } // main 结束解读 左侧为 false 时右侧不会执行|| 左侧为 true 时右侧不会执行。位运算符仓颉支持 按位与、|按位或、^按位异或、左移、右移、!按位求反。main() { // 程序入口 let a: Int64 0b1100 // 二进制 1100十进制 12 let b: Int64 0b1010 // 二进制 1010十进制 10 println(a b) // 按位与0b1000 8 println(a | b) // 按位或0b1110 14 println(a ^ b) // 按位异或0b0110 6 println(a 1) // 左移一位24 println(a 1) // 右移一位6 println(!a) // 按位求反-13 } // main 结束赋值与复合赋值运算符赋值运算符 和复合赋值运算符 、-、*、/、%、** 等所有赋值表达式的类型都是 Unit值为 ()而不是返回左表达式的引用。main() { // 程序入口 var a: Int64 128 // 定义可变变量 a let b: Int64 64 // 定义不可变变量 b a b // 等价于 a a ba 变为 192 println(a) // 输出 192 a - 32 // a 变为 160 a * 2 // a 变为 320 a / 4 // a 变为 80 a % 7 // a 变为 3 println(a) // 输出 3 } // main 结束注意由于赋值表达式类型是 Unit不能写 let x (a 5)这会导致类型不匹配错误。运算符优先级仓颉运算符优先级从高到低宏调用 → 成员访问 .、索引 []、函数调用 () → 自增 、自减 – → 逻辑非 !、一元负号 - → 幂 ** → 乘除 * / % → 加减 - → 移位 → 区间 … … → 关系 → 判等 ! → 按位与 → 按位异或 ^ → 按位或 | → 逻辑与 → 逻辑或 || → 赋值 及复合赋值。main() { // 程序入口 let a: Int64 3 2 * 6 // 先算 2*612再算 31215 println(a) // 输出 15 let b (3 2) * 6 // 括号优先先 325再 5*630 println(b) // 输出 30 let c a 15 b 30 // 先算两边关系再算 println(c) // 输出 true } // main 结束二、类型转换数值类型之间的转换仓颉不支持不同类型之间的隐式转换类型转换必须显式进行。数值类型使用 T(e) 的方式转换其中 T 是目标类型e 是源表达式。main() { // 程序入口 let a: Int8 10 // 定义 Int8 let b: Int16 20 // 定义 Int16 let r1 Int16(a) // Int8 转 Int16 println(r1 ${r1}, 类型 Int16) // 输出 r1 10 let r2 Int8(b) // Int16 转 Int8 println(r2 ${r2}, 类型 Int8) // 输出 r2 20 let c: Float32 1.0 // 定义 Float32 let d: Float64 1.123456789 // 定义 Float64 let r3 Float64(c) // Float32 转 Float64 println(r3 ${r3}) // 输出 1.000000 let r4 Float32(d) // Float64 转 Float32精度丢失 println(r4 ${r4}) // 输出 1.123457 let e: Int64 1024 // 定义 Int64 let r5 Float64(e) // Int64 转 Float64 println(r5 ${r5}) // 输出 1024.000000 let f: Float64 1024.1024 // 定义 Float64 let r6 Int64(f) // Float64 转 Int64截断小数 println(r6 ${r6}) // 输出 1024 } // main 结束注意类型转换时可能发生溢出若溢出可提前在编译器检测出来编译器会直接报错否则根据默认的溢出策略抛出异常。is 操作符is 用于判断表达式的类型是否是指定类型或其子类型返回 Bool 值。open class Animal { // 定义父类 Animal public func speak(): String { // 定义成员函数 return ... // 返回占位符 } // 函数结束 } // 类结束 class Dog : Animal { // 定义子类 Dog继承 Animal public func speak(): String { // 重写成员函数 return 汪汪 // 返回狗叫声 } // 函数结束 } // 类结束 main() { // 程序入口 let animal: Animal Dog() // 用子类实例初始化父类变量 println(animal is Dog) // trueanimal 的实际类型是 Dog println(animal is Animal) // trueDog 是 Animal 的子类型 let s: String hello // 定义字符串 println(s is String) // true } // main 结束as 操作符as 用于将表达式的类型转换为指定类型。由于类型转换可能失败as 返回的是一个 Option 类型。对于 e as T如果转换成功值为 Option.Some(e)如果失败值为 Option.None。open class Animal { // 定义父类 public func speak(): String { // 定义成员函数 return ... // 返回占位符 } // 函数结束 } // 类结束 class Dog : Animal { // 定义子类 public func speak(): String { // 重写函数 return 汪汪 // 返回狗叫声 } // 函数结束 } // 类结束 class Cat : Animal { // 定义另一个子类 public func speak(): String { // 重写函数 return 喵喵 // 返回猫叫声 } // 函数结束 } // 类结束 main() { // 程序入口 let animal: Animal Dog() // 父类引用指向子类实例 let dog animal as Dog // 转换为 Dog返回 OptionDog match (dog) { // 对 Option 进行模式匹配 case Some(d) println(d.speak()) // 转换成功输出“汪汪” case None println(不是 Dog) // 转换失败 } // match 结束 let cat animal as Cat // 转换为 Cat match (cat) { // 对 Option 进行模式匹配 case Some(c) println(c.speak()) // 转换成功 case None println(不是 Cat) // 转换失败输出“不是 Cat” } // match 结束 } // main 结束关键区别is 返回 Bool用于类型判断as 返回 Option用于安全类型转换。三、流程控制if 表达式仓颉的 if 是表达式可以被求值并作为值使用。if 的值与类型需要根据使用场景来确定。main() { // 程序入口 let score 85 // 定义成绩 let result if (score 90) { // if 作为表达式返回值赋给 result 优秀 // 分支的值 } else if (score 60) { // 继续判断 及格 // 分支的值 } else { // 兜底分支 不及格 // 分支的值 } // if 表达式结束 println(result) // 输出“及格” } // main 结束代码块的值规则由 {} 包围的代码块其值与类型等于其中最后一个表达式的值与类型。空代码块的类型为 Unit值为 ()。while 循环while 表达式的类型是 Unit值为 ()。条件为 true 时持续执行循环体。main() { // 程序入口 var i 1 // 循环变量初始为 1 while (i 5) { // 条件为 true 时循环 println(第 ${i} 次) // 输出当前次数 i i 1 // i 自增 } // while 结束 } // main 结束do-while 循环do-while 至少执行一次循环体然后再判断条件。main() { // 程序入口 var n 10 // 定义变量 n do { // 先执行循环体 println(执行一次${n}) // 输出 n n 1 // n 自增 } while (n 5) // 条件为 false循环结束 println(最终 n ${n}) // 输出 11 } // main 结束解读n 10 时条件 n 5 为 false但 do-while 先执行一次循环体所以至少输出一次。for-in 循环for-in 用于遍历区间或集合。遍历元组构成的序列时可以使用解构。main() { // 程序入口 for (i in 1..5) { // 遍历闭区间 1 到 5 println(区间${i}) // 输出 1 到 5 } // for 结束 let scores: ArrayInt64 [85, 90, 78] // 定义数组 for (score in scores) { // 遍历数组元素 println(成绩${score}) // 输出 85、90、78 } // for 结束 } // main 结束break 与 continuebreak 用于提前终止当前循环跳出循环体continue 用于跳过当前循环的剩余部分直接进入下一轮。main() { // 程序入口 for (i in 1..10) { // 遍历 1 到 10 if (i 6) { // 当 i 等于 6 break // 终止循环 } // if 结束 if (i % 2 0) { // 偶数时 continue // 跳过本次循环 } // if 结束 println(奇数${i}) // 输出 1、3、5 } // for 结束 } // main 结束重要break、continue、return、throw 表达式的类型是 Nothing程序执行到这些表达式时它们之后的代码不会被执行。四、函数进阶函数重载仓颉允许在同一作用域内定义多个同名函数编译器根据参数的个数和类型来决定调用哪个函数。func add(a: Int64, b: Int64): Int64 { // 版本 1两个 Int64 return a b // 返回两数之和 } // 函数结束 func add(a: Int32, b: Int32): Int32 { // 版本 2两个 Int32 return a b // 返回两数之和 } // 函数结束 func add(a: Int64, b: Int64, c: Int64): Int64 { // 版本 3三个 Int64 return a b c // 返回三数之和 } // 函数结束 main() { // 程序入口 println(add(1, 2)) // 调用版本 1 println(add(1, 2, 3)) // 调用版本 3 } // main 结束命名参数函数定义时在参数名后添加 ! 即为命名参数调用时必须在实参值前指定参数名。func dateOf(year!: Int64, month!: Int64, day!: Int64): String { // 定义命名参数 return ${year}年${month}月${day}日 // 返回日期字符串 } // 函数结束 main() { // 程序入口 println(dateOf(year: 2024, month: 6, day: 21)) // 必须写参数名 println(dateOf(month: 12, day: 25, year: 2025)) // 参数顺序可调整 } // main 结束参数默认值函数定义中可以为特定形参提供默认值调用时如果使用默认值则可以省略该参数。func greet(name!: String, greeting!: String 你好): String { // greeting 有默认值 return ${greeting}${name} // 返回拼接结果 } // 函数结束 main() { // 程序入口 println(greet(name: 仓颉)) // 使用默认 greeting println(greet(name: 开发者, greeting: 欢迎)) // 显式传入 greeting } // main 结束尾随 lambda仓颉支持尾随 lambda 语法糖将函数作为最后一个参数传入时可以写在括号外面。func repeat(times: Int64, action: () - Unit): Unit { // 定义函数接收 lambda for (i in 1..times) { // 重复 times 次 action() // 调用 lambda } // for 结束 } // 函数结束 main() { // 程序入口 repeat(3) { // 尾随 lambda 写法 println(执行一次) // lambda 体 } // 调用结束 } // main 结束五、常见复合类型入门元组元组将多个不同类型的值组合在一起使用括号表示。元组是固定大小的不可变集合。可以通过索引访问元素从 0 开始也可以解构赋值。main() { // 程序入口 let person: (String, Int64) (Alice, 30) // 定义二元组 println(person[0]) // 索引访问Alice println(person[1]) // 索引访问30 let (name, age) person // 解构赋值 println(${name} 今年 ${age} 岁) // 输出 Alice 今年 30 岁 let (_, onlyAge) person // 使用 _ 忽略不需要的元素 println(只取年龄${onlyAge}) // 输出 30 } // main 结束数组数组用于存储同一类型的多个元素使用 Array 表示元素按插入顺序排列。可以通过索引访问也可以用 for-in 遍历。main() { // 程序入口 let scores: ArrayInt64 [85, 90, 78] // 定义 Int64 数组 println(scores[0]) // 索引访问85 println(scores[2]) // 索引访问78 for (score in scores) { // 遍历数组元素 println(成绩${score}) // 依次输出 85、90、78 } // for 结束 } // main 结束字符串字符串使用双引号表示支持 比较、 拼接和 ${} 插值。字符串也支持切片操作。main() { // 程序入口 let s1 Hello // 定义字符串 let s2 Cangjie // 定义字符串 let s3 s1 , s2 // 使用 拼接字符串 println(s3) // 输出 Hello, Cangjie println(s1 Hello) // true字符串比较 println(s1.size) // 输出 5字符串长度 let sub s3[0..5] // 切片取前 5 个字符 println(sub) // 输出 Hello } // main 结束六、多元化习题与答案A. 选择题题目1下列哪个运算符的优先级最高A. B. *C. **D. 答案与解读C。优先级从高到低**4→ *5→ 6→ 14。题目2仓颉中 Int64 Int32 的结果是A. 自动提升为 Int64B. 自动截断为 Int32C. 编译错误需要显式转换D. 运行时异常答案与解读C。仓颉大部分二元运算符要求参与运算的两个操作数必须是相同类型。题目3as 操作符返回的类型是A. TB. BoolC. OptionD. Unit答案与解读C。as 因为可能失败返回 Option。题目4下列哪个表达式的类型是 UnitA. 1 2B. a bC. a 5D. “hello”答案与解读C。所有赋值表达式的类型都是 Unit值为 ()。题目5do-while 循环的特点是A. 条件为 true 时才执行B. 至少执行一次循环体C. 不能使用 breakD. 返回 Bool 值答案与解读B。do-while 先执行循环体再判断条件因此至少执行一次。题目6break 和 continue 表达式的类型是A. UnitB. BoolC. NothingD. Int64答案与解读C。break、continue、return、throw 的类型都是 Nothing。题目7函数重载的依据是A. 函数名不同B. 返回值类型不同C. 参数个数或类型不同D. 函数体不同答案与解读C。仓颉根据参数的个数和类型来决定调用哪个重载函数。题目8元组元素访问的索引从几开始A. 0B. 1C. -1D. 任意答案与解读A。元组支持通过 t[index] 访问索引从 0 开始。题目9下列哪个是仓颉合法的区间操作符A. …B. …C. …D. 答案与解读B。… 是左闭右开… 是闭区间。题目10if 表达式作为值使用时其值的类型由什么决定A. 固定为 UnitB. 固定为 BoolC. 各分支最后一个表达式的类型D. 由条件类型决定答案与解读C。代码块的值与类型等于其中最后一个表达式的值与类型。B. 判断题题目1仓颉支持不同类型之间的隐式转换。答案与解读错误。仓颉不支持隐式类型转换必须显式进行。题目2 左侧为 false 时右侧不会执行。答案与解读正确。 支持短路求值。题目3is 操作符返回 Option。答案与解读错误。is 返回 Boolas 才返回 Option。题目4while 表达式的类型是 Unit。答案与解读正确。while、do-while、for-in 的类型都是 Unit值为 ()。题目5关系运算符可以连续使用如 a b c。答案与解读错误。关系运算符不支持连续使用需要用 连接。题目6命名参数在定义时参数名后加 !。答案与解读正确。定义时加 !调用时必须写参数名。题目7数组是值类型。答案与解读错误。Array 是引用类型。题目8as 转换失败时会抛出异常。答案与解读错误。as 返回 Option失败时值为 Option.None不会抛异常。题目9复合赋值运算符 的表达式类型是 Unit。答案与解读正确。所有赋值表达式包括复合赋值的类型都是 Unit。题目10尾随 lambda 是将函数参数写在括号外面。答案与解读正确。尾随 lambda 语法糖允许将最后一个函数参数写在括号外。C. 填空题题目1仓颉中幂运算的运算符是 ______。答案与解读**。题目2a as T 的返回类型是 ______。答案与解读Option。题目3do-while 循环至少执行 ______ 次。答案与解读1。题目4函数重载的依据是参数个数不同或 ______ 不同。答案与解读参数类型。题目5break、continue 表达式的类型是 ______。答案与解读Nothing。题目6元组解构时用 ______ 忽略不需要的元素。答案与解读_。题目7if 代码块的值等于其中 ______ 表达式的值。答案与解读最后一个。题目8数组使用 ______ 类型表示T 是元素类型。答案与解读Array。题目9字符串拼接使用 ______ 运算符。答案与解读。题目10… 是左闭右开区间… 是 ______ 区间。答案与解读闭。D. 代码改错题题目1main() { // 程序入口 let a: Int64 10 // 定义 Int64 let b: Int32 20 // 定义 Int32 let c a b // 错误类型不同 println(c) // 输出 } // main 结束答案与解读main() { // 程序入口 let a: Int64 10 // 定义 Int64 let b: Int32 20 // 定义 Int32 let c a Int64(b) // 显式转换 b 为 Int64 println(c) // 输出 30 } // main 结束仓颉不支持隐式类型转换需要显式转换。题目2main() { // 程序入口 let x if (true) { 1 } // 错误缺少 else 分支 println(x) // 输出 } // main 结束答案与解读main() { // 程序入口 let x if (true) { 1 } else { 0 } // 补充 else 分支 println(x) // 输出 1 } // main 结束if 作为表达式使用时必须有 else 分支否则无法确定类型。题目3main() { // 程序入口 let s: String hello // 定义字符串 let r s as Int64 // 错误String 不能 as 为 Int64 println(r) // 输出 } // main 结束答案与解读main() { // 程序入口 let s: String hello // 定义字符串 // as 只用于类和接口的类型转换值类型转换使用 T(e) println(s.size) // 输出 5 } // main 结束as 只用于类和接口的引用类型转换不能用于值类型。数值类型之间用 T(e)。题目4main() { // 程序入口 for (i in 1..5) { // 遍历 1 到 5 if (i 3) { // 当 i 等于 3 continue // 跳过本次循环 } else { // 否则 break // 终止循环 } // if 结束 println(i) // 输出 } // for 结束 } // main 结束答案与解读这段代码逻辑有问题。当 i 1 时continue 不成立进入 else 的 break循环直接终止只输出 1。如果希望输出 1、2、4、5跳过 3应改为main() { // 程序入口 for (i in 1..5) { // 遍历 1 到 5 if (i 3) { // 当 i 等于 3 continue // 跳过本次循环 } // if 结束 println(i) // 输出 1、2、4、5 } // for 结束 } // main 结束题目5func add(a: Int64, b: Int64): Int64 { // 版本 1 return a b // 返回两数之和 } // 函数结束 func add(a: Int64, b: Int64): Int64 { // 版本 2与版本 1 完全相同 return a b // 返回两数之和 } // 函数结束答案与解读两个函数名相同、参数类型和个数相同不构成重载编译错误。函数重载要求参数个数不同或参数类型不同。E. 输出预测题题目1main() { // 程序入口 let a: Int64 7 // a 7 let b: Int64 2 // b 2 println(a / b) // 整数除法3 println(a % b) // 取模1 println(a ** b) // 幂运算49 } // main 结束答案与解读输出3 1 49整数除法截断小数7 / 2 37 % 2 17 ** 2 49。题目2main() { // 程序入口 var x 5 // x 5 let y if (x 3) { x * 2 } else { x 1 } // if 表达式 println(y) // 输出 10 } // main 结束答案与解读输出 10。x 5 3取 x * 2 10。题目3main() { // 程序入口 var sum 0 // 累加器 var i 1 // 循环变量 do { // do-while sum i // 累加 i 1 // 自增 } while (i 3) // 条件 println(sum) // 输出 6 } // main 结束答案与解读输出 6。1 2 3 6。题目4func add(a: Int64, b: Int64): Int64 { // 两个参数 return a b // 返回两数之和 } // 函数结束 func add(a: Int64, b: Int64, c: Int64): Int64 { // 三个参数 return a b c // 返回三数之和 } // 函数结束 main() { // 程序入口 println(add(1, 2)) // 调用两参数版本 println(add(1, 2, 3)) // 调用三参数版本 } // main 结束答案与解读输出3 6函数重载编译器根据参数个数选择对应版本。题目5main() { // 程序入口 let person: (String, Int64, Bool) (Bob, 25, true) // 三元组 let (name, age, _) person // 解构忽略第三个元素 println(${name} ${age}) // 输出 Bob 25 } // main 结束答案与解读输出 Bob 25。使用 _ 忽略布尔值。F. 编程题题目1编写函数 maxOfThree(a: Int64, b: Int64, c: Int64): Int64返回三个数中的最大值使用 if 表达式。func maxOfThree(a: Int64, b: Int64, c: Int64): Int64 { // 定义函数 return if (a b a c) { // a 最大 a // 返回 a } else if (b a b c) { // b 最大 b // 返回 b } else { // c 最大 c // 返回 c } // if 表达式结束 } // 函数结束 main() { // 程序入口 println(maxOfThree(3, 7, 5)) // 输出 7 println(maxOfThree(10, 2, 8)) // 输出 10 } // main 结束if 作为表达式直接 return各分支返回 Int64。题目2用 for-in 遍历数组统计大于 80 的成绩个数。main() { // 程序入口 let scores: ArrayInt64 [85, 72, 90, 65, 88] // 定义成绩数组 var count 0 // 计数器 for (score in scores) { // 遍历数组 if (score 80) { // 大于 80 count 1 // 计数器加一 } // if 结束 } // for 结束 println(大于80的成绩个数${count}) // 输出 3 } // main 结束遍历数组条件判断后计数。题目3使用命名参数和默认值定义函数 formatDate(year!: Int64, month!: Int64, day!: Int64, sep!: String “-”): String。func formatDate(year!: Int64, month!: Int64, day!: Int64, sep!: String -): String { // 定义 return ${year}${sep}${month}${sep}${day} // 返回格式化日期 } // 函数结束 main() { // 程序入口 println(formatDate(year: 2024, month: 6, day: 21)) // 默认分隔符 println(formatDate(year: 2024, month: 6, day: 21, sep: /)) // 自定义分隔符 } // main 结束输出2024-6-21 2024/6/21命名参数可选择性传参未传的使用默认值。题目4用 while 循环和 continue计算 1 到 100 中所有不能被 3 整除的数之和。main() { // 程序入口 var sum 0 // 累加器 var i 1 // 循环变量 while (i 100) { // 循环条件 if (i % 3 0) { // 能被 3 整除 i 1 // 先自增 continue // 跳过累加 } // if 结束 sum i // 累加 i 1 // 自增 } // while 结束 println(不能被3整除的数之和${sum}) // 输出 3367 } // main 结束注意continue 之前必须先自增 i否则会死循环。题目5使用元组返回一个数的整数部分和小数部分。func splitNumber(n: Float64): (Int64, Float64) { // 返回二元组 let intPart Int64(n) // 整数部分截断 let fracPart n - Float64(intPart) // 小数部分 return (intPart, fracPart) // 返回元组 } // 函数结束 main() { // 程序入口 let (i, f) splitNumber(3.14) // 解构元组 println(整数${i}小数${f}) // 输出 整数3小数0.140000 } // main 结束元组常用于从函数返回多个值。G. 开放综合题题目1用自己的话解释仓颉为什么要求运算符两侧类型相同。答案与解读仓颉是静态强类型语言要求运算符两侧类型相同可以避免隐式转换带来的精度丢失和逻辑错误让类型转换在代码中显式可见提高程序的安全性和可读性。题目2简述 is 和 as 的区别。答案与解读is 用于判断表达式的类型返回 Boolas 用于将表达式转换为指定类型返回 Option转换失败时返回 None不会抛出异常。is 用于判断as 用于转换。七、知识点总结· 算术运算符、-、*、/、%、**、一元 -。· 关系运算符、、、、、!不支持连续使用。· 逻辑运算符、|| 支持短路求值! 逻辑非。· 位运算符、|、^、、、!。· 赋值表达式类型为 Unit值为 ()。· 运算符优先级幂 乘除 加减 移位 关系 判等 按位 逻辑 赋值。· 数值类型转换使用 T(e)不支持隐式转换。· is 判断类型返回 Boolas 转换类型返回 Option。· if 是表达式代码块的值等于最后一个表达式的值。· 循环类型均为 Unitwhile、do-while、for-in。· do-while 至少执行一次。· break、continue、return、throw 的类型是 Nothing。· 函数重载依据参数个数或类型不同。· 命名参数定义时加 !调用时必须写参数名。· 参数默认值可减少函数重载。· 尾随 lambda 将函数参数写在括号外。· 元组是固定大小的不可变集合支持索引访问和解构。· 数组 Array 是引用类型元素类型相同。· 字符串支持 拼接、 比较、${} 插值和切片。八、易错点· 仓颉不支持隐式类型转换不同类型运算前必须显式转换。· as 只用于类和接口的引用类型转换值类型转换用 T(e)。· as 返回 Option需要用 match 或 ?? 处理。· 赋值表达式类型是 Unit不能用于需要值的场合。· 关系运算符不能连续使用如 a b c 是编译错误。· do-while 至少执行一次条件在循环体之后判断。· continue 前要确保循环变量已更新否则可能死循环。· 函数重载不能仅靠返回值类型区分。· 命名参数调用时必须写参数名。· if 作为表达式时必须包含 else 分支。九、本课通关清单· 能正确使用算术、关系、逻辑、位运算符。· 能写出复合表达式并判断求值顺序。· 能进行数值类型的显式转换。· 能使用 is 和 as 进行类型判断与转换。· 能使用 if 表达式作为值。· 能正确选用 while、do-while、for-in。· 能在循环中使用 break 和 continue。· 能定义重载函数、命名参数函数、带默认值的函数。· 能使用元组、数组、字符串的基本操作。· 能独立完成本课全部习题。
