Rust语法基础 #

// 单行注释：用于简短说明

/*
 * 多行注释：
 * 用于较长的说明
 * 可以跨越多行
 */

/// 这是函数文档注释
/// 
/// # Examples
/// 
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
/// 
/// # Panics
/// 
/// 当参数溢出时会panic
/// 
/// # Errors
/// 
/// 此函数不返回错误
fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// 结构体文档注释
/// 
/// 用于表示一个人的基本信息
struct Person {
    /// 人的姓名
    name: String,
    /// 人的年龄
    age: u32,
}

//! 模块级文档注释
//! 
//! 这个注释描述整个模块或crate
//! 通常放在文件开头

// 合法标识符
let name = "Alice";
let _count = 10;
let user_name = "Bob";
let UserName = "Charlie";  // 类型命名风格
let MAX_SIZE = 100;        // 常量命名风格

// 非法标识符
// let 2fast = true;       // 错误：以数字开头
// let my-var = 10;        // 错误：包含连字符
// let fn = "function";    // 错误：使用关键字

// 变量和函数
let user_count = 100;
fn calculate_total_price(base: f64, tax: f64) -> f64 { ... }

// 类型
struct UserAccount { ... }
enum HttpStatus { ... }

// 常量
const MAX_CONNECTIONS: usize = 100;
static DEFAULT_TIMEOUT: u64 = 30;

// 特征
trait Serializable { ... }

let r#match = "value";
let r#fn = "function";
let r#type = "type";

println!("{}", r#match);

as, break, const, continue, crate, else, enum, extern, false, fn, for, 
if, impl, in, let, loop, match, mod, move, mut, pub, ref, return, 
self, Self, static, struct, super, trait, true, type, unsafe, use, 
where, while, async, await, dyn

abstract, become, box, do, final, macro, override, priv, typeof, 
unsized, virtual, yield

// let - 变量声明
let x = 5;
let mut y = 10;

// const - 常量
const MAX_POINTS: u32 = 100_000;

// fn - 函数
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// struct - 结构体
struct Point {
    x: i32,
    y: i32,
}

// enum - 枚举
enum Option<T> {
    Some(T),
    None,
}

// impl - 实现
impl Point {
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
}

// trait - 特征
trait Display {
    fn fmt(&self) -> String;
}

// match - 模式匹配
match value {
    0 => println!("zero"),
    1 => println!("one"),
    _ => println!("other"),
}

// async/await - 异步
async fn fetch_data() -> String {
    let data = get_data().await;
    data
}

// 推荐
fn calculate(a: i32, b: i32, c: i32) -> i32 {
    let result = a + b * c;
    if result > 100 {
        return 100;
    }
    result
}

// 不推荐
fn calculate(a:i32,b:i32,c:i32)->i32{
    let result=a+b*c;
    if result>100{return 100;}
    result
}

// 推荐
fn main() {
    if condition {
        do_something();
    } else {
        do_other();
    }
}

// 不推荐
fn main() 
{
    if condition 
    {
        do_something();
    }
}

// 短函数可以单行
fn identity(x: i32) -> i32 { x }

// 长函数多行
fn complex_function(
    param1: i32,
    param2: String,
    param3: Vec<i32>,
) -> Result<String, Error> {
    // 函数体
    Ok(String::new())
}

let result = collection
    .iter()
    .filter(|x| x > 0)
    .map(|x| x * 2)
    .collect::<Vec<_>>();

// 多字段时换行
let person = Person {
    name: String::from("Alice"),
    age: 30,
    city: String::from("Beijing"),
};

// 简短时可单行
let point = Point { x: 0, y: 0 };

// 标准库
use std::collections::HashMap;
use std::io::Read;

// 外部库
use serde::{Deserialize, Serialize};
use tokio::net::TcpStream;

// 本地模块
use crate::models::User;
use super::utils;

# 格式化当前项目
cargo fmt

# 格式化特定文件
rustfmt src/main.rs

# 检查格式（不修改）
cargo fmt -- --check

max_width = 100
tab_spaces = 4
edition = "2021"
use_small_heuristics = "Default"

# 运行clippy
cargo clippy

# 自动修复
cargo clippy --fix

// 警告：未使用的变量
fn example() {
    let x = 5;  // 警告：unused variable
}

// 修复：使用下划线前缀
fn example() {
    let _x = 5;  // 正确
}

// 警告：不必要的克隆
fn example() {
    let s = String::from("hello");
    let len = s.clone().len();  // 警告：unnecessary clone
}

// 修复
fn example() {
    let s = String::from("hello");
    let len = s.len();  // 正确
}

let x = 5;  // 语句
println!("{}", x);  // 语句

5 + 5  // 表达式，返回10

// 块表达式
let y = {
    let x = 3;
    x + 1  // 表达式，返回4
};

fn main() {
    // 语句
    let x = 5;
    
    // 块表达式
    let y = {
        let a = 1;
        let b = 2;
        a + b  // 无分号，表达式，返回值
    };
    
    println!("y = {}", y);  // y = 3
    
    // 如果加分号，变成语句
    let z = {
        let a = 1;
        let b = 2;
        a + b;  // 有分号，语句，返回 ()
    };
    
    println!("z = {:?}", z);  // z = ()
}