Rust常用语法—快速总结

古城微笑少年丶 2023-10-08 21:09 35阅读 0赞

### 简介 ###

Rust是一种系统级编程语言，它具有强类型、静态类型检查和高性能等特点。Rust的语法设计是非常严谨和安全的，同时也是非常灵活和高效的。下面是Rust中一些常用的语法：

### 变量和数据类型 ###

在Rust中，变量必须先声明，然后才能使用。声明变量时需要指定数据类型。Rust变量默认是不可变的，如果需要可变的变量，则需要使用mut关键字进行声明。例如：

let x = 5; // x为整型，不可变
    let mut y = 5; // y为整型，可变

**说明**：上面的代码声明了一个整型变量x，并将其初始化为10。i32表示这个变量的数据类型为32位带符号整型。Rust中还有其他的整型类型，例如u8、u16、u32、u64、i8、i16、i32、i64等。

除了整型，Rust还有其他的基本数据类型，例如bool、char、f32、f64等。  
Rust中还有一种特殊的数据类型()，它表示空类型，通常用于函数的返回值类型。  
Rust中还有复合类型，元组和数组，元组中元素的数据类型可以不同，而数组中元素的数据类型必须一致。

let a = true; // a为布尔型
    let b: char = 'a'; // b为字符型
    let pi: f64 = 3.14159; //pi为64位浮点型
    let nothing: () = (); //空类型
    let c = (1, "hello"); // c为元组类型
    let arr = [1, 2, 3, 4, 5]; //arr为数组类型

### 控制流语句 ###

Rust中常用的控制流语句包括if、loop、while、for和match。  
其中，if语句用于条件判断，loop语句用于无限循环，while和for语句用于循环，match语句用于模式匹配。

### 函数和闭包 ###

**Rust中的函数**：  
1、和其他语言中的函数类似，但是需要显式地指定参数的类型和返回值的类型。  
2、使用fn关键字进行声明，函数的返回值类型可以使用->进行指定。  
3、函数名采用蛇形命名法（snake\_case）。

//函数
    fn add(x: i32, y: i32) -> i32 {
        
        x + y
    }
    
    fn main() {
        
        let result = add(1, 2);
        println!("{}", result); // 输出3
    }

**Rust中的闭包**  
1、类似于其他语言中的匿名函数，它可以捕获周围的环境并在需要时执行。  
2、使用||操作符进行定义，可以捕获函数外部的变量，类似于匿名函数。  
3、闭包可以存储在变量中，也可以作为参数传递给其他函数。

// 闭包
    fn main() {
        
        let add = |x: i32, y: i32| x + y;
        let result = add(1, 2);
        println!("{}", result); // 输出3
    }

### 模块和包 ###

Rust中的代码可以组织成模块和包，以便于管理和重用。每个Rust文件都是一个模块，可以包含多个函数、结构体、枚举等。

Rust中的包是一个或多个相关模块的集合，通常包含一个名为src的目录，其中包含所有的源代码文件，还包含一个名为Cargo.toml的文件，用于描述包的元数据和依赖关系。

// 模块的定义
    mod my_module {
        
        pub fn hello() {
        
            println!("Hello from my_module!");
        }
    }
    
    // 使用模块
    use my_module::hello;
    
    fn main() {
        
        hello();
    }

# Cargo.toml文件
    [package]
    name = "my_package"
    version = "0.1.0"
    authors = ["Your Name <your.email@example.com>"]
    edition = "2018"
    
    [dependencies]

### 结构体和枚举 ###

Rust中的结构体类似于其他语言中的类，用于组织数据。Rust中的枚举用于定义一组相关的命名值，可以与结构体一起使用。  
**注**：因为Rust中的方法总是被定义在某个结构体（或者枚举类型、后面提到的Trait对象）的上下文中，并且它们第一个参数永远是`self`，用于指代调用该方法的结构体实例

// 定义结构体
    struct Point {
        
        x: i32,
        y: i32,
    }
    
    impl Point {
        
        fn new(x: i32, y: i32) -> Point {
        
            Point {
         x, y }
        }
    
        fn translate(&mut self, dx: i32, dy: i32) {
        
            self.x += dx;
            self.y += dy;
        }
    }
    
    // 使用结构体
    let mut p = Point::new(0, 0);
    p.translate(10, 20);
    println!("p = ({}, {})", p.x, p.y);
    
    // 定义枚举
    enum Color {
        
        Red,
        Green,
        Blue,
    }
    
    impl Color {
        
        fn to_hex(&self) -> u32 {
        
            match self {
        
                Color::Red => 0xff0000,
                Color::Green => 0x00ff00,
                Color::Blue => 0x0000ff,
            }
        }
    }
    
    // 使用枚举
    let c = Color::Red;
    println!("c = {:x}", c.to_hex());

### Trait和泛型 ###

Rust中的Trait类似于其他语言中的接口，用于定义方法的集合。  
Rust中的泛型用于编写可重用的代码，使得代码可以处理多种不同类型的数据。

// 定义Trait
    trait Drawable {
        
        fn draw(&self);
    }
    
    // 实现Trait
    struct Circle {
        
        x: f32,
        y: f32,
        r: f32,
    }
    
    impl Drawable for Circle {
        
        fn draw(&self) {
        
            println!("Drawing circle at ({}, {}) with radius {}", self.x, self.y, self.r);
        }
    }
    
    // 定义泛型函数
    fn max<T: std::cmp::PartialOrd>(a: T, b: T) -> T {
        
        if a > b {
        
            a
        } else {
        
            b
        }
    }
    
    // 使用泛型函数
    let x = 1;
    let y = 2;
    println!("max = {}", max(x, y));
    
    let s1 = "hello";
    let s2 = "world";
    println!("max = {}", max(s1, s2));

### 错误处理 ###

Rust提供了一套强大的错误处理机制，用于处理可能发生的错误。错误可以通过Result枚举类型来表示，其中包含Ok和Err两个变体。

// 定义错误类型
    #[derive(Debug)]
    enum MyError {
        
        DivisionByZero,
        Overflow,
        InvalidInput(String),
    }
    
    // 定义函数
    fn divide(x: i32, y: i32) -> Result<i32, MyError> {
        
        if y == 0 {
        
            Err(MyError::DivisionByZero)
        } else if x == i32::MAX && y == 1 {
        
            Err(MyError::Overflow)
        } else {
        
            Ok(x / y)
        }
    }
    
    // 使用函数
    match divide(10, 0) {
        
        Ok(result) => println!("Result = {}", result),
        Err(MyError::DivisionByZero) => println!("Error: Division by zero"),
        Err(MyError::Overflow) => println!("Error: Arithmetic overflow"),
        Err(MyError::InvalidInput(s)) => println!("Error: Invalid input: {}", s),
    }

### 并发编程 ###

Rust提供了多种方式来实现并发编程，包括线程、通道和锁等机制。

// 创建线程
    let handle = std::thread::spawn(|| {
        
        println!("Hello from thread!");
    });
    
    // 等待线程结束
    handle.join().unwrap();
    
    // 创建通道
    let (tx, rx) = std::sync::mpsc::channel();
    
    // 发送消息
    tx.send("Hello from channel").unwrap();
    
    // 接收消息
    let message = rx.recv().unwrap();
    
    // 创建锁
    let mutex = std::sync::Mutex::new(0);
    
    // 获取锁
    let mut count = mutex.lock().unwrap();
    
    // 修改共享数据
    *count += 1;
    
    // 释放锁
    drop(count);

> 结束语：不要为了别人的期望而活，你的生命是你自己的，你应该按照自己的方式生活。