块#

在仓颉语言中, 由一对匹配的大括号及其中可选的表达式声明序列组成的结构被称之为块(block)

块在仓颉语言中无处不在, 例如函数定义的函数体、if表达式的两个分支、while表达式的循环体, 都是块

块会引出新的作用域

块的语法定义为:

1
block
2
    : '{' expressionOrDeclarations '}'
3
    ;

块拥有值, 块的值由其中的表达式与声明序列确定

对块进行求值时, 会按表达式和变量声明在块中的顺序进行

若块的最后一项是表达式, 当该表达式求值完毕后, 该表达式的值即为该块的值:

1
{
2
    let a = 1
3
    let b = 2
4
    a + b
5
} // a + b的值就是此块的值

若块的最后一项是声明, 当该声明处理完毕后, 该块的值为():

1
{
2
    let a = 1
3
} // () 是此块的值

若块中不含有任何表达式或声明, 该块的值为():

1
{ } // () 是此块的值

仓颉中块也是存在值的, 且与块内的最后一个执行的表达式有关

类型应该也是吧? 值为()的块的类型是Unit?

作用域级别#

如果嵌套的多层作用域中存在相同的名字, 内层作用域引入的名字会遮盖外层作用域的名字, 我们称内层作用域级别比外层作用域级别更高

在嵌套的作用域中, 作用域级别比较定义如下:

1. 通过import引入的名字, 作用域级别最低
2. 包内top-level的名字, 其作用域级别比 1 中的名字高
3. 类型内部、函数定义或表达式中引入的名字, 其定义通常被包围在一对花括号{}(即块)中, 其作用域级别相较于花括号{}外层的名字要高
4. 对于类和接口, 子类中的名字比父类中的名字的作用域级别更高, 子类中的名字可能会shadow或override父类中的名字

1
import p1.a   // a 有最低的作用域级别
2

3
var x = 1   // x 的作用域级别比a高
4

5
open class A {    // A 的作用域级别与 第3行的x相同
6
    var x = 3     // 这个x 的作用域级别 比第3行的x高
7
    var y = 'a'
8
    func f(a: Int32, b: Float64): Unit {
9

10
    }
11
}
12

13
class B <: A {
14
    var x = 5   // 这个x 的作用域级别 比第6行的x高
15

16
    func f(x!: Int32 = 7) { // 这个x 的作用域级别 比第14行的x高
17

18
    }
19
}

作用域类型#

根据名字引入的位置分为三种:top-level, local-level, 类型内部, 这三种类型的scope原则各有不同

遮盖#

通常来说, 若两个相互重叠的拥有不同级别的作用域中引入了相同的名字, 则会发生遮盖(shadowing):

其中作用域级别高的名字会遮盖作用域级别低的名字

这导致作用域级别低的名字要么需要加上前缀限定词访问, 要么无法访问

当作用域级别高的名字的作用域结束时, 遮盖消除

具体说来, 作用域级别不同时:

1. 若作用域级别高的名字C为一个类型, 则直接发生遮盖

   1
   // == 在 package a 中 ==
   2
   public class C {} // ver 1
   3
   
   4
   // == 在 package b 中 ==
   5
   import a.*
   6
   
   7
   class C {} // ver 2
   8
   
   9
   let v = C() // will use ver 2
   

2. 若作用域级别高的名字x为一个变量, 则直接发生遮盖(对于成员变量的遮盖规则, 请参见 “类和接口” 章节)

   1
   let x = 1
   2
   
   3
   func foo() {
   4
       let x = 2
   5
       println(x) // will print 2
   6
   }
   

3. 若作用域级别高的名字p为package名字, 则直接发生遮盖

   1
   // == 在 package a 中 ==
   2
   public class b {
   3
       public static let c = 1
   4
   }
   5
   
   6
   // == 在 package a.b 中 ==
   7
   public let c = 2
   8
   
   9
   // == 在 package test 中 ==
   10
   import a.*
   11
   import a.b.*
   12
   
   13
   let v = a.b.c // will be 1
   

4. 若作用域级别高的名字f为一个成员函数, 则按重载的规则判断f是否发生重载, 如无重载, 则可能发生覆盖或重定义;

   如无重载且不能覆盖/重定义, 则报错(具体规则, 见[覆盖]、[重定义])

   1
   open class A {
   2
       public open func foo() {
   3
           println(1)
   4
       }
   5
   }
   6
   
   7
   class B <: A {
   8
       public override func foo() {  // override
   9
           println(2)
   10
       }
   11
   
   12
       public func foo() {  // error, conflicting definitions
   13
           println(3)
   14
       }
   15
   }
   

5. 若作用域级别高的名字f为非成员函数, 则按重载的规则判断f是否发生重载

   如无重载, 则视为遮盖

   1
   func foo() { 1 }
   2
   
   3
   func test() {
   4
       func foo() { 2 } // shadows
   5
       func foo(x: Int64) { 3 } // overloads
   6
   
   7
       println(foo()) // will print 2
   8
   }
   

下面的例子展示了函数内变量的作用域级别和之间的遮盖关系, 以及项与类型在同一命名空间

1
func g(): Unit {
2
      f(1, 2)  // OK. f 是顶层定义, 在整个文件中可见
3
}
4

5
func f(x: Int32, y: Int32): Unit {
6
    // Error. 变量名 Maze 遮盖了类型 Maze, 因此 Maze 不能用作类型
7
    // let Maze : Maze
8
    // var x = 1    // Error, x 已经在参数中引入了
9
    var i = 1       // OK
10

11
    for (i in 1..3) { // OK, i 是引入的一个新变量, 遮盖第9行定义的i
12
        let v = 1
13
    }              // i 和 v 消失
14

15
    print("${i}")     // OK. 这个 i 是第9行定义的
16
    // print("${v}")  // Error, v 已经消失了, 找不到 v
17
}
18

19
enum Maze {
20
    C1 | C2
21
    // | C1 // Error. C1 这个名字, 在同级作用域中已经用过了
22
}

下面的例子展示了不同包之间定义的变量和类的作用域级别关系和之间遮盖关系

1
// File a.cj
2
package p1
3

4
class A {}
5
var v: Int32 = 10
6

7
// File b.cj
8
package p2
9

10
import p1.A        // A 属于包 p1
11
import p1.v        // v 属于包 p1
12

13
// p2 定义了自己的 v, 其作用域级别高于包 p1 中的 v
14
var v: Int32 = 20
15

16
func displayV1(): Unit {
17
    // 根据作用域级别, p2.v 遮盖了 p1.v, 因此在此处访问 p2.v
18
    print("${v}")          // output: 20
19
}
20

21
var a = A()         // 调用 p1 中的A

下面的例子展示了继承中的遮盖关系

1
var x = 1
2

3
open class A {
4
      var x = 3   // 这个 x 遮盖了顶层作用域的 x
5
}
6

7
class B <: A {
8
    var x = 5   // error: 子类的成员不能遮盖父类的成员
9

10
    func f(x!: Int32 = 7): Unit { // 这个 x 会遮盖上面的所有 x
11

12
    }
13
}

成员函数不存在遮盖, 只有覆盖、重载、重定义, 重定义就会报错

也只有存在继承关系的类型中的成员函数会出现这些情况

变量的定义#

变量定义的语法定义为:

1
variableDeclaration
2
    : variableModifier* ('let' | 'var' | 'const') patternsMaybeIrrefutable (((':' type)? ('=' expression)) | (':' type))
3
    ;
4

5
patternsMaybeIrrefutable
6
    : wildcardPattern
7
    | varBindingPattern
8
    | tuplePattern
9
    | enumPattern
10
    ;

变量的定义均包括四个部分: 修饰符、let/var/const关键字、patternsMaybeIrrefutable和变量类型

其中:

1. 修饰符

   • top-level变量的修饰符包括:public, protected, private, internal
   • 局部变量不能用修饰符修饰
   • class类型的成员变量的修饰符包括:public, protected, private, internal, static
   • struct类型的成员变量的修饰符包括:public, private, internal, static

2. 关键字let/var/const

   • let用于定义不可变变量, let变量一旦初始化就不能再改变
   • var用于定义可变变量
   • const用于定义const变量

3. patternsMaybeIrrefutable

   • let(或var/const)之后只能是那些一定或可能为 irrefutable 的pattern(见 [模式的分类])

     在语义检查阶段, 会检查pattern是否真的是 irrefutable, 如果不是 irrefutablepattern, 则编译报错

   • let(或var/const)之后的pattern中引入的新的变量, 全部都是let修饰(或var修饰)的变量

   • 在class和struct中定义成员变量时, 只能使用binding pattern(见 [绑定模式])

4. 变量类型是可选的, 不声明变量类型时需要给变量初始值, 编译器将尝试根据初始值推断变量类型

5. 变量可以定义在top-level, 表达式内部, class/struct类型内部

顶层作用域种定义变量, 仓颉比 C/C++多了修饰符, 应该是包管理的原因, C/C++包管理不完善(悲)

根据已经了解的一些内容

patternsMaybeIrrefutable应该是变量名的模式, irrefutable是不可辩驳的意思, 意思应该是没有歧义

wildcardPattern通配符模式, 意思是, 定义时变量名可以是通配符? 应该是解构某些数据时, 忽略数据用的:let _ = "ignore data"

varBindingPattern变量绑定模式, 应该就是普通的变量:let val: Int64 = 30

tuplePattern元组模式, 解构元组时用的:let (_, val) = ("ignore data", 30)

enumPattern是枚举模式, 暂时想不出什么作用?

class和interface的成员变量, 只能是绑定模式, 只有varBindingPattern吗?

QUESTION

记录这两个问题, 具体了解到之后回答

需要注意的是:

1. pattern和变量类型之间需要使用冒号(:)分隔, pattern的类型需要和冒号后的类型相匹配

2. 关键字let/var/const和pattern是必选的

3. 局部变量除了使用上述语法定义之外, 还有如下几种情形会引入局部变量:

   • for-in循环表达式中, for和in中间的pattern, 详见 [for-in 表达式]
   • 函数、lambda定义中的形参, 详见 [参数]
   • try-with-resource表达式中ResourceSpecifications, 详见 [异常]
   • match表达式中, case后的pattern, 详见 [模式匹配表达式]

4. 可以使用一对反引号(` `)将关键字变为合法的标识符

   (例如, `open`等)

下面给出变量定义的一些实例:

1
let b: Int32                    // 定义 Int32 类型 只读变量b
2
let c: Int64                    // 定义 Int64 类型 只读变量b
3
var bb: String                // 定义 String 类型 可写变量bb
4
var (x, y): (Int8, Int16)        // 定义 Int8和Int16 类型 两个可写变量x, y
5
var`open`= 1                // 定义 变量名为`open`的值为1的变量
6
var`throw`= "throw"            // 定义 变量名为`throw`的值为"throw"的变量
7
const d: Int64 = 0            // 定义 Int64 类型 const变量bb, 初始化值为0

变量的初始化#

访问修饰符#

详细内容请参考包和模块管理章节[访问修饰符]

非访问修饰符#

仓颉提供了许多非访问修饰符以支持其它丰富的功能

• open 表示该实例成员可被子类覆盖, 或者该类能被子类继承, 详见[类]
• sealed 表示该class或interface只能在当前包内被继承或实现, 详见[类]
• override 表示覆盖父类的成员, 详见[类]
• redef 表示重新定义父类的静态成员, 详见[类]
• static 表示该成员是静态成员, 静态成员不能通过实例对象访问, 详见[类]
• abstract 表示该class是抽象类, 详见[类]
• foreign 表示该成员是外部成员, 详见[语言互操作]
• unsafe 表示与 C 语言进行互操作的上下文, 详见[语言互操作]
• sealed 表示该class或interface只能在当前包内被继承或实现, 详见[类]
• mut 表示该成员是具有可变语义的, 详见[函数]

这些修饰符的具体功能详见对应的章节

看来修饰符的使用与具体的语法结合得比较深

那就具体阅读到再具体了解