1. 基础语法¶

1.1. 实例声明¶

1.1.1. 变量¶

不可变变量 let ：代码可读性强；每次需要创建实例，开销较大；
可变变量 let mut ：复用变量/地址空间；

1.1.2. 常量¶

声明方式 const ：不允许用mut；必须注明值的类型；常量只能被设置为常量表达式；

const MAX_POINTS: u32 = 100_000;

let mut guess = String::new();
// 创建了一个可变变量，当前它绑定到一个新的 String 空实例上

::new 那一行的 :: 语法表明 new 是 String 类型的一个 关联函数（associated function）。关联函数是针对类型实现的，在这个例子中是 String，而不是 String 的某个特定实例。一些语言中把它称为 静态方法（static method）。

new 函数创建了一个新的空字符串（String类的实例），很多类型上有 new 函数

1.2. 数据类型¶

1.2.1. 标量（scalar）¶

1.2.2. 复合（compound）¶

1.2.2.1. 元组（tuple）¶

元组长度固定：一旦声明，其长度不会增大或缩小。

fn main() {
    //创建了一个包含多个类型元素的元组，并绑定到 tup 变量上。
    let tup = (500, 6.4, 1);

    // 接着使用了 let 和一个模式将 tup 分成了三个不同的变量，x、y 和 z。这叫做 解构（destructuring）
    let (x, y, z) = tup;

    println!("The value of y is: {}", y);

    let tuple: (i32, f64, u8) = (500, 6.4, 1);

    // 也可以使用点号（.）后跟值的索引来直接访问它们
    println!("The value of x is: {}", tuple.0);
}

1.2.2.2. 数组（array）¶

数组固定长度：一旦声明，它们的长度不能增长或缩小。

fn main() {
    // [元素类型; 元素数量] i32: 标量类型； 5个元素
    let a: [i32; 5] = [1, 2, 3, 4, 5];

    // 数组是一整块分配在栈上的内存。可以使用索引来访问数组的元素
    let first = a[0];
    println!("first = {} ", first);
}

1.3. 函数调用¶

每个参数需要注明类型，返回值用 -> 表示

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

fn plus_one(x: i32) -> i32 {
    // return x + 1; 显式的 x + 1
    x + 1
    // x + 1；会报错，相当于执行 return 空
}

1.4. 循环控制¶

Rust 有三种循环：loop、while 和 for

fn main() {
    let mut a: [i32; 4] = [0;4];
    let mut i: i32  = 1; let mut count = 0;

    // result 表达式：会返回 loop 过程中的返回值 
    let result = loop {
        if i > 10 {
            break;
        }
        i += i; a[count] = i; count += 1;
    };
    result;   // 执行刚刚的代码块

    // while 循环
    while i < 100 {
        i += i;
    }
    println!("i is {}", i);

    // for 循环遍历 ： 
    for element in a.iter() {
        println!("iter value is: {}", element);
    }

    // 循环遍历 rev: 反转 range
    for number in (1..4).rev() {
        println!("rev  {}!", number);
    }
}