Rust常用语法—快速总结

简介

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语句用于模式匹配。

let x = 10;
if x > 0 {
    println!("x is positive");
} else if x == 0 {
    println!("x is zero");
} else {
    println!("x is negative");
}

let mut i = 0;
loop {
    println!("i = {}", i);
    i += 1;
    if i == 5 {
        break;
    }
}

let mut j = 0;
while j < 5 {
    println!("j = {}", j);
    j += 1;
}

let arr = [1, 2, 3, 4, 5];
for element in arr.iter() {
    println!("element = {}", element);
}

let x = 5;
match x {
    1 => println!("x is one"),
    2 | 3 => println!("x is two or three"),
    4...6 => println!("x is four, five, or six"),
    _ => println!("x is something else"),
}

函数和闭包

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 "]
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);

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