Rust 基础

命令

# 编译
rustc 文件.rs

rustup update 更新更新依赖

rustc 文件.rs 生成二进制可执行文件

cargo new 项目名 创建项目

cargo buile 构建项目生成二进制可执行文件

cargo buile --release 生成环境

cargo check 检查项目是否可以编译

cargo doc --open 说明文档

Some 还没有搞明白

基本

# 入口
fn main (){
    println!("Holle Word!")
}

# 定义函数
fn 函数名 () {
    //
}

变量定义

let 变量名 = 值;
let 变量名:数据类型 = 值;

// 可变变量 
let mut 变量名 = 值;

// 常量 字母全部大写 块级作用域 不可变 类型必须声明
const 变量名:数据类型 = 值;

// 静态变量 字母全部大写 生命周期是整个程序的生命周期 
static 变量名 = 值;

命名空间

命名空间作用域内声明的变量与获取的变量是同一个变量, 命名空间结束后命名空间内的变量自动销毁

{
    // 代码块
}

关联函数

关联函数经常被用作返回一个结构体新实例的构造函数

impl 结构体名 {
    fn 关联函数名(size: u32) -> 结构体名 {
        结构体名 {
            width: size,
            height: size,
        }
    }
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

调用

// 返回一个对象
let 名称 = 结构体名::关联函数名(参数)

宏

assert_eq!(result, 100); 判断两个表达式的值是否相同如果不相同将停止执行

语法

输出

# 输出
println!("Holle Word!");
println!("Holle Word!{}", 变量名);
println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
println!("{subject} {verb} {object}",object="the lazy dog",subject="the quick brown fox",verb="jumps over");

println!("{:?}", peter);
println!("{:#?}", peter);

for

遍历

for i in 迭代数据{
    // 代码
}

if

if number == 0 {
    // 代码块
} else if number == 0 {
    // 代码块
} else {
    // 代码块
}

loop

loop {
    if 条件 {
        break;
    }
}

'名称: loop {
    if 条件 {
        break '名称;
    }
}

break 结束循环

break 表达式 结束循环并返回值

continue 结束本次循环进入下次循环

while

while 条件 {
    // 代码块
}

match

控制流

match 值 {
    模式1 => 表达式1,
    模式2 => 表达式2,
    _ => 默认表达式, // 可选的
}

match number {
    1 => println!("One"),
    2 => println!("Two"),
    3 => println!("Three"),
    _ => println!("Other number"),  // 不绑定值
    other => other,  // 通配分支  绑定值
}

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

枚举与match

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

match 枚举对象 {
    枚举结构体::枚举字段 => 1,
    Coin::Nickel => 5,
    Coin::Dime => 10,
    Coin::Quarter(state) => {
        println!("State quarter from {:?}!", state);
        25
    }
}

函数

返回值是最后一个表达式的值

fn add(x: i32, y: i32) -> i32{
    x + y
}

Result

确保处理确保异常

enum Result<T, E> {
    Ok(T),
    Err(E),
}

T 代表成功, E 代表失败

错误处理

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

let f = match f {
    Ok(file) => file,
    Err(error) => {
        panic!("Problem opening the file: {:?}", error)
    },
};

panic!

不可恢复错误

打印错误信息到标准错误信息, 程序出现错误时会自动调用panic!

// 手动触发panic!
panic!("错误信息")

泛型

struct Point<T> {
    x: T,
    y: T,
}

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

trait

// 定义
pub trait Summary {
    fn summarize(&self) -> String;

    // 不需要被其他 impl 定义 可以直接使用
    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

// 定义
pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

// 使用了trait的Summary后必须实现里面的函数
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}