[Rust] 基础语法

目录

• 参考
• 01 变量与常量
• 02 数据类型
  • 2.1 基本类型
  • 2.2 复合类型
• 03 函数
• 04 控制流
  • 4.1 if表达式
  • 4.2 循环
• 05 所有权系统
• 06 引用和借用
• 07 结构体
• 08 枚举与模式匹配
• 09 模块系统
• 10 错误处理
• 11 常用集合
  • 11.1 Vector
  • 11.2 String
  • HashMap

参考

从零蛋开始学 Rust
[Bilibili]一小时Rust核心：面向C++的忙碌人士

01 变量与常量

let x = 5;          // 不可变变量
let mut y = 10;     // 可变变量 (使用 mut 关键字)
const MAX_POINTS: u32 = 100_000; // 常量

02 数据类型

2.1 基本类型

let a: i32 = -42;       // 有符号整数
let b: u32 = 42;        // 无符号整数
let c: f64 = 3.14;      // 浮点数
let d: bool = true;     // 布尔值
let e: char = 'z';      // 字符

2.2 复合类型

// 元组
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;    // 解构

// 数组
let arr = [1, 2, 3, 4, 5];
let first = arr[0];     // 访问元素

03 函数

// 函数定义
fn add(a: i32, b: i32) -> i32 {
    a + b               // 注意没有分号，这是表达式返回值
}

// 调用函数
let sum = add(2, 3);

04 控制流

4.1 if表达式

let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else {
    println!("number is not divisible by 4 or 3");
}

// if 是表达式，可以赋值
let condition = true;
let num = if condition { 5 } else { 6 };

4.2 循环

// loop
let mut count = 0;
loop {
    count += 1;
    if count == 10 {
        break;
    }
}

// while
while count < 20 {
    count += 1;
}

// for
let arr = [10, 20, 30, 40, 50];
for element in arr.iter() {
    println!("the value is: {}", element);
}

// 范围循环
for number in 1..4 {    // 1, 2, 3
    println!("{}", number);
}

05 所有权系统

Rust 的核心特性：

• 每个值都有一个所有者
• 一次只能有一个所有者
• 当所有者离开作用域，值将被丢弃

let s1 = String::from("hello"); // s1 拥有字符串
let s2 = s1;                    // s1 的所有权移动到 s2
// println!("{}", s1);           // 错误！s1 不再有效

let s3 = s2.clone();            // 深度拷贝
println!("s2 = {}, s3 = {}", s2, s3); // 都有效

06 引用和借用

fn calculate_length(s: &String) -> usize { // 借用引用
    s.len()
}

let s = String::from("hello");
let len = calculate_length(&s); // 传递引用
println!("'{}' 的长度是 {}", s, len);

07 结构体

// 定义结构体
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

// 创建实例
let user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

// 访问字段
println!("用户名: {}", user1.username);

08 枚举与模式匹配

// 定义枚举
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

// 使用枚举
let home = IpAddr::V4(127, 0, 0, 1);

// 模式匹配
match home {
    IpAddr::V4(a, b, c, d) => println!("IPv4: {}.{}.{}.{}", a, b, c, d),
    IpAddr::V6(s) => println!("IPv6: {}", s),
}

// Option 枚举 (Rust 没有 null)
let some_number = Some(5);
let absent_number: Option<i32> = None;

09 模块系统

// 声明模块 (通常在 lib.rs 或 main.rs)
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// 使用模块
use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

10 错误处理

// 可恢复错误 Result<T, E>
use std::fs::File;

let f = File::open("hello.txt");

let f = match f {
    Ok(file) => file,
    Err(error) => panic!("打开文件出错: {:?}", error),
};

// 使用 ? 运算符简化错误处理
fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

11 常用集合

11.1 Vector

let v: Vec<i32> = Vec::new();
let v = vec![1, 2, 3]; // 宏创建

let third = &v[2];     // 索引访问
let third = v.get(2);  // 方法访问返回 Option

11.2 String

let mut s = String::from("foo");
s.push_str("bar");
let slice = &s[0..3];  // 字符串切片

HashMap

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);