定义变量

• let 定义不可变变量，块级作用域，可在作用域内重复定义同类型的变量（类似覆盖操作）。
• let mut 定义可变变量，可以动态的修改变量的值，而不是通过let来进行覆盖操作。

fn main() {
    let x = 5;
    println!("The value of x: {x}");
    let x = 888;
    println!("The value of x: {x}");

    let mut a = 5;
    println!("The value of a: {a}");
    a = 3;
    println!("The value of a: {a}");
}

定义常量

• const 编译时就固定的值。

const NUM: u32 = 5;
fn main() {
    println!("The value of NUM: {NUM}");
}

数据类型

标量（整数、浮点数、布尔值和字符）

1. 整数

isize 和 usize 类型取决于程序运行所在计算机的体系结构，在表中表示为"arch"：如果您使用的是 64 位体系结构，则为 64 bit；如果您使用的是 32 位体系结构，则为 32 bit

fn main() {
    // unsigned
    let x_8bit: u8 = b'V';
    println!("The value of x_8bit: {x_8bit}");
    let x_16bit: u16 = 0xff;
    println!("The value of x_16bit: {x_16bit}");
    let x_32bit: u32 = 5;
    println!("The value of x_32bit: {x_32bit}");
    let x_64bit: u64 = 5;
    println!("The value of x_64bit: {x_64bit}");
    let x_128bit: u128 = 5;
    println!("The value of x_128bit: {x_128bit}");

    //signed
    let ux_8bit: u8 = 5;
    println!("The value of ux_8bit: {ux_8bit}");
    let ux_16bit: u16 = 5;
    println!("The value of ux_16bit: {ux_16bit}");
    let ux_32bit: u32 = 5;
    println!("The value of ux_32bit: {ux_32bit}");
    let ux_64bit: u64 = 5;
    println!("The value of ux_64bit: {ux_64bit}");
    let ux_128bit: u128 = 5;
    println!("The value of ux_128bit: {ux_128bit}");
}

2. 浮点类型

f64、f32

浮点数根据 IEEE-754 标准表示。该 f32类型是单精度浮点数，并且f64具有双精度。

fn main() {
    let x_f32: f32 = 5.00000000006666;
    println!("The value of x_f32: {x_f32}"); // 5

    let x_f64: f64 = 5.00000000006666;
    println!("The value of x_f64: {x_f64}"); // 5.00000000006666
}

3. 布尔类型(bool)

true、false

fn main() {
    let b_false: bool = false;
    println!("The value of b_false: {b_false}"); // false

    let b_true: bool = true;
    println!("The value of b_true: {b_true}"); // true
}

4. 字符类型（char）

char用单引号指定文字，而不是使用双引号的字符串文字。Rust 的 char类型 大小为 4 个字节

fn main() {
    let c = 'z';
    println!("The value of c: {c}"); // z

    let z: char = '您'; // with explicit type annotation
    println!("The value of z: {z}"); // 您

    let heart_eyed_cat = '😻';
    println!("The value of heart_eyed_cat: {heart_eyed_cat}"); // �
}

复合类型（元组和数组）

元组类型

元组是将具有多种类型的多个值组合在一起形成一个复合类型的通用方法。元组有固定的长度：一旦声明，它们的大小就不能增长或缩小

fn main() {
    let tup: (u16, f32, u8) = (500, 6.4, 1);

    let _unit: () = ();

    let (x, y, z) = tup;

    println!("The value of top is: {_unit:?}");
    println!("The value of top is: {tup:?}");
    println!("The value of top is: {tup:#?}");
    println!("The value of x,y,z is: {x},{y},{z}");
}

数组类型

与其他一些语言中的数组不同，Rust 中的数组具有固定长度

fn main() {
    let a: [i32; 5] = [1, 2, 3, 4, 5];

    let first = a[0];
    println!("The value of top first: {first:?}");
    let second = a[1];
    println!("The value of top second: {second:?}");

    let a = [3; 5];
    println!("The value of top a: {a:?}"); //  [3, 3, 3, 3, 3]
}