Rust 基础语法

概述

本章深入学习 Rust 的基础语法，包括变量、常量、作用域、命名规范等核心概念。掌握这些基础知识是编写高质量 Rust 代码的前提。

📝 变量声明

不可变变量（默认）

fn immutable_variables() {
    // 默认不可变
    let x = 5;
    println!("x 的值是: {}", x);
    
    // x = 6; // 编译错误！不能修改不可变变量
    
    // 类型注解
    let y: i32 = 10;
    let z: f64 = 3.14;
    println!("y: {}, z: {}", y, z);
    
    // 延迟初始化
    let a;
    a = 42; // 必须在使用前初始化
    println!("a: {}", a);
    
    // 未使用的变量（警告抑制）
    let _unused = "这个变量不会被使用";
}

可变变量

fn mutable_variables() {
    // 可变变量
    let mut x = 5;
    println!("x 的初始值: {}", x);
    
    x = 6; // 可以修改
    println!("x 的新值: {}", x);
    
    // 类型不能改变
    let mut number = 10;
    number = 20; // OK
    // number = "hello"; // 编译错误！类型不匹配
    
    // 可变性传播
    let mut vec = vec![1, 2, 3];
    vec.push(4); // 可以修改内容
    println!("向量: {:?}", vec);
}

变量遮蔽（Shadowing）

fn variable_shadowing() {
    let x = 5;
    
    // 遮蔽之前的 x
    let x = x + 1;
    println!("遮蔽后 x: {}", x); // 6
    
    // 在新作用域中遮蔽
    {
        let x = x * 2;
        println!("内部作用域 x: {}", x); // 12
    }
    
    println!("外部作用域 x: {}", x); // 6
    
    // 遮蔽可以改变类型
    let spaces = "   ";
    let spaces = spaces.len(); // 现在是数字类型
    println!("空格数量: {}", spaces);
    
    // 对比：可变变量不能改变类型
    let mut guess = "42";
    // guess = guess.len(); // 编译错误！
}

🏷️ 常量

常量定义

// 全局常量
const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159265359;
const APP_NAME: &str = "我的应用";

fn constants_example() {
    // 函数内常量
    const LOCAL_CONST: i32 = 42;
    
    println!("最大分数: {}", MAX_POINTS);
    println!("圆周率: {}", PI);
    println!("应用名称: {}", APP_NAME);
    println!("本地常量: {}", LOCAL_CONST);
    
    // 常量表达式
    const SECONDS_IN_MINUTE: u32 = 60;
    const SECONDS_IN_HOUR: u32 = SECONDS_IN_MINUTE * 60;
    const SECONDS_IN_DAY: u32 = SECONDS_IN_HOUR * 24;
    
    println!("一天的秒数: {}", SECONDS_IN_DAY);
}

常量 vs 不可变变量

fn const_vs_immutable() {
    // 常量：编译时必须已知值
    const COMPILE_TIME: i32 = 42;
    
    // 不可变变量：运行时确定值
    let runtime_value = get_runtime_value();
    
    println!("编译时常量: {}", COMPILE_TIME);
    println!("运行时值: {}", runtime_value);
}

fn get_runtime_value() -> i32 {
    use std::time::{SystemTime, UNIX_EPOCH};
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    now.as_secs() as i32 % 100
}

🎯 作用域和生命周期

作用域基础

fn scope_basics() {
    let outer = "外部变量";
    
    { // 新作用域开始
        let inner = "内部变量";
        println!("内部可以访问: {}, {}", outer, inner);
        
        // 遮蔽外部变量
        let outer = "遮蔽的外部变量";
        println!("遮蔽后: {}", outer);
    } // inner 在这里被销毁
    
    println!("外部作用域: {}", outer); // 恢复原来的值
    // println!("{}", inner); // 编译错误！inner 不在作用域内
}

所有权作用域

fn ownership_scope() {
    {
        let s = String::from("hello"); // s 进入作用域
        println!("s: {}", s);
    } // s 离开作用域，内存被释放
    
    // println!("{}", s); // 编译错误！s 不在作用域内
    
    let s1 = String::from("world");
    let s2 = s1; // s1 的所有权移动到 s2
    
    // println!("{}", s1); // 编译错误！s1 已失效
    println!("s2: {}", s2);
}

📏 标识符和命名规范

命名规则

// 有效的标识符
fn naming_conventions() {
    // 蛇形命名法（推荐）
    let user_name = "Alice";
    let max_count = 100;
    let is_valid = true;
    
    // Unicode 支持
    let 变量名 = "中文变量名";
    let переменная = "俄文变量名";
    
    // 下划线开头（通常用于未使用的变量）
    let _unused_var = 42;
    let __internal_var = "内部变量";
    
    // 数字（不能以数字开头）
    let var1 = "变量1";
    let var_2 = "变量2";
    // let 1var = "错误"; // 编译错误！
    
    println!("{}, {}, {}", user_name, max_count, is_valid);
    println!("{}, {}", 变量名, переменная);
}

Rust 命名规范

// 常量：大写字母 + 下划线
const MAX_SIZE: usize = 1024;
const DEFAULT_TIMEOUT: u64 = 30;

// 结构体、枚举、trait：帕斯卡命名法
struct UserAccount {
    user_id: u64,
    account_type: AccountType,
}

enum AccountType {
    Basic,
    Premium,
    Enterprise,
}

trait Drawable {
    fn draw(&self);
}

// 函数、变量：蛇形命名法
fn calculate_total_price(base_price: f64, tax_rate: f64) -> f64 {
    base_price * (1.0 + tax_rate)
}

// 模块：蛇形命名法
mod user_management {
    pub fn create_user() {}
    pub fn delete_user() {}
}

// 宏：蛇形命名法
macro_rules! debug_print {
    ($x:expr) => {
        println!("Debug: {:?}", $x);
    };
}

🔤 字面量

数值字面量

fn numeric_literals() {
    // 整数字面量
    let decimal = 98_222;        // 十进制（下划线分隔）
    let hex = 0xff;              // 十六进制
    let octal = 0o77;            // 八进制
    let binary = 0b1111_0000;    // 二进制
    let byte = b'A';             // 字节（u8 类型）
    
    println!("数值字面量: {}, {}, {}, {}, {}", 
             decimal, hex, octal, binary, byte);
    
    // 浮点字面量
    let float1 = 2.0;
    let float2 = 3.14159;
    let scientific = 1e6;       // 科学计数法
    let scientific2 = 2.5e-4;
    
    println!("浮点字面量: {}, {}, {}, {}", 
             float1, float2, scientific, scientific2);
    
    // 类型后缀
    let x = 42u32;      // u32 类型
    let y = 3.14f32;    // f32 类型
    let z = 100_i64;    // i64 类型
    
    println!("类型后缀: {}, {}, {}", x, y, z);
}

字符和字符串字面量

fn string_literals() {
    // 字符字面量
    let c1 = 'a';
    let c2 = '中';
    let c3 = '😀';
    let c4 = '\n';       // 转义字符
    let c5 = '\x41';     // ASCII 码
    let c6 = '\u{1F600}'; // Unicode
    
    println!("字符: {}, {}, {}", c1, c2, c3);
    
    // 字符串字面量
    let s1 = "Hello, World!";
    let s2 = "包含\n换行符";
    let s3 = "包含\"引号\"";
    let s4 = r"原始字符串\n不转义";
    let s5 = r#"可以包含"引号"的原始字符串"#;
    
    println!("字符串: {}", s1);
    println!("换行: {}", s2);
    println!("引号: {}", s3);
    println!("原始: {}", s4);
    println!("原始引号: {}", s5);
    
    // 多行字符串
    let multiline = "这是一个\
                     多行字符串\
                     继续在这里";
    
    let multiline_raw = r"
        这是原始的
        多行字符串
        保持原有格式
    ";
    
    println!("多行: {}", multiline);
    println!("原始多行: {}", multiline_raw);
}

布尔和单元字面量

fn boolean_and_unit() {
    // 布尔字面量
    let t = true;
    let f = false;
    
    println!("布尔值: {}, {}", t, f);
    
    // 单元类型
    let unit = ();
    println!("单元类型: {:?}", unit);
    
    // 单元类型函数
    let result = print_hello();
    println!("函数返回: {:?}", result);
}

fn print_hello() -> () {
    println!("Hello!");
    // 隐式返回 ()
}

🎭 表达式和语句

语句 vs 表达式

fn statements_vs_expressions() {
    // 语句：执行操作但不返回值
    let x = 5; // let 语句
    
    // 表达式：求值并返回结果
    let y = {
        let x = 3;
        x + 1 // 表达式，注意没有分号
    };
    
    println!("y: {}", y); // 4
    
    // 函数调用是表达式
    let result = add_one(5);
    println!("结果: {}", result);
    
    // if 是表达式
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("条件值: {}", number);
    
    // 块是表达式
    let block_result = {
        let a = 1;
        let b = 2;
        a + b // 返回值
    };
    println!("块结果: {}", block_result);
}

fn add_one(x: i32) -> i32 {
    x + 1 // 表达式
}

复杂表达式

fn complex_expressions() {
    // 嵌套表达式
    let result = {
        let base = 10;
        let multiplier = {
            let a = 2;
            let b = 3;
            a * b
        };
        base * multiplier
    };
    println!("嵌套表达式结果: {}", result);
    
    // 条件表达式链
    let number = 6;
    let description = if number % 4 == 0 {
        "能被4整除"
    } else if number % 3 == 0 {
        "能被3整除"  
    } else if number % 2 == 0 {
        "能被2整除"
    } else {
        "奇数"
    };
    println!("{} {}", number, description);
    
    // 匹配表达式
    let coin = Coin::Quarter;
    let value = match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    };
    println!("硬币价值: {}", value);
}

#[derive(Debug)]
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

🏃‍♂️ 控制流语法

条件表达式

fn conditional_syntax() {
    let number = 7;
    
    // 基本 if
    if number < 5 {
        println!("小于5");
    }
    
    // if-else
    if number % 2 == 0 {
        println!("偶数");
    } else {
        println!("奇数");
    }
    
    // if-else if-else
    if number < 0 {
        println!("负数");
    } else if number > 0 {
        println!("正数");
    } else {
        println!("零");
    }
    
    // 复杂条件
    let age = 18;
    let has_license = true;
    let has_car = false;
    
    if age >= 18 && has_license && has_car {
        println!("可以独自开车");
    } else if age >= 18 && has_license {
        println!("可以借车开");
    } else if age >= 16 {
        println!("可以学开车");
    } else {
        println!("太年轻了");
    }
}

循环语法

fn loop_syntax() {
    // 无限循环
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // 返回值
        }
    };
    println!("循环结果: {}", result);
    
    // 带标签的循环
    'outer: loop {
        println!("进入外层循环");
        
        'inner: loop {
            println!("进入内层循环");
            break 'outer; // 跳出外层循环
        }
        
        println!("这行不会执行");
    }
    
    // while 循环
    let mut number = 3;
    while number != 0 {
        println!("倒计时: {}", number);
        number -= 1;
    }
    
    // for 循环
    let a = [10, 20, 30, 40, 50];
    
    // 遍历数组
    for element in a.iter() {
        println!("值: {}", element);
    }
    
    // 遍历范围
    for number in (1..4).rev() {
        println!("倒序: {}", number);
    }
    
    // 带索引遍历
    for (i, value) in a.iter().enumerate() {
        println!("索引 {}: 值 {}", i, value);
    }
}

📝 本章小结

通过本章学习，你应该掌握了：

基础语法

• ✅ 变量声明（可变 vs 不可变）
• ✅ 常量定义和使用
• ✅ 变量遮蔽和作用域
• ✅ Rust 命名规范

字面量和表达式

• ✅ 各种类型的字面量写法
• ✅ 表达式 vs 语句的区别
• ✅ 复杂表达式的构造
• ✅ 条件和循环语法

最佳实践

1. 遵循 Rust 命名规范
2. 合理使用可变性
3. 利用作用域管理生命周期
4. 优先使用表达式而非语句

---

继续学习：下一章 - Rust 数据类型