合法的普通标识符#

abc
_abc
abc_
a1b2c3
a_b_c
a1_b2_c3

不合法的普通标识符#

ab&c    // 使用了非法字符 "&"
_123    // 起始下划线 "_" 后不能接数字
3abc    // 数字不能出现在头部
while   // 不能使用仓颉关键字

合法的原始标识符#

`abc`
`_abc`
`a1b2c3`
`if`
`while`

不合法的原始标识符#

`ab&c`
`_123`
`3abc`

整数类型字面量#

整数类型字面量有 4 种进制表示形式: 二进制 (使用0b 或 0B 前缀)、八进制 (使用0o 或 0O 前缀)、十进制 (不使用前缀) 和十六进制 (使用0x 或 0X 前缀)。例如, 对于十进制数 24, 表示成二进制是 0b00011000 (或 0B00011000)、八进制是 0o30 (或 0O30)、十六进制是 0x18 (或 0X18)。
在使用整数类型时, 可以通过加入后缀来明确整数字面量的类型, 后缀于类型的对应为

var x = 100i8   // x is 100 with type Int8
var y = 16u64   // y is 16 with type UInt64
var z = 282i32  // z is 282 with type Int32

浮点类型字面量#

浮点类型字面量有两种进制表示形式: 十进制、十六进制。在十进制表示中, 一个浮点字面量至少要包含一个整数部分或一个小数部分, 没有小数部分时必须包含指数部分 (以 e 或 E 为前缀, 底数为 10)。在十六进制表示中, 一个浮点字面量除了至少要包含一个整数部分或一个小数部分 (以 0x 或 0X 为前缀), 同时必须包含指数部分 (以 p 或 P 为前缀, 底数为 2)。

let a: Float32 = 3.14
let b: Float32 = 2e3
let c: Float32 = 2.4e-1
let d: Float32 = 0x1p2
let e: Float64 = 0x2p4

在使用浮点数时, 可以通过加入后缀来明确浮点字面量的类型, 后缀与类型的对应为

let a = 3.14f16     // a is 3.14 with type Float16
let b = 2e3f32      // b is 2e3 with type Float32
let c = 2.4e-1f64   // c is 2.4e-1 with type Float64

布尔类型字面量#

布尔类型字面量有两个: true 和 false。布尔类型的值可以通过逻辑运算符 (如与、或、非) 进行组合和计算

let a: Bool = true
let b: Bool = false
let c: Bool = a && b
let d: Bool = a || b
let e: Bool = !a

回顾if表达式#

from std import random.*
main() {
    let speed = Random(). nextFloat64() * 20.0
    println("${speed} km/s")
    println(speed > 16.7)               // true or false
    if (speed > 16.7) {
        println("第三宇宙速度, 鹊桥相会")
    } else if (speed > 11.2) {
        println("第二宇宙速度, 嫦娥奔月")
    } else if (speed > 7.9) {
        println("第一宇宙速度, 腾云驾雾")
    } else {
        println("脚踏实地, 仰望星空")
    }
}

回顾while表达式#

main() {
    var num: Int64 = 0
    while (num <= 10) {
        println(num)
        num++
        println(num <= 10)              // true or false
    }
    println("while执行完毕")
}

字符类型字面量#

字符类型字面量有三种形式: 单个字符、转义字符和通用字符, 它们均使用一对单引号定义

单个字符的字符字面量举例:

let a: Rune = 'a'
let b: Rune = 'b'

转义字符是指在一个字符序列中对后面的字符进行另一种解释的字符。转义字符使用转义符号\开头, 后面加需要转义的字符。 举例如下:

let slash: Rune = '\\'
let newline: Rune = '\n'
let tab: Rune = '\t'

通用字符以\u开头, 后面加上定义在一对花括号{}中的 1~8个十六进制数, 即可表示对应的 Unicode 值代表的字符。 举例如下:

main() {
    let a: Rune = '\u{4E2D}' // 中
    let b: Rune = '\u{534E}' // 华
    let c: Rune = '\u{6C11}' // 民
    let d: Rune = '\u{65CF}' // 族
    let result: String = String(a) + String(b) + String(c) + String(d)
    print(result)
}
// result: 中华民族

字符串类型字面量#

字符串字面量分为三类: 单行字符串字面量、多行字符串字面量、多行原始字符串字面量

单行字符串字面量 的内容定义在一对双引号之内"", 双引号中的内容可以是任意数量的 (除了非转义的双引号和单独出现的\之外的) 任意字符。单行字符串字面量只能写在同一行,不能跨多行

let s1: String = ""
let s2 = "Hello Cangjie Lang"
let s3 = "\"Hello Cangjie Lang\""
let s4 = "Hello Cangjie Lang\n"

多行字符串字面量 以三个双引号开头""", 并以三个双引号结尾""",并且开头的三个双引号之后需要换行(否则编译错误)。字面量的内容从开头的三个双引号换行后的第一行开始, 到结尾的三个双引号之前结束, 之前的内容可以是任意数量的(除单个出现的\之外的) 任意字符。不同于单行字符串字面量, 多行字符串字面量可以跨多行。

let s1: String = """
"""
let s2 = """
    Hello,
    Cangjie Lang"""

多行原始字符串字面量 以一个或多个井号# 加上一个双引号开始, 并以一个双引号加上和开始相同个数的#结束。开始的双引号和结束的双引号之间的内容可以是任意数量的任意合法字符。不同于 (普通) 多行字符串字面量, 多行原始字符串字面量中的内容会维持原样 (转义字符不会被转义, 如下例中 s2 中的 \n 不是换行符, 而是由 \ 和 n 组成的字符串 \n)

let s1: String = #""#
let s2 = ##"\n"##
let s3 = ###"
    Hello,
    Canjie
    Lang"###

插值字符串#

插值字符串是一种包含一个或多个插值表达式的字符串字面量 (不适用于多行原始字符串字面量), 通过将表达式插入到字符串中, 可以有效避免字符串拼接的问题。

插值表达式必须用花括号{}包起来, 并在花括号前加上美元符号$, 例如"${expression}"。{}中可以包含一个或者多个声明或表达式

main() {
    let fruit = "apples"
    let count = 10
    let s = "There are ${count * count} ${fruit}"
    println(s)  // There are 100 apples
    
    let r = 2.4
    let area = "There area of a circle with redius ${r} is ${let pi = 3.14; pi * r * r}"
    println(area) // There area of a circle with redius 2.400000 is 18.086400
}

访问 Array 成员#

当需要对 Array 的所有元素进行访问时, 可以使用 for-in 表达式遍历 Array 的所有元素
Array 是按元素插入顺序排列的, 因此对 Array 遍历的顺序总是恒定的

main() {
    let arr = [0, 1, 2]
    for (i in arr) {
        println("The element is ${i}")
    }
}

当需要知道某个 Array 包含的元素个数时, 可以使用 size 属性来获取。

main() {
    let arr = [0, 1, 2]
    println("The size of the array is ${arr.size}")
}

注意: 属性不用( ), 方法要用( )

当需要访问 Array 中的某个元素时, 可以使用下标运算符[]来访问
非空 Array 的第一个元素总是从位置 0 开始
索引值不能使用负数或者大于等于 Array 的长度, 当编译器能检查出索引值非法时, 会在编译时报错, 否则会在运行时抛异常。

main() {
    let arr = [0, 1, 2]
    let a = arr[0]  // 0
    let b = arr[1]  // 1
    println("The first element is ${a}")
    println("The second element is ${b}")
    let c = arr[-1] // error: index out of range
    println("The last element is ${c}")
}

如果想获取某一段 Array 的元素, 可以在下标中传入 Range 类型的值, 就可以一次性取得 Range 对应范围的一段 Array

let arr1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
let arr2 = arr1[1..3]   // [20, 30]
let arr3 = arr1[4..=7]  // [50, 60, 70, 80]

修改 Array#

Array 是一种长度不变的 Collection 类型, 因此 Array 没有提供添加和删除元素的成员函数
但 Array 允许对其中的元素进行修改

main() {
    let arr = [0, 1, 2]
    arr[0] = 10
    println(arr[0])  // 10
}

Array 是引用类型, 因此 Array 在作为表达式使用时不会拷贝副本, 同一个 Array 实例的所有引用都会共享同样的数据。
因此对 Array 元素的修改会影响到该实例的所有引用

main() {
    let arr1 = [0, 1, 2]
    let arr2 = arr1
    arr2[0] = 10
    println(arr1) // [10, 1, 2]
    println(arr2) // [10, 1, 2]

    // ⬇ 值传递类型
    var msg1 = 100
    var msg2 = msg1
    msg1 = 200
    println(msg1) // 200
    println(msg2) // 100
}

区间类型字面量#

区间字面量有两种形式: “左闭右开”区间和”左闭右闭”区间。其中, “左闭右开”区间的格式是start..end : step, 表示一个从start开始, 以step为步长, 到end(不包含end)为止的区间; “左闭右闭”区间的格式是start..=end : step, 表示一个从start开始, 以step为步长, 到end(包含end)为止的区间

let n = 10
let r1 = 0..10:1    // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
let r2 = 0..=n:1    // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
let r3 = n..0:-2    // 10, 8, 6, 4, 2
let r4 = n..=0:-2   // 10, 8, 6, 4, 2, 0

区间字面量中, 可以不写step, 此时step默认等于1。
注意: step不能为0, 另外区间也有可能是空的(即不包含任何元素的空序列)

let r5 = 0..10      // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
let r6 = 0..=10:0   // error: step cannot be 0

let r7 = 10..0:1    // empty ranges
let r8 = 0..10:-1   // empty ranges
let r9 = 10..=0:1   // empty ranges
let r10 = 0..=10:-1 // empty ranges

提示
表达式start..end:step中, 当step > 0且start >= end, 或者step < 0且start <= end时, start..end:step是一个空区间; 表达式start..=end:step中, 当step > 0且start > end, 或者step < 0且start < end时, start..=end:step是一个空区间

元组类型的字面量#

元组类型的字面量使用(E1, E2, ..., En)表示, 其中E1~En是表达式, 多个表达式之间使用逗号分隔。

下面的例子中, 分别定义了一个(Int64, Float64)类型的变量x, 以及一个(Int64, Float64, String)类型的变量y, 并且使用元组类型的字面量初始化:

let x: (Int64, Float64) = (2, 3.14159)
let y: (Int64, Float64, String) = (2, 3.14159, "PI")

元组类型的类型参数#

let tuple: (name: String, age: Int64) = ("apple", 18)

对于一个元组类型, 只允许统一写类型参数名, 或者统一不写类型参数名, 不能部分写类型参数名, 否则编译报错

let tuple: (String, age: Int64) = ("apple", 18) // error: type parameter name mismatch

Unit 类型#

对于那些只关心副作用而不关心值得表达式, 它们的类型是Unit。
例如, print函数、赋值表达式、复合赋值表达式、自增和自减表达式、循环表达式, 它们的类型都是Unit

Unit类型只有一个值, 也就是它的字面量()。除了赋值、判等和判不等外, Unit类型不支持其它操作

Nothing 类型#

Nothing是一种特殊的类型, 它不包含任何值, 并且Nothing类型是所有类型的子类型

break、continue、return、throw表达式的类型是Nothing, 程序执行到这些表达式时, 它们之后的代码将不会被执行。其中break、continue只能在循环体中使用, return只能在函数体中使用

注意
目前编译器还不允许在使用类型的地方显式使用Nothing类型, 例如: let a: Nothing = ()会报错, 但是可以在函数返回值的地方使用Nothing类型, 例如: return break

余数运算符#

余数运算符是比较常用的, 因为在逻辑思维上寻找规律, 余数运算符是很好用的

main() {
    var result: Int64
    var x = 101
    var y = 5
    result = x % y
    println("x % y = ${result}")
}

自增和自减运算符#

自增和自减运算符, 是一元运算符, 只需一个运算子。它们的作用是将运算子首先转为数值, 然后加上1或减去1

main() {
    var x = 10
    var y = 20
    x++
    y--
    println("x++ = ${x}") // 11
    println("y-- = ${y}") // 19
}

复合赋值运算符#

赋值运算符还可以与其他运算符结合, 形成变体。

x += 1      // x = x + 1
x -= 1      // x = x - 1
x *= 2      // x = x * 2
x /= 2      // x = x / 2
x %= 2      // x = x % 2

取反运算符 (!)#

!true // false
!false // true

与运算符 (&&)#

多个条件都要满足

if (10 < 20 && 10 > 5) {
    println("Yes")
} else {
    println("No")
}

或运算符 (||)#

只要有一个条件满足即可

if (10 < 20 || 10 > 5) {
    println("Yes")
} else {
    println("No")
}

快速计算位移方案 << >>#

1. 左移运算符就是*2的n次方 (n代表位移次数)
2. 右移运算符就是/2的n次方 (n代表位移次数, 不同点, 出现小数时要取整)

位运算演算过程#

5 << 2  // 20
↓
0000 0000 0000 0000 0000 0000 0000 0101 // 5
0000 0000 0000 0000 0000 0000 0001 0100 // 20 左移2位

1000 >> 8  // 3
↓
0000 0000 0000 0000 0000 0011 1110 1000 // 1000
0000 0000 0000 0000 0000 0000 0000 0011 // 3 右移8位

函数调用#

函数调用的形式为funcName(arg1, arg2, ..., argn)。其中, funcName是要调用的函数名, arg1 ~ argn是n个调用时的参数(称为实参), 要求每个实参的类型必须是对应参数类型的子类型。实参可以有0个或多个, 当实参个数为0时, 调用方式为funcName()

参数列表#

一个函数可以拥有0个或多个参数, 这些参数均定义在函数的参数列表中。根据函数调用时是否需要给定参数名, 可以将参数列表中的参数分为两类: 非命名参数和命名参数

非命名参数的定义方式是p:T, 其中p是参数名, T是参数p的类型, 参数名和其类型间使用冒号链接。例如, 上例中add函数的两个参数a和b均为非命名参数

命名参数的定义方式是p!:T, 与非命名参数的不同是在参数名p之后多了一个!。可以将上例中add函数的两个非命名参数修改为命名参数

func add(a!: Int64, b!: Int64): Int64 {
    return a + b
}

命名参数还可以设置默认值, 通过p!:T = e方式将参数p的默认值设置为表达式e的值。
例如, 可以将上述add函数的两个参数的默认值都设置为1:

func add(a!: Int64 = 1, b!: Int64 = 1): Int64 {
    return a + b
}

非命名参数和命名参数的主要差异在于调用时的不同

根据函数定义时参数是非命名参数还是命名参数的不同, 函数调用时传实参的方式也有所不同: 对于非命名参数, 它对应的实参是一个表达式, 对于命名参数, 它对应的实参需要使用p:e的形式, 其中p是命名参数的名字, e是表达式(即传递给参数p的值)

func add(a!: Int64 = 1, b!: Int64 = 1): Int64 {
    return a + b
}
add(a:10, b:20)

函数参数均为不可变变量, 在函数定义内不能对其赋值

func add(a: Int64, b: Int64): Int64 {
    a = a + b // error: cannot assign to immutable value
    return a
}

函数返回值类型#

函数返回值类型是函数被调用后得到的值的类型, 函数定义时, 返回值类型是可选的: 可以显式地定义返回值类型(返回值类型定义在参数列表和函数体之间), 也可以不定义返回值类型, 交由编译器推导确定

当显式地定义了函数返回值类型时, 就要求函数体的类型、函数体中所有return e表达式中e的类型是返回值类型的子类型。
例如, 对于上述add函数, 显示地定义了它的返回值类型为Int64, 如果将函数体中地return a + b修改为return (a, b), 则会因为类型不匹配而报错

// Error: the type of the expression after return does not match the return type of the function
func add(a: Int64, b: Int64): Int64 {
    return (a, b)   // error: type mismatch
}

在函数定义时如果未显式定义返回值类型, 编译器将根据函数体的类型以及函数体中所有地return表达式来共同推导出函数的返回值类型。
例如, 下列add函数的返回值类型虽然被省略, 但编译器可以根据return a + b推导出add函数的返回值类型是Int64:

func add(a: Int64, b: Int64) {
    return a + b    // return type is Int64
}

提示
函数的返回值类型并不是任何情况下都可以被推导出来的, 如果返回值类型推导失败, 编译报错

函数体#

函数体中定义了函数被调用时执行的操作, 通常包含一系列的变量定义和表达式, 也可以包含新的函数定义(即嵌套函数)。
如下add函数的函数体中首先定义了Int64类型的变量r(初始值为0), 接着将a + b的值赋于r, 最后返回r的值

func add(a: Int64, b: Int64): Int64 {
    var r: Int64 = 0
    r = a + b
    return r
}

在函数体的任意位置都可以使用return表达式来终止函数的执行并返回。return表达式有两种形式:return和return expr( expr 是一种表达式)

对于return expr, 要求expr的类型与函数定义的返回值类型保持一致。
例如, 下例中会因为return 100中100类型(Int64)和函数foo的返回值类型String不同而报错

// Error: the type of the expression after return does not match the return type of the function
func foo(): String {
    return 100 // error: type mismatch
}

对于return, 其等价于return (), 所以函数的返回值类型为Uint

func add(a: Int64, b: Int64) {
    var r = 0
    r = a + b
    return r
}

func foo(): Unit{
    add(1, 2)
    return
}

提示
return表达式作为一个整体, 其类型并不由后面跟随的表达式决定, 而是 Nothing 类型

在函数体内定义的变量属于局部变量的一种, 它的作用域从其定义之后开始到函数体结束

对于一个局部变量, 允许在其外层作用域中定义同名变量, 并且在此局部变量的作用域内, 局部变量会”遮盖”外层作用域的同名变量

let r = 0
func add(a: Int64, b: Int64) {
    var r = 0
    r = a + b
    return r
}

👆上例, add函数之前定义了Int64类型的全局变量r, 同时add函数体内定义了同名的局部变量r, 那么在函数体内, 所有使用变量r的地方(如r = a + b), 用到的将是局部变量r, 即(在函数体内)局部变量r”遮盖”了全局变量r

函数体也是有类型的, 函数体的类型是函数体内最后一”项”的类型: 若最后一项为表达式, 则函数体的类型是此表达式的类型, 若最后一项为变量定义或函数声明, 或函数体为空, 则函数体的类型为 Unit

func add(a: Int64, b: Int64): Int64 {
    a + b
}

👆上例, 因为函数体的最后一”项”是Int64类型的表达式(即a + b), 所以函数体的类型也是Int64, 与函数定义的返回值类型相匹配。
又如, 下例函数体的最后一项是print函数调用, 所以函数体的类型是Unit, 同样与函数定义的返回值类型相匹配

func foo(): Unit{
    let s = "Hello"
    println(s)
}

函数类型#

函数类型由函数的参数类型和返回类型组成, 参数类型和返回类型之间使用->连接。参数类型使用圆括号()括起来, 可以有0个或多个参数, 如果参数超过两个, 参数类型之间使用逗号,分隔

func hello(): Unit{
    println("Hello!")
}

👆示例定义了一个函数, 函数名为hello, 其类型是()->Unit,表示该函数没有参数, 返回类型为Unit

func add(a: Int64, b: Int64): Int64 {
    a + b
}

👆函数名为add, 其类型是(Int64, Int64) -> Int64, 表示该函数有两个参数, 两个参数类型均为Int64, 返回类型为Int64

函数类型作为参数类型#

示例: 函数名为printAdd, 其类型是((Int64, Int64) -> Int64, Int64, Int64) -> Unit, 表示该函数有三个参数, 参数类型分别为函数类型(Int64, Int64) -> Int64和两个Int64, 返回类型为Unit

func printAdd(add: (Int64, Int64) -> Int64, a: Int64, b: Int64 ): Unit {
    println(add(a, b))
}

func demo(x: Int64, y: Int64): Int64{
    return x * y
}
main() {
    printAdd(demo, 10, 10)
}

函数类型作为返回类型#

函数类型可以作为另一个函数的返回类型 👇示例, 函数名为returnAdd, 其类型是() -> (Int64, Int64) -> Int64, 表示该函数无参数, 返回类型为函数类型(Int64, Int64) -> Int64。注意,->是右结合的

func add(a: Int64, b: Int64): Int64 {
    return a + b
}
func returnAdd(): (Int64, Int64) -> Int64 {
    add
}
main() {
    var a = returnAdd()
    println(a(1, 2)) // 3
}

函数类型作为变量类型#

函数名本身也是表达式, 它的类型为对应的函数类型

func add(p1: Int64, p2: Int64): Int64 {
    p1 + p2
}

let f: (Int64, Int64) -> Int64 = add

Lambda 表达式定义#

Lambda 表达式的语法形式: {p1: T1, ..., pn:Tn => expressions | declarations}

其中, =>之前为参数列表, 多个参数之间使用,分隔, 每个参数名和参数类型之间使用:分隔。=>之前也可以没有参数。=>之后为 Lambda 表达式体, 是一组表达式或声明序列

let f1 = { a: Int64, b: Int64 => a + b }
var display = { => println("Hello") }   // Parameterless Lambda

main() {
    println(f1(10, 20))  // 30
    display()            // Hello
}

Lambda 表达式中参数的类型标注可缺省。以下情形中, 若参数类型省略, 编译器会尝试进行类型推断

• Lambda 表达式赋值给变量时, 其参数类型根据变量类型推断
• Lambda 表达式作为函数调用表达式的实参使用时, 其参数类型根据函数的形参类型推断

var sum: (Int64, Int64) -> Int64 = { a, b => a + b }

func f(fn: (Int64) -> Int64): Int64{
    fn(1)
}

main() {
    println(sum(10, 20))            // 30
    println(f({ num => num + 10 })) // 11
}

Lambda 表达式声明#

Lambda 表达式支持立即调用

let r1 = { a: Int64, b: Int64 => a + b }(1, 2)
let r2 = { => 123}()

Lambda 表达式也可以赋值给一个变量, 使用变量名进行调用

func f() {
    var g = { x: Int64 => println("x = ${x}") }
    g(2)
}