# Rust 语法学习

## 用例 1：猜数游戏

生成一个随机 1-100 的数并让玩家猜测

```rust

// rust默认隐式引入prelude
// 除了prelude以外都要显式引入
use rand::random;

fn main() {
    // 使用常量定义一个偏置量
    // 常量在编译时就已经确定，所以不能通过如CONST XX = XX()来初始化
    // let声明的不可变变量虽然不可变，但是在编译时默认为未知的。
    const BIAS: u8 = 1;

    println!("guess number game");

    // let: 声明变量，默认不可变
    // mut：声明变量可变
    // String::new()，冒号表示这是一个String类的关联函数
    // 关联函数就是类似于静态方法
    let secret_number = random::<u8>() + BIAS;
    println!("secret number is {}", secret_number);

    // mut使得变量可变
    let mut user_guess: u8 = 0;
    let mut user_input = String::new();
    while user_guess != secret_number {
        // 清空之前的输入
        user_input.clear();

        // io::stdin()：标准输入
        // read_line：读取一行
        // &：取地址符号，表示引用，默认不可变
        // &mut：声明可变引用
        std::io::stdin().read_line(&mut user_input).expect("read fail");
        // 将输入的字符串转换为数字
        // user_guess = user_input.trim().parse().expect("parse fail");
        // 使用 match 表达式判断用户输入的是否为数字
        // 比使用if else更简洁
        user_guess = match user_input.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("please input a number");
                continue;
            }
        };

        // 判断用户输入的数字与随机数的大小关系
        // if user_guess > secret_number {
        //     println!("user number is too large");
        // } else if user_guess < secret_number {
        //     println!("user number is too small");
        // } else {
        //     println!("user number is correct");
        //     break;
        // }
        // 使用 match 表达式判断用户输入的数字与随机数的大小关系
        // 比使用if else更简洁
        match user_guess.cmp(&secret_number) {
            std::cmp::Ordering::Greater => println!("user number is too large"),
            std::cmp::Ordering::Less => println!("user number is too small"),
            std::cmp::Ordering::Equal => {
                println!("user number is correct");
                break;
            }

        }
        println!("user number is {}", user_input);
    }


}

```

## 特性： shadow

在同一个作用域内，可以重复声明同名的变量，会覆盖之前的变量

```rust
fn main() {
    let x = 5;
    // 重复声明同名的变量，会覆盖之前的变量
    let x = x + 1;
    let x = x * 2;
    println!("The value of x is: {}", x); // 12
}
```

## 类型

### 基本类型

#### 整数类型

- 整数：i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize
- 整数类型范围：
  - 有符号：-2^n+1 ~ 2^(n-1)-1
  - 无符号：0 ~ 2^n-1
- isize, usize：取决于运行程序的计算机的架构
- 表示
  - hex: 0x12345678
  - oct: 0o12345678
  - bin: 0b1010_1010
  - Byte: b'A'

#### 浮点数类型

- 浮点数：f32, f64, 默认是 f64
- 表示
  - 科学计数法：1.23e3
  - 小数点：1.23

#### 布尔类型

- 布尔类型：bool
- 表示
  - true, false

#### 字符类型

- 字符类型：char
- 表示
  - 'a', 'A', '1', '中'
  - 单引号表示
- 占用 4 字节

### 复合类型

#### 元组类型（Tuple）

- 可以将多个类型的多个值放在一个类型里
- 长度是固定的，一旦声明就无法改变
- 声明例： let tup: (i32, f64, u8) = (500, 6.4, 1);
- 访问例 1： let (x, y, z) = tup;
- 访问例 2： let x = tup.0;

#### 数组类型（Array）

- 可以将多个类型的多个值放在一个类型里
- 长度也是固定的，一旦声明就无法改变
- 想要使用有固定数量的元素时使用数组更有好处
- 声明例： let arr: [i32; 5] = [1, 2, 3, 4, 5];
- 声明例 2： let arr = [3; 5]; // 表示数组有 5 个 3
- 访问例： let x = arr[0];
- 没有 Vector 灵活

## 函数

函数名小写，单词间使用下划线进行分割

例子：

```rust

fn f(x: i32, y: i32) -> i32 {
    // 这里不加分号，因为是表达式，会返回值
    // 函数默认使用最后一个表达式作为返回值
    x + y
}

fn f2(x: i32, y: i32) {
    let z = {
        x + y + 1
    };
    z
}

```

## 控制流

### if 表达式

- 如果使用多于一个的 if-else，最好使用 match 对代码进行重构
- if 表达式是一个表达式，所以可以将其赋值给一个变量

```rust
fn main() {
    let x = 5;
    if x < 5 {
        println!("x is less than 5");
    } else if x > 5 {
        println!("x is greater than 5");
    } else {
        println!("x is 5");
    }
    // 使用 match 对代码进行重构
    let x = 5;
    match x.cmp(&5) {
        std::cmp::Ordering::Less => println!("x is less than 5"),
        std::cmp::Ordering::Greater => println!("x is greater than 5"),
        std::cmp::Ordering::Equal => println!("x is 5"),
    }

    let y = if x < 5 {
        1
    } else {
        2
    };
}
```

### 循环

```rust
fn main() {
    let mut x = 0;
    while x < 5 {
        println!("x is {}", x);
        x += 1;
    }
    x = 0;
    // 使用 .. 表示一个范围，不包含右边的数
    // 实际的类型是std::ops::Range<{integer}>
    // 可以通过(1..5).rev() 表示一个倒序的范围
    for x in 0..5 {
        println!("x is {}", x);
    }
    const A: [i32; 5] = [1, 2, 3, 4, 5];
    // iter 方法返回一个迭代器，迭代器是一个可以遍历集合的对象
    for x in A.iter() {
        println!("x is {}", x);
    }
    x = 0;
    loop {
        println!("x is {}", x);
        x += 1;
        if x > 5 {
            break;
        }
    }
    // loop 表达式是一个表达式，所以可以将其赋值给一个变量
    let result = loop {
        if x > 5 {
            break x * 2;
        }
        x += 1;
    };
}
```

## 所有权

- 内存管理分为两个部分：栈和堆
- 所有权是 Rust 最独特的特性之一
- 在 Rust 中，每个值都有一个变量，这个变量被称为所有者
- 每个值在任意时刻有且只有一个所有者
- 当所有者离开 scope（作用域），这个值将被删除

### 作用域

例：

```rust
fn main() {
    {
        let x = 5;
        println!("x is {}", x);
    }
    // x 已经离开作用域
}
```

### copy trait

- 赋值要么发生移动，要么发生复制
- Rust 中的基本类型都实现了 copy trait
- 如果一个类型实现了 copy trait，则旧的变量在赋值后仍然可以使用
- 否则就像下面的 String 一样，赋值以后旧的变量会失效
- 内容全为已实现 copy 的 tuple 也是可 copy 的

### 所有权和函数

- rust 函数传参与赋值操作类似
- 所以可能发生移动，使得一些变量失效
- 返回值时所有权也很发生移动或复制
- 一个变量的所有权总是遵循同样的模式
  - 把一个值赋给其他变量的时候会发生移动
  - 当一个包含 heap 数据的变量离开作用域时。这个值就会被 drop 函数删除
  - 除非其所有权发生了转移

例：

```rust
fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // 这里会报错，因为s已经失效了
    // println!("{}", s);
    let x = 5;
    makes_copy(x);
    // 这里不会报错，因为x仍然可以使用
    println!("{}", x);

    let s1 = generates_string();

    let s2 = String::from("hello");

    let s3 = takes_and_gives_back(s2);
    println!("{}", s1);
    // 这里会报错，因为s2已经失效了
    println!("{}", s2);
    println!("{}", s3);
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string
}

fn generates_string() -> String {
    let s = String::from("hello");
    s
}

fn makes_copy(x: i32) {
    println!("{}", x);
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}
```

## 引用和借用

- 引用是一个指向某个值的指针
- 引用不会获取到值的所有权
- 引用的变量默认是不可变的
- 引用的变量可以通过 mut 关键字声明为可变的
- 特定的作用域内，一个变量只能有一个可变引用
- 不可同时拥有可变引用与不可变引用
- 不可变引用可以有多个
- rust 在编译时会防止悬空指针的出现
  例

```rust
fn main() {
    let s1 = String::from("hello");
    // 这里的s2是一个引用，指向s1
    let len = calculate_length(&s1);
    change_string(&mut s1);
    println!("{}", s2);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change_string(s: &mut String) {
    s.push_str(", world");
}
```

## slice 切片

- slice 是一个引用，指向一个字符串/数组的一部分
- 定义函数时使用字符串切片（&str）来代替字符串引用会使我们的 api 更加通用且不会损失任何功能

```rust
fn main() {
    let s = String::from("hello world");
    let wordIndex = first_word(&s);
    let hello = &s[0..5];
    let world = &s[6..11];
    // 这里会报错，因为clear会导致可变，但是 s已被不可变引用
    s.clear();
    let a: [u8; 5] = [1, 2, 3, 4, 5];
    let slice = &a[0..2];
}

fn first_word(s: &str) -> usize {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[i..];
        }
    }
    &s[..]
}
```

## String

- 相比于使用双引号创建的字符串，使用 String 类型可以动态地分配内存
- String 是一个可变的字符串类型
- String 是一个堆上的字符串，而不是栈上的字符串
- 底层实现上：
  - String 是一个结构体，包含一个指向堆上的字符串的指针和一个长度，一个容量
  - 结构体储存在栈上
  - 真实的字符串储存在堆上

```rust
fn main() {
    // 在heap上分配内存了
    let mut s = String::from("hello");
    // 和js类似，s1和s实际上是同一个字符串
    // 但是因为一些所有权的问题，所以在s1生效以后，s就失效了
    let s1 = s;
    // 克隆消耗资源，但是原来的不会失效了
    let s2 = s1.clone();
    // 这样会报错，因为s已经失效了
    s.push_str(", world");
    s1.push_str(", world");
    println!("s is {}", s1);
}
```

## struct 结构体

- 结构体是一个自定义的类型
- 一旦结构体是可变的，那么结构体的所有字段就是可变的
- 只要 struct 是有效的，则里面的引用也都是有效的

```rust
struct User {
    name: String,
    age: u8,
    id: u32,
}

// tuple struct 元组结构体
struct Color(i32, i32, i32)

// 这样可以将结构体打印出来
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// impl关键字用于为结构体实现接口或者关联函数或者方法
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }

    // 关联函数，不需要实例化就可以调用，通常用于创建结构体
    // 类似于静态方法
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let id: u32 = 1;
    let user = User {
        name: String::from("hello"),
        age: 18,
        id, // 如果字段名和变量名相同，可以省略变量名
    };
    let user2 = User {
        name: String::from("world"),
        id: 2,
        ..user //struct更新语法
    };
    println!("user is {}", user.name);

    let color = Color(255, 0, 0);
    let rect = Rectangle {
        width: 10,
        height: 20,
    };
    let rect2 = Rectangle {
        width: 5,
        height: 10,
    };
    println!("rect is {:#?}", rect);
    println!("rect area is {}", rect.area());
    println!("rect can hold rect2? {}", rect.can_hold(&rect2));
}
```

## 枚举

- 枚举是一个自定义的类型
  例

```rust
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6((String::from("::1")));
}
```

## Option

- Option 是一个枚举类型，表示一个值可能不存在
- 包含在预导入库中，可以直接使用
```rust
enum Option<T> {
    Some(T),
    None,
}
```
- 如 let x: Option<i32> = None;
- 通过unwrap方法可以获取到Some的值

## match
- match可以提供一种匹配

```rust
enum UsState {
    Alabama,
    Alaska,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn main() {
    let coin = Coin::Quarter(UsState::Alaska);
    println!("value_in_cents is {}", value_in_cents(coin));
}
```