变量|常量与可变性

变量声明

通过使用let 关键字进行变量声明，但是我们要知道如此声明的变量是不可变的！即若不进行指定则变量无法被修改，用Java来说就是在基础类型上添加了final关键字

let x = 1;

案例

fn main() {
    let x = 5;
    println!("{}", x);
    x = 6;
    println!("{}", x);
}

若你强行给x修改值则会出现如下报错信息

为什么不可变

这一设计相信大家学过Java使用jdk8以上的版本之后在IDEA中编写代码你的变量都会自动添加final关键字，这是因为要保证系统的安全。

所以Rust中直接声明的变量无法改变也是因为需要保证系统的安全，要知道如果程序的模块庞大而分散的时候，在一个地方声明的一个变量在另一个遥远的地方被改变了很容易引发难以追踪的错误。

变量可变（mut关键字）

我们可以通过使用mut关键字来声明一个变量是可变的

fn main() {
    let mut x = 5;
    println!("{}", x);
    x = 6;
    println!("{}", x);
}

但即使是这样，我们依然要知道Rust是一门强类型的语言所以我们不能进行如下的写法：

fn main() {
    let mut x = 5;
    println!("{}", x);
    x = "sgans";
    println!("{}", x);
}

变量可变（覆盖）

我们可以通过声明同一个变量名来修改变量，这样的修改是可以做到无视原始类型的，相当于重新进行了声明，官方称之为隐藏，但我更倾向于覆盖

fn main() {
    let x = 5;
    println!("{}", x);
    let x = "8xx";
    println!("{}", x);
}

常量声明

我们通过使用const关键字对一个常量进行声明，对于常量而言常量是不可变的且一定要规定常量的类型，常量一般使用全大写字符使用_进行单词间的分割，如下：

const TEST:i32 = 10086;

数据类型

上面我们也说过，Rust是个强（静态）类型语言，所以每一个值都有一个属于它的数据类型与之对应

标量类型

标量（scalar）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型

整型

在Rust中有六大类整型，每类分为有符号和无符号

每一个有符号的变体可以储存包含从-(2^n - 1)到 2^(n - 1) - 1 在内的数字，这里 n 是变体使用的位数。所以 i8 可以储存从 -(2^7) 到 2^7 - 1 在内的数字，也就是从 -128 到 127。无符号的变体可以储存从 0 到 2n - 1 的数字，所以 u8 可以储存从 0 到 2^8 - 1 的数字，也就是从 0 到 255。

整型字面值

整型溢出问题

这是个非常经典的问题，因为其他语言中也会有，在Rust中你多数时候不会意识到整型溢出，因为这并不会被检测出来，只有你使用cargo run|check|build命令进行编译时才会检测出来

在Rust中有以下一套规则：
使用 --release flag 在 release 模式中构建时，Rust 不会检测会导致 panic 的整型溢出。相反发生整型溢出时，Rust 会进行一种被称为二进制补码 wrapping（two’s complement wrapping）的操作。简而言之，比此类型能容纳最大值还大的值会回绕到最小值，值 256 变成 0，值 257 变成 1，依此类推。程序不会 panic，不过变量可能也不会是你所期望的值。依赖整型溢出 wrapping 的行为被认为是一种错误。

为了显式地处理溢出的可能性，可以使用这几类标准库提供的原始数字类型方法：

1. 所有模式下都可以使用 wrapping_* 方法进行 wrapping，如 wrapping_add
2. 如果 checked_* 方法出现溢出，则返回 None值
3. 用 overflowing_* 方法返回值和一个布尔值，表示是否出现溢出
4. 用 saturating_* 方法在值的最小值或最大值处进行饱和处理

浮点型

在Rust中只有以下两种浮点型，且都是有符号的

1. f32：单精度
2. f64：双精度

由于f64比f32精度更高，速度几乎一样快，所以我们常使用f64

布尔型

在rust中使用bool作为布尔型（true|false）

let flag:bool = true;

字符类型

let c: char = 'c';
let emoji = '😁';

注意emoji会打印出一个�所以还是算了别用吧

复合类型

复合类型（Compound types）可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）

元组

元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小，通过()进行声明且指定每个位置的类型

let tuple: (i8, f64) = (2, 6.332);

元组解构

如下我们通过m，n就能解析并得到对应元组中的值，我们称之为结构赋值

let (m, n) = tuple;

元组取值

元组取值的方式也很简单，你就认为元组是由一个一个单元组成起来的一栋楼，通过门牌号进行方位即可取值

let first = tuple.1

数组

数组中的每个元素的类型必须相同，且长度固定：一旦声明，其长度不会增大或缩小，我们通过[]声明数组

let arr: [i32; 3] = [1, 2, 3];

而这个数组的类型就是[i32; 3]前一个表示公共类型，后一个表示元素个数

数组取值

let first = arr[0];

我们的数组取值是和其他语言一样的

数组越界

这个问题也是一个经典问题了

index out of bounds

若你访问的的索引超出了数组容量，引发数组越界，在Rust中如不对其进行任何处理则会抛出panic！此时程序会直接中断！