Hello Rust！

因为最近看到了很多关于 Rust 的项目，然后又了解到了 webassembly 可以使用 Rust 等语言编译为 wasm 供 javascript 使用，所以准备入门了解下。本文可以看作是我的读书笔记。

1.学习途径

2. 安装 rust

Rust 的源文件为 .rs 文件

• 通过 homebrew 进行安装： brew install rust

• 查看 Rust 版本：rustc -V

• 编译 .rs 文件：rustc path

3.Hello World

fn main() {
	println!("Hello world!");
}

4.Hello Cargo

绝大多数 Rust 项目使用 Cargo，官方安装包的一般自带了 Cargo

• 查看 cargo 版本：cargo —version

• 使用 cargo 创建项目：cargo new hello_cargo

• 使用 cargo 构建项目：cargo build

• 一步构建并运行项目：cargo run

• 在不生成二进制文件的情况下构建项目来检查错误：cargo check

5.猜数字游戏

• let 在 Rust 中定义变量的关键字，如果后续值需要可变则 使用 let mut 进行定义。

• match 类似于 if，但需要为所有可能的结果设定处理程序。

• 在 Cargo.toml 中引入外部包
在 [dependencies] 后使用 crateName = “version” 的格式引入，如

rand = "0.8.3"

然后重新构建项目 cargo build，或更新 crate cargo update

6.数据类型

let guess: u32 = "42".parse().expect("Not a number!");

标量类型

• 整型是一个没有小数部分的数字。在 Rust 中存在有符号（i）和无符号（u）两大类整型，有符号和无符号代表数字能否为负值。
有符号
• i8
• i16
• i32
• i64
• i128
• isize
无符号
• u8
• u16
• u32
• u64
• u128
• usize
字面量
• Decimal (十进制)
• Hex (十六进制)
• Octal (八进制)
• Binary (二进制)
• Byte (单字节字符 仅限于u8)

• 浮点型，Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32速度几乎一样，不过精度更高。所有的浮点型都是有符号的。

• 布尔型使用 bool 表示，有两个可能的值 true 或 false 。

• 字符类型使用 char 表示，是语言中最原生的字母类型。

• 元组类型一旦声明，长度和成员位置不会再改变，使用包含在圆括号中的逗号分隔的值列表来创建一个元组，不同位置的成员类型不必相同。
元组是一个单独的复合元素。为了从元组中获取单个值，可以使用模式匹配（pattern matching）来解构（destructure）元组值

fn main() {
    // 定义一个元组
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    // 解构元组
    let (x, y, z) = tup; // x: 500, y: 6.4, z: 1
}

除了使用解构外，还可以使用点号（.）后跟索引值来直接访问。

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

• 复合类型可以将多个值组合成一个类型，Rust 中有元组和数组。
• 数组类型中的每个元素类型必须相同，且 Rust 中的数组长度是固定的。可以这样来定义数组的类型：

let a: [i32;5] = [1,2,3,4,5];

可以通过在方括号中指定初始值和个数来创建一个每个元素都相同的数组：

let a = [3;5];
// 和 let a = [3,3,3,3,3] 的作用相同

可通过索引来访问数组元素，但是当索引超出数组的长度时，将会导致运行时错误。

let a = [1,2,3,4,5];
let first = a[0]; // 1
let second = a[1]; // 2

7.函数

fn sum(a:i32,b:i32)->i32 {
    a + b
}

8. 注释

9.控制流

if 表达式

let number = 3;

if number < 0 {
    // ... do something
} else if number > 10 {
    // ... do something
} else {
    // ... do something
}

let number = 4;

let number = if number < 3 { 3 } else { number };

循环

• loop 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。
• break 关键字可以停止循环并返回值。

fn main () {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
   println!("The result is {result}");
}

• continue 关键字告诉程序跳过这个循环迭代中的任何剩余代码，并转到下一个迭代。
• 循环标签用于在嵌套循环时和 break 或 continue 一起使用，用于指定要停止或退出的循环。

fn main() {
    'loop_label' loop {
       // ... do something
   };
}

• while 条件循环，当条件为真，执行循环。当条件不再为真，调用 break 停止循环。

fn main() {
   let mut number = 10;

   while number > 0 {
       number -= 1;
   }
}

• for 循环可以用来对集合的每一个元素执行一些代码。

fn main() {
    let a = [1,2,3,4,5];
    for item in a {
        println!("the value is: {item}")
    }
}

10.所有权

所有权规则

1. Rust 中的每一个值都有一个 所有者（owner）。

2. 值在任一时刻有且只有一个所有者。

3. 当所有者（变量）离开作用域，这个值将被丢弃。

变量作用域

   {                      // s 在这里无效, 它尚未声明
        let s = "hello";   // 从此处起，s 是有效的

        // 使用 s
   }                      // 此作用域已结束，s 不再有效

移动

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}, world!", s1); // 报错
}

克隆

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {}, s2 = {}", s1, s2);
}

拷贝

• 所有整数类型，比如 u32。

• 布尔类型，bool，它的值是 true 和 false。

• 所有浮点数类型，比如 f64。

• 字符类型，char。

• 元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。

所有权和函数

返回值和作用域

fn main() {
    let a = String::from("test");
    let b =String::from("test2");

    let (result,a) = get_length(a);
    let (result2,c) = get_length(b);


    println!("result is {},a is {}",result,a);
    println!("result2 is {},b is {}",result2, b); // 报错，b已经无效
}

fn get_length (s:String) -> (String,usize) {
    let length = s.len();
    (s,length)
}

11.引用和借用

fn main() {
    let a = String::from("test");

    let result = get_length(&a);

    println!("result is {},a is {}",result,a);
}

fn get_length (s:&String) -> (String,usize) {
    let length = s.len();
    length
}

可变引用

垂悬引用

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // dangle 返回一个字符串的引用

    let s = String::from("hello"); // s 是一个新字符串

    &s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
  // 危险！

12.Slice 类型

字符串 Slice

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

fn main() {
    let s = String::from("hello");
    let slice = &s[..2];
    let slice = &s[1..];
    let slice = &s[..];
}

数组 Slice

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

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

13.结构体

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    user1.email = String::from("[email protected]");
}

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("[email protected]"),
        String::from("someusername123"),
    );
}

结构体更新语法

fn main() {

    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("[email protected]"),
        ..user1 // 除 email 字段外，其他字段都和 user1 保持一致
    };
}

元组结构体

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

没有字段的类单元结构体

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

dbg! 方法

14. 结构体方法