2.Rust变量

变量的声明

let关键字

在Rust中变量必须要先声明才能使用，let关键字用于声明变量并将一个值绑定到该变量上。如下:

fn main() {
    let var_name:i32 = 123123;
    println!("{}",var_name) //println! 是一个宏（macros），可以将文本输出到控制台（相当于js console.log）。
}
1
2
3
4

let声明的关键字具有模式解构功能。（怎么理解呢？相当于js中的解构赋值）

let声明变量的特点

1.模式解构：模式解构是一种用于匹配和解构数据的语法。Rust会尝试将等号右边的值与模式(=号左边的就是模式)进行匹配，并将匹配的部分绑定到变量上。
下面是一些场景的解构示例，看不懂不要着急，后面学了数据类型就明白了。

let (x, y, _) = (1, 2, 3); // 忽略元组的第三个元素
let [a, b, c] = [1, 2, 3]; // 解构数组
let Point { x, y } = Point { x: 1, y: 2 }; // 解构结构体
let Some(value) = Some(5); // 解构Option枚举类型的Some变体
1
2
3
4

2.只读的：let声明的变量是只读的如果我们修改会报错，例如：

fn main() {
   let var_name:i32 = 123123;
   var_name = 111;
   println!("{}",var_name);
}
1
2
3
4
5

报错如下：

我们可以看到也给我们提示了，不能给不可变变量var_name赋值两次，help中提示了我们可以使用mut关键字来让该变量变成可变的

 fn main() {
    let mut var_name:i32 = 123123;
    var_name = 111;
    println!("{}",var_name);
}
1
2
3
4
5

变量遮蔽

在Rust中当我们在同一作用域下声明同名变量，后声明的会“遮蔽”前面声明的变量，例如：

fn main() {
    let var_name:i32 = 123123;
    println!("{}",var_name); // 123123
    let var_name = "www";
    println!("{}",var_name); // www
}
1
2
3
4
5
6

冻结

什么是冻结？
当数据被相同的名称不变地绑定时，它还会冻结（freeze）。在不可变绑定超出作用域之前，无法修改已冻结的数据：

fn main() {
    let mut _mutable_integer = 7i32;

    {
        // 被不可变的 `_mutable_integer` 遮蔽
        let _mutable_integer = _mutable_integer;

        // 报错！`_mutable_integer` 在本作用域被冻结
        _mutable_integer = 50;
        // 改正 ^ 注释掉上面这行

        // `_mutable_integer` 离开作用域
    }

    // 正常运行！ `_mutable_integer` 在这个作用域没有冻结
    _mutable_integer = 3;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用场景

1.当我们使用变量时，需要把变量转换成另一个类型的变量，但是不改变其变量名。

fn main() {
	let num1:i32 = 123;
	let num1:i64 = 13222;
}
1
2
3
4

2.当我们需要修改变量可变性时，可以声明一个可变的变量，之后我们希望他不可变，变成只读的。

fn main() {
    let mut v = 123;
    v = 555;
    let v = v ;//此时v只读
}
1
2
3
4
5

Static静态变量

语法

fn main(){
	static CONFIG = "localhost"
}
1
2
3

特点
用关键字

1. static声明的变量，其生命周期是整个程序启动到退出。
2. 占用的内存空间在程序执行过程中不会回收。
3. static声明的变量同样具有模式匹配效果。

使用要注意的地方

由于Rust十分注意内存安全，因此全局变量使用有一些限制，防止程序员写出不安全的代码。

1. 全局变量声明时必须初始化。
2. 全局变量初始化时必须是编译时可以确定的常量。（不能是函数调用/表达式）

fn main() {
    static VERSION: &str = "1.0.0"; //√
    let x = 1 
    let y = 2
    static VERSION:i32 = x + y;// ×
    static VERSION = fn() // ×
}
1
2
3
4
5
6
7

4. 带有mut修饰的全局变量，在修改时，必须用unsafe关键字。（不建议使用）

fn main() {
    static mut VERSION:&str = "static";
    unsafe{
        VERSION = "mut static";
        println!("{}",VERSION);
    }
}
1
2
3
4
5
6
7

Const常量

使用const关键字声明的称为常量，常量不允许用mut关键字修饰
语法

fn main() {
    const VERSION: & str = "const var";
    println!("{}",VERSION);
}
1
2
3
4

特点

1. const声明常量不具备模式匹配功能。
2. 同样必须声明时初始化。
3. 编译器并不一定会给const声明常量分配内存。（在Rust中，const声明的常量是编译时常量（compile-time constants）。与变量不同，常量的值在编译期间就已知，而不是在运行时分配内存来存储常量的值，并且被直接嵌入到生成的二进制文件中。因此，对于常量，编译器通常不需要为其分配内存。）

变量作用域

每个声明的变量都有其有效范围。Rust中{}就代表一个作用域，在花括号内声明的变量知道当前作用域结束前都是有效的

{                      // str 在这里无效，它尚未声明
    let str = "hello";   // 从此处起，str 是有效的
}      
// str就被内存释放了
1
2
3
4

总结

1. 声明变量/常量需要使用关键字let,const,static。
2. 如果声明的变量需要修改要加上mut关键字。
3. 对于let和static声明的变量可以使用模式解构。
4. 变量在使用前必须初始化否则会报错。
5. 常量和静态变量都需要在声明时初始化切值不能为表达式和函数调用。