变量#

在仓颉编程语言中, 一个变量由对应的变量名、数据(值)和若干属性构成, 开发者通过变量名访问变量对应的数据, 但访问操作需要遵从相关属性的约束(如数据类型、可变性和可见性等)

变量定义的具体形式为:

1
修饰符 变量名: 变量类型 = 初始值

其中修饰符用于设置变量的各类属性, 可以有一个或多个, 常用的修饰符包括:

• 可变性修饰符: let与var, 分别对应不可变和可变属性, 可变性决定了变量 被初始化后其值还能否改变, 仓颉变量也由此分为不可变变量和可变变量两类

• const修饰符: const是一种特殊的变量修饰符

  它用于声明常量, 要求在声明时必须初始化, 一旦被赋值, 其值就不能被改变

  这与let修饰符类似, 都具有不可变的特性, 但const在使用上有更严格的限制

• 可见性修饰符: private与public等, 影响全局变量和成员变量的可引用范围, 详见后续章节的相关介绍

• 静态性修饰符: static, 影响成员变量的存储和引用方式, 详见后续章节的相关介绍

变量均支持赋值操作符(=), 与类型无关

let修饰的变量只能被赋值一次, 即初始化; var修饰的变量可以被多次赋值

变量, 是编程语言中为存储、使用某个类型的数据创建的一个元素

举一个最简单的例子:

1
var value: Int64 = 20

这个代码, 就创建了一个变量名为value的用于存储Int64类型数据的var可变变量, 并给定了一个初始值20

之后, 你就可以通过value使用存储在变量中的值, 目前是20, 你也可以通过value = 30以及类似的赋值操作, 修改value变量的值

当然, 如果是let value, 那就只能赋值一次

仓颉中, 你可以将变量看作一个贴有变量名贴纸的数据, 通过变量名就能访问数据

在定义仓颉变量时, 可变性修饰符是必要的, 在此基础上, 还可以根据需要添加其他修饰符

• 变量名应是一个合法的仓颉标识符

• 变量类型指定了变量所持有数据的类型

  当初始值具有明确类型时, 可以省略变量类型标注, 此时编译器可以自动推断出变量类型

• 初始值是一个仓颉表达式, 用于初始化变量, 如果标注了变量类型, 需要保证初始值类型和变量类型一致

  在定义全局变量或静态成员变量时, 必须指定初始值

  在定义局部变量或实例成员变量时, 可以省略初始值, 但需要标注变量类型, 同时要在此变量被引用前完成初始化, 否则编译会报错

例如, 下列程序定义了三个Int64类型的变量(分别为不可变变量a、可变变量b和const变量c)

随后修改了变量b的值, 同时将b的值赋值给a, 并调用println函数打印a, b和c的值

1
main() {
2
    let a: Int64
3
    var b: Int64 = 14
4
    const c: Int64 = 13
5
    b = 12
6
    a = b                         // 由 let 修饰的变量只能赋值一次, 即初始化
7
    println("${a}, ${b}, ${c}")
8
}

编译运行此程序, 将输出:

1
12, 12, 13

在定义变量时, 必须要从var、let、const中选择一个可变性修饰符进行修饰

分别对应可变变量(var)、不可变变量(let)以及常量变量(const)

变量名需要是一个合法的 标识符

一个变量一定被定义出来, 其类型就固定了, 就只能用来存储此类型数据, 如果是自定义类型 或许还可以存储其子类型

这与C/C++这种弱类型语言很不一样, C/C++中存在许多的隐式类型转换和强制类型转换, 而仓颉因为强类型所以少了很多类型转换

如果尝试修改不可变变量, 编译时会报错, 例如:

1
main() {
2
    let pi: Float64 = 3.14159
3
    pi = 2.71828                // Error, 无法赋值于不可变值
4
}

当初始值具有明确类型时, 可以省略变量类型标注, 例如:

1
main() {
2
    let a: Int64 = 2023
3
    let b = a
4
    println("a - b = ${a - b}")
5
}

其中变量b的类型可以由其初值a的类型自动推断为Int64, 所以此程序也可以被正常编译和运行, 将输出:

1
a - b = 0

不可变变量以及常量变量, 都是不可变性的变量, 无法多次赋值

在定义变量时, 如果直接进行初始化, 且初始化数值的类型是确定的, 那么定义变量类型可以省略声明, 由编译器自动推断

在定义局部变量时, 可以不进行初始化, 但一定要在变量被引用前赋予初值, 例如:

1
main() {
2
    let text: String
3
    text = "仓颉造字"
4
    println(text)
5
}

编译运行此程序, 将输出:

1
仓颉造字

在定义全局变量和静态成员变量时必须初始化, 否则编译会报错, 例如:

1
let global: Int64                   // Error, 在顶层作用域中的变量必须初始化
2

3
main(): Unit{
4

5
}
6

7
class Player {
8
    static let score: Int32         // Error, 静态变量 'score' 在声明时需要初始化
9
}

需要注意的是, 当编译器无法判断某些场景是否一定会被初始化或无法判断是否重复初始化了不可变变量时, 会倾向于保守策略进行编译报错, 见如下示例:

1
func calc(a: Int32){
2
    println(a)
3
    return a * a
4
}
5
main() {
6
    let a: String
7
    if(calc(32) == 0){
8
      a = "1"
9
    }
10
    a = "2"                         // Error, 无法赋值于不可变值
11
}

此外, 对于try-catch场景, 编译器会假设try块总是全部被执行, 且总是抛异常, 从而进行相关报错, 见如下示例:

1
main() {
2
    let a: String
3
    try {
4
        a = "1"
5
    } catch (_) {
6
        a = "2"                     // Error, 无法赋值于不可变值
7
    }
8
}

局部let和var变量的在定义时, 可以不进行初始化, 但在首次使用之前必须要进行赋值, 否则编译报错

全局变量和静态变量, 必须在定义时进行初始化

且注意, 仓颉的try-catch中, 编译器静态语法解析时, 认为try块总是被全部执行, 且总是抛异常

意思是, 仓颉编译器总认为, try-catch的所有块中的代码全部都被执行, 即使try实际并不会抛异常, catch实际也并不会被执行

那么如果你尝试在两个块中, 各执行一次原本不允许多次执行的语句, 编译器也会认为这两句都一定会执行, 那么就出现了错误

const变量#

const变量是一种特殊的变量, 它以关键字const修饰, 定义在编译时完成求值, 并且在运行时不可改变的变量

例如, 下面的例子定义了万有引力常数G:

1
const G = 6.674e-11

const变量可以省略类型标注, 但是不可省略初始化表达式

const变量可以是全局变量, 局部变量, 静态成员变量

但是const变量不能在扩展中定义

const变量可以访问对应类型的所有实例成员, 也可以调用对应类型的所有非mut实例成员函数

const变量, 在编译时求值, 运行时禁止修改

const变量在定义时, 必须进行初始化, 即:

1
const nonInitCVar: Int64    // Error, const 变量声明必须初始化
2

3
const initCVar = 10         // OK

const变量可以访问所有非mut实例成员

下例定义了一个struct, 记录行星的质量和半径, 同时定义了一个const成员函数gravity用来计算该行星对距离为r质量为m的物体的万有引力:

1
struct Planet {
2
    const Planet(let mass: Float64, let radius: Float64) {}
3

4
    const func gravity(m: Float64, r: Float64) {
5
        G * mass * m / r ** 2
6
    }
7
}
8

9
main() {
10
    const myMass = 71.0
11
    const earth = Planet(5.972e24, 6.378e6)
12
    println(earth.gravity(myMass, earth.radius))
13
}

编译执行得到地球对地面上一个质量为71kg 的成年人的万有引力:

1
695.657257

const变量初始化后该类型实例的所有成员都是const的(深度const, 包含成员的成员), 因此不能被用于左值

1
main() {
2
    const myMass = 71.0
3
    myMass = 70.0           // Error, 无法赋值于不可变值
4
}

const变量初始化之后, 该实例的所有直接或间接的成员均为const, 被称为深度const

const变量在定义时, 必须要进行初始化, 而初始化所使用的表达式, 必须是const表达式

const表达式可以是const变量, 可以是数据的字面量, 可以是const表达式, 也可以是const函数等

但, 不能是其他类型变量或函数等

1
const cG = 6.674e-11
2
let letG = 6.674e-11
3

4
func getName() {
5
    return "humid1ch"
6
}
7

8
const func getCName() {
9
    return "humid1ch"
10
}
11

12
main() {
13
    const cName = getCName()        // OK
14
    const tryCName = getName()      // Error, 'const' 表达式, 保证在编译时进行计算
15

16
    const newCG = cG                // OK
17
    const tryCG = letG              // Error, 'const' 表达式, 保证在编译时进行计算
18
}

1
func f1() {
2
    // 这里是 作用域1 的范围
3
    var value = 1
4
    println(value)
5
}
6

7
func f2() {
8
    // 这里是 作用域2 的范围
9
    var value = 2
10
    println(value)
11
}

1
func fOut() {
2
    // 这里是 外层作用域 in1
3
    var value = 2
4
    println("in1: ${value}")
5

6
    func fIn() {
7
        // 这里是 内层作用域 out1
8
        println("out1: 定义value之前 ${value}")
9
        var value = 3
10
        println("out1: 定义value之后 ${value}")
11
        if (value != 2) {
12
            // 这里是 更内层的作用域 out2
13
            println("out2: 定义value之前 ${value}")
14
            var value = 4
15
            println("out2: 定义value之后 ${value}")
16
        }
17
    }
18

19
    fIn()
20
}