数值类型字面量#

详细的表述, 在 阅读仓颉文档的第一篇文章 中 有涉及仓颉中的整型字面量 和 浮点类型字面量

浮点类型量中有几个特殊的值需要注意: 正无穷(POSITIVE_INFINITY), 负无穷(NEGATIVE_INFINITY), Not a Number(NaN), 正0(+0.0), 负0(-0.0)

其中, 无穷表示操作结果超出了表示范围, 例如将两个很大的浮点数相乘, 或将一个非零浮点数除以浮点零时, 其结果都是无穷, 无穷的符号由操作数的符号决定, 符合”正负得负, 负负得正”的规律

NaN表示既不是实数也不是无穷的情况, 例如计算正无穷乘以0的结果就是NaN

仓颉编程语言中的浮点小数类型的最小正值为非正规浮点小数 (subnormal floating point number)

对于Float32类型最小可表示的正浮点数为 2⁻¹⁴⁹, 大约为1.4e-45; 而最大值可表示的数为 (2 − 2⁻²³)×2¹²⁷, 大约为3.40282e38

对于Float64类型最小可表示的正浮点数为 2⁻¹⁰⁷⁴, 大约为4.9e-324; 而最大可表示的数为 (2 − 2⁻⁵²)×2¹⁰²³, 大约为1.79769e308

当非 0 的浮点小数字面值因过小或者过大而舍入得到 0 或者无穷, 那么编译器会告警

数值类型支持的操作符#

数值类型支持的操作符包括: 算术操作符、位操作符、关系操作符、自增(减)操作符、一元负号操作符和(复合)赋值操作符

其中浮点类型不支持位操作符

算术操作符包括加(+)、减(-)、乘(*)、除(/)、取余(%)、取幂(**)

默认算术操作符没有被重载的情况下, 要求算术操作符的两个操作数的类型必须相同, 如果要将两个不同类型的操作数进行操作, 必须先进行强制类型转换

这一句表述, 其实也是 仓颉语言是一种强类型语言的一种体现

在算术操作符没有重载的情况下, 即 操作符功能是默认的情况下, 操作符两边的操作数的类型要一致

这里的一致, 不仅仅是只 整型 或 浮点型, 还有具体类型也要一致, 即 如果一个操作数为Int32则 另一个操作数也必须是Int32

下面这段代码, 就会出现问题:

1
main() {
2
    var int32Val: Int32 = 30
3
    var int64Val: Int64 = 30
4
    var intVal = int32Val + int64Val
5

6
    return 0
7
}

错误: 二元操作符+的操作数为Int32和Int64两种类型, 不合法

位操作符 包括位求反(!)、左移(<<)、右移(>>)、位与(&)、位异或(^)、位或(|)

关系操作符包括小于(<)、大于(>)、小于等于(<=)、大于等于(>=)、相等(==)、不等(!=), 关系表达式的结果是一个Bool类型的值(true或false)

仓颉中关系表达式的结果是Bool类型的, 可以作为判断条件使用

自增(减)操作符包括自增(++)和自减(--), 可看做是一种特殊的赋值操作符(见下), 用于实现将变量值加(减)1

自增(减)操作符只能作为后缀操作符使用, 且只能作用于整数类型可变变量, 因为不可变变量和整数字面量的值不允许修改

与 C/C++中的++和--不同, 仓颉语言中的++和--只能后置

仓颉中的++和--只能操作 整型可变变量, 即var修饰定义的整型变量

文章提到, 更详细的说明, 在关于表达式的内容中有介绍

一元负号操作符使用-表示, 结果是对其操作数取负

(复合)赋值操作符包括赋值(=)和复合赋值操作(op=), 其中op可以是算术操作符、逻辑操作符和位操作符中的任意二元操作符

(复合)赋值操作可以实现一个值为数值类型的表达式到数值类型变量的赋值

1
main() {
2
    let val = 30.0
3
    if (val == Float64.NaN) {
4
        println("val == NaN")
5
    }
6

7
    if (val != Float64.NaN) {
8
        println("val != NaN")
9
    }
10

11
    return 0
12
}

插值字符串#

插值字符串 是一种包含一个或多个插值表达式的字符串字面量(不适用于多行原始字符串字面量)

当插值字符串解析为结果字符串时, 每个插值表达式所在位置会被对应表达式的结果替换

每个插值表达式必须用{}括号包起来, 并加上$前缀, 大括号中支持和 块 中一样的表达式声明序列, 但不能为空

多行字符串中的插值表达式支持换行

插值字符串, 应该是 C++开发者心心念念了很久的东西了, 但即使是 C++最新的标准, 它还没有呈上来

这应该是现代语言非常常用的一种字符串字面量

1
main() {
2
    let obj = "apples"
3
    let count = 10
4
    let interps1 = "There are ${count * count} ${obj}."
5
    println(interps1)
6

7
    return 0
8
}

"There are ${count * count} ${obj}."就是一种插值字符串, ${count * count}和${obj}都是插值表达式

如果字符串中的$符号后面没有{, 则当成普通$符号处理

如果在$前添加了转义字符\, 那么无论$符号后面是不是{, 都不会被当成插值表达式处理

插值表达式也支持自定义类型, 只要该类型满足ToStringinterface 约束

插值字符串中的插值表达式, 都会被转换为对应的字符串

插值表达式的{}中应该支持, 任何完整的、类型存在接口toString的表达式

元组字面量#

不过, 仓颉中并不存在Tuple这个关键字, 也意味着仓颉的元组类型并不使用关键字

元组字面量使用格式(expr1, expr2, ... , exprN)表示, 其中多个表达式之间使用逗号分隔, 并且每个表达式可以拥有不同的类型

仓颉中元组字面量就像这样:(1, 2, 3, "one_two_three"), 对应的类型就是(Int64, Int64, Int64, String)

即, 类似(type1, type2, ..., typeN)这样的格式作为元组的类型

使用元组做解构#

元组也可以用来对另一个元组值进行解构: 将一个元组中不同位置处的元素分别绑定到不同的变量

1
func multiValues(a: Int32, b: Int32): (Int32, Int32) {
2
    return (a + b, a - b) // The type of the return value of the function multiValues is (Int32, Int32).
3
}
4

5
main() {
6
    var (x, y) = multiValues(8,24) // Define an anonymous tuple who has two elements, i.e., x and y.
7
    print("${x}") // output: 32
8
    print("${y}") // output: -16
9
    return 0
10
}

按照文档中的例子:

函数multiValues会返回一个(Int32, Int32)类型的元组

main()函数中, 执行var (x, y) = multiValues(8, 24), 将返回的元组解构到两个变量中

最终的结果, x被赋值为 32, y被赋值为-16, 即为multiValues(8, 24)返回的元组(8+24, 8-24)的两个元素

NOTE

类似var (x, y)的方式, 是仓颉中的多变量声明的一种方式

在上面的示例中, 用于元组的解构赋值

如果只是要声明变量, 而不是解构元组, 就需要指明变量类型:

1
var (x, y): (Int64, Int64)

元组的下标访问#

元组支持通过tupleName[index]的方式访问其中某个具体位置的元素(index表示从0开始的下标, 并且只能是一个Int64类型的字面量)

元组中元素的访问, 可以通过下标访问, 范围是[0, 1, ...]

重点是, 下标只能是Int64类型的字面量, 不能是任何变量

即:

1
let tuple = (1, 2)
2
tuple[0]        // √
3

4
let index = 0
5
tuple[index]    // ×

定义元组类型的变量#

在定义元组类型的变量时, 可以省略类型标注, 由编译器根据程序上下文推断出具体的类型

1
let tuplePIE = (3.14, "PIE")     // The type of tuplePIE is inferred to be (Float64, String).
2
var pointOne = (2.4, 3.5)         // The type of pointOne is inferred to be (Float64, Float64).
3
var pointTwo = (2, 3, 4)         // The type of pointTwo is inferred to be (Int64, Int64, Int64).
4
var pointThree = ((2, 3), 4)     // The type of pointThree is inferred to be ((Int64, Int64), Int64).

除了省略类型让编译器自动推断外, 肯定要先了解不省略的定义方式:

1
let tuplePIE: (Float64, String) = (3.14, "PIE")
2
var pointOne: (Float64, Float64) = (2.4, 3.5)
3
var pointTwo: (Int64, Int64, Int64) = (2, 3, 4)
4
var pointThree: ((Int64, Int64), Int64) = ((2, 3), 4)

因为元组的元素可以是任意类型的, 所以也可以元组套元组

创建Range实例#

存在两种Range操作符:..和..=, 分别用于创建”左闭右开”和”左闭右闭”的Range实例

它们的使用方式分别为start..end:step和start..=end:step(其中start、end和step均是表达式)

关于这两种表达式, 说明如下

1. 要求start和end的类型相同, step的类型为Int64

2. 表达式start..end:step中,

   当step > 0且start >= end, 或者step < 0且start <= end时, start..end:step返回一个空Range实例(不包含任何元素的空序列);

   如果start..end:step的结果是非空Range实例, 则Range实例中元素的个数等于(end-start)/step向上取整(即大于等于(end-start)/step的最小整数)

3. 表达式start..=end:step中, 当step > 0且start > end, 或者step < 0且start < end时, start..=end:step返回一个空Range实例; 如果start..=end:step的结果是非空Range实例, 则Range实例中元素的个数等于((end-start)/step)+1向下取整(即小于等于((end-start)/step)+1的最大整数)

   1
   let range1 = 0..10:1     // Define an half-open range [0,10) (with step = 1) which contains 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9.
   2
   let range2 = 0..=10:2     // Define a closed range [0,10] (with step = 2) which contains 0, 2, 4, 6, 8 and 10.
   3
   let range3 = 10..0:-2     // Define an half-open range [10,0) (with step = -2) which contains 10, 8, 6, 4 and 2.
   4
   let range4 = 10..=0:-1     // Define a closed range [10,0] (with step = -1) which contains 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 and 0.
   5
   let range5 = 10..0:1     // Define an empty range.
   6
   let range6 = 0..0:1     // Define an empty range.
   7
   let range7 = 0..=0:1    // Define a closed range [0,0] (with step = 1) which only contains 0.
   8
   let range8 = 0..=10:-1     // Define an empty range.
   

4. 表达式start..end:step和start..=end:step中, step的值不能等于0

   1
   let range9 = 0..10: 0                 // error: the value of the step should not be zero.
   2
   let range10 = 0..=10: 0             // error: the value of the step should not be zero.
   

5. 除了下节提到的Range<Int64>类型的实例用在下标操作符[]中时可以省略start或end外, 其他场景下, start和end均是必选的, 只有step是可选的(默认step=1)

   1
   let range11 = 1..10          // Define an half-open range [1, 10) with step = 1.
   2
   let range12 = 1..=10          // Define a closed range [1, 10] with step = 1.
   3
   let range13 = ..10              // error: the start value is required.
   4
   let range14 = 1..              // error: the end value is required.
   5
   let range15 = ..              // error: the start and end value are required.
   

Range类型的使用#

Range类型的表达式主要用在for-in表达式中, 以及作为下标用于截取片段

需要注意的是:

• 当Range<Int64>类型的实例用在下标操作符[]中时, start和end均是可选的
• 它们的值由使用的上下文决定: 在自定义类型上重载下标操作符[]且参数类型是Range<Int64>时, 使用过程中省略start时start的值等于0, 省略end时end的值等于Int64的最大值

“Range类型的表达式主要用在for-in表达式中, 以及作为下标用于截取片段”

for-in表达式的部分具体阅读到地方在具体了解

不过, Range可以作为下标用于截取片段

那么就意味着, Range可以出现在[]操作符中

结合文档的内容, 就会出现这几种合法用法:

1
obj[..end]
2
obj[start..]
3
obj[start..end]
4
obj[start..end:1]

且经测试, 在仓颉标准库提供的Array和ArrayList等类型中, Range作为下标用于截取片段时, step只能为1

且, 即 如果使用..=的形式且不指定end, 会抛异常

以及, 如果start或end被省略, step禁止被显式指定, 会出现语法错误

定义Range类型变量#

在定义Range<T>类型的变量时, 可以显式添加类型标注, 也可以省略类型标注(此时由编译器根据程序上下文推断)

1
let range16: Range<Int64> = 0..10         // Define an half-open range [0,10) with step = 1
2
let range17: Range<Int64> = -10..10:2     // Define an half-open range [-10,10) with step = 2
3
let range18 = 0..=10                     // Define a closed range [0,10] with step = 1
4
let range19 = -10..=10:2                 // Define a closed range [-10,10] with step = 2

定义enum类型#

定义enum类型的语法为:

1
enumDefinition
2
    : enumModifier? 'enum' identifier typeParameters? ('<:' superInterfaces)? genericConstraints? '{' enumBody '}'
3
    ;
4

5
enumBody
6
    : '|'? caseBody ('|' caseBody)* (functionDefinition | operatorFunctionDefinition | propertyDefinition | macroExpression)*
7
    ;
8

9
caseBody
10
    : identifier ('(' type (',' type)* ')')?
11
    ;

其中enumModifier是enum类型的修饰符(即public), enum是关键字, identifier是enum类型的名字, typeParameters和genericConstraints分别是类型变元列表和类型变元的约束

enumBody中可以定义若干caseBody(即constructor), 每个constructor可以没有参数, 也可以有一组不同类型的参数, 多个constructor之间使用|分隔, 第一个constructor之前可以存在一个可选的|

caseBody后可以定义enum的其它成员, 包含成员函数、操作符重载函数、成员属性

C/C++中的枚举, 与现代语言中的枚举一般会存在很大的不同

以仓颉中的枚举类型为例, 按照文档中的说明, 仓颉的枚举类型是可以携带参数的, 且枚举类型内部还可以实现成员函数、成员属性等

1
enum TimeUnit1 {
2
    Year | Month | Day | Hour
3
}
4

5
enum TimeUnit2 {
6
    | Year(Float32)
7
    | Month(Float32, Float32)
8
    | Day(Float32, Float32, Float32)
9
    | Hour(Float32, Float32, Float32, Float32)
10
}
11

12
enum TimeUnit3<T1, T2> {
13
    | Year(T1)
14
    | Month(T1, T2)
15
    | Day(T1, T2, T2)
16
    | Hour(T1, T2, T2, T2)
17
}

关于enum类型, 需要注意的是:

1. enum类型只能定义在top-level, 即 顶层作用域

2. 不支持空括号无参的constructor定义, 且无参constructor的类型为被定义的enum类型本身, 不视作函数类型

   有参的constructor具有函数类型, 但不能作为一等公民使用:

   1
   enum E {
   2
       | mkE // OK. The type of mkE is E but not () -> E.
   3
       | mkE() // Syntax error.
   4
   }
   5
   
   6
   enum E1 {
   7
       | A
   8
   }
   9
   let a = A // ok, a: E1
   10
   
   11
   enum E2 {
   12
       | B(Bool)
   13
   }
   14
   let b = B // error
   15
   // 不能作为一等公民
   16
   
   17
   enum E3 {
   18
       | C
   19
       | C(Bool)
   20
   }
   21
   let c = C // ok, c: E3
   

3. 作为一种自定义类型, enum类型默认不支持使用==(!=)进行判等(判不等)

   当然, 可以通过重载==(!=)操作符使得自定义的enum类型支持==(!=)

4. 同一个enum中支持constructor的重载, 但是只有参数个数参与重载, 参数类型不参与重载, 也就是说, 允许同一个enum中定义多个同名constructor, 但是要求它们的参数个数不同(没有参数的constructor虽不为函数类型, 也可以与其它constructor重载), 例如:

   1
   enum TimeUnit4 {
   2
       | Year
   3
       | Year(Int32)                              // ok
   4
       | Year(Float32)                          // error: redeclaration of 'Year'
   5
       | Month(Int32, Float32)                  // ok
   6
       | Month(Int32, Int32)                      // error: redeclaration of 'Month'
   7
       | Month(Int32)                              // ok
   8
       | Day(Int32, Float32, Float32)           // ok
   9
       | Day(Float32, Float32, Float32)          // error: redeclaration of 'Day'
   10
       | Day(Float32, Float32)                  // ok
   11
       | Hour(Int32, Float32, Float32, Float32) // ok
   12
       | Hour(Int32, Int32, Int32, Int32)          // error: redeclaration of 'Hour'
   13
       | Hour(Int32, Int32, Int32)              // ok
   14
   }
   

5. enum类型支持递归和互递归定义, 例如:

   1
   // 递归
   2
   enum TimeUnit5 {
   3
       | Year(Int32)
   4
       | Month(Int32, Float32)
   5
       | Day(Int32, Float32, Float32)
   6
       | Hour(Int32, Float32, Float32, Float32)
   7
       | Twounit(TimeUnit5, TimeUnit5)
   8
   }
   9
   
   10
   // 互递归定义
   11
   enum E1 {
   12
       A | B(E2)
   13
   }
   14
   enum E2 {
   15
       C(E1) | D(E1)
   16
   }
   

6. enum不可以被继承

7. enum可以实现接口

enum值的访问#

enum值有两种访问方式:

第一种是通过enum名加上constructor名的访问方式

第二种是省略enum名的方式

假设存在:

1
enum TimeUnit1 {
2
    Year | Month | Day | Hour
3
}
4

5
enum TimeUnit2 {
6
    | Year(Float32)
7
    | Month(Float32, Float32)
8
    | Day(Float32, Float32, Float32)
9
    | Hour(Float32, Float32, Float32, Float32)
10
}
11

12
enum TimeUnit3<T1, T2> {
13
    | Year(T1)
14
    | Month(T1, T2)
15
    | Day(T1, T2, T2)
16
    | Hour(T1, T2, T2, T2)
17
}

第一种方式就是: 通过enum名.constructor(参数)的方式访问

1
let time1 = TimeUnit1.Year
2
let time2 = TimeUnit2.Month(1.0, 2.0)
3
let time3 = TimeUnit3<Int64, Float64>.Day(1, 2.0, 3.0)

第二种方式, 则是省略enum名:

1
let time1 = Year
2
let time2 = Month(1.0, 2.0)
3
let time3 = Day<Int64, Float64>(1, 2.0, 3.0)

关于第二种使用方式需要满足以下规则:

当不存在其它变量名、函数名、类型名、包名冲突的时候, 可以省略类型前缀使用

否则会优先选择变量名、函数名、类型名或包名

enum类型的解构#

使用match表达式和enum pattern可以实现对 enum 的解构

1
let time12 = TimeUnit1.Year
2
let howManyHours = match (time12) {
3
    case Year => 365 * 24 // matched
4
    case Month => 30 * 24
5
    case Day => 24
6
    case Hour => 1
7
}
8

9
let time13 = TimeUnit2.Month(1.0, 1.5)
10
let howManyHours = match (time13) {
11
    case Year(y) => y * 365.0 * 24.0
12
    case Month(y, m) => y * 365.0 * 24.0 + m * 30.0 * 24.0 // matched
13
    case Day(y, m, d) => y * 365.0 * 24.0 + m * 30.0 * 24.0 + d * 24.0
14
    case Hour(y, m, d, h) => y * 365.0 * 24.0 + m * 30.0 * 24.0 + d * 24.0 + h
15
}

match表达式的具体使用, 在本篇文档中没有提及, 之后进行阅读

不过大概意思是, match可以匹配enum类型值, 同时可以将值携带的参数数据提取出来使用

enum的其他成员#

enum中也可以定义成员函数、操作符函数和成员属性

• 定义普通成员函数 参见[函数定义]
• 定义操作符函数的语法 参见[操作符重载]
• 定义成员属性的语法 参见[属性的定义]

enum中的constructor、静态成员函数、实例成员函数之间不能重载

因此, enum的constructor、静态成员函数、实例成员函数、成员属性之间均不能重名

虽然本篇文档中没有涉及成员函数、操作符函数和成员属性的定义语法

但是有一个简单的例子:

1
enum Foo {
2
    A | B | C
3
    func f1() {
4
        f2(this)
5
    }
6
    static func f2(v: Foo) {
7
        match (v) {
8
            case A => 0
9
            case B => 1
10
            case C => 2
11
        }
12
    }
13
    prop item: Int64 {
14
        get() {
15
            f1()
16
        }
17
    }
18
}
19

20
main() {
21
    let a = Foo.A
22
    a.f1()
23
    Foo.f2(a)
24
    a.item
25
}

大致可以看出, 成员函数可以通过enum值调用, 静态成员函数还可以通过enum类型直接调用

成员属性, 可以通过值访问, 调用get()方法, 应该还有set()方法

Option值的解构#

提供若干方式以方便对 Option 值的解构: 模式匹配、getOrThrow函数、coalescing操作符(??)和问号操作符(?)

1. Option类型是一种enum类型, 因此可以使用模式匹配表达式中的enum pattern实现Option值的解构

   1
   let number1 = match (opInt32_1) {
   2
       case Some(num) => num
   3
       case None => 0
   4
   }
   5
   
   6
   let number2 = match (opInt32_2) {
   7
       case Some(num) => num
   8
       case None => 0
   9
   }
   10
   
   11
   let enumValue = match (opEnum) {
   12
       case Some(tu) => match (tu) {
   13
                             case Year => "Year"   // matched
   14
                             case Month => "Month"
   15
                             case Day => "Day"
   16
                             case Hour => "Hour"
   17
                         }
   18
       case None => "None"
   19
   }
   

2. 对于Option<T>类型的表达式e, 通过调用函数getOrThrow()或getOrThrow(exception: ()->Exception)实现对e的解构:

   如果e的值等于Option<T>.Some(v), 则e.getOrThrow()(或e.getOrThrow(lambdaArg))的值等于v的值;

   如果e的值等于Option<T>.None, 则e.getOrThrow()在运行时抛出NoneValueException异常(e.getOrThrow(lambdaArg)在运行时抛出lambdaArg中指定的异常)

   1
   let number1 = opInt32_1.getOrThrow()                 // number1 = 100
   2
   let number2 = opInt32_2.getOrThrow()                 // throw NoneValueException
   3
   let number3 = opInt32_2.getOrThrow{ MyException("Get None value") } // throw MyException
   

3. 对于Option<T>类型的表达式e1和T类型的表达式e2, 表达式e1 ?? e2的类型为T

   当e1的值等于Option<T>.Some(v)时, e1 ?? e2的值等于v的值;

   当e1的值等于Option<T>.None时, e1 ?? e2的值等于e2的值

   1
   let number1 = opInt32_1 ?? 0  // number1 = 100
   2
   let number2 = opInt32_2 ?? 0  // number2 = 0
   

4. 问号操作符(?)是一元后缀操作符

   ?需和后缀操作符., (), {}或[]一起使用, 以实现Option<T>对这些后缀操作符的支持

   对于一个Option类型的表达式e, e?.b表示当e为 Some 时得到Option<T>.Some(b), 否则得到Option<T>.None(T 为 b 的类型), 其它操作符同理

   1
   class C {
   2
       var item = 100
   3
   }
   4
   let c = C()
   5
   let c1 = Some(c)
   6
   let c2 = Option<C>.None
   7
   let r1 = c1?.item   // r1 = Option<Int64>.Some(100)
   8
   let r2 = c2?.item   // r2 = Option<Int64>.None
   

Option在match中的解构, 就是匹配有值和无值两种情况, 并进行处理

同时Option类型的表达式内置函数getOrThrow(), 如果有值则获取值, 如果无值, 则抛出异常

而, Option<T>类型的表达式, 还可以通过e1 ?? e2表达式, 如果有值则获取值, 如果无值 则获取e2这个默认值, e2的类型为T

然后就是?操作符, Option<T>类型表达式后可用?操作符再后接访问T类型内元素的操作符:.、[]、()等, 获取Some(T)或None