基础语法：变量、类型与模式匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

fn main() {
    // 不可变变量（默认）
    let x = 5;
    // x = 6;  // 编译错误！cannot assign twice to immutable variable

    // 可变变量
    let mut y = 5;
    y = 6;  // OK

    // 编译期常量
    const PI: f64 = 3.14159;

    // 变量遮蔽（Shadowing）
    let x = x + 1;  // 创建新绑定，覆盖旧值
    let x = "hello";  // 甚至可以改变类型
}

1
2
3
4
5
6
7
8

// 元组示例
let tuple: (i32, f64, bool) = (1, 3.14, true);
let (x, y, z) = tuple;  // 解构
let first = tuple.0;     // 通过索引访问

// 数组示例
let arr: [i32; 5] = [1, 2, 3, 4, 5];
let first = arr[0];

1
2
3

fn max(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

1
2
3
4
5
6

// 条件必须是 bool 类型
let number = 6;
// if number {  // 编译错误！expected `bool`, found integer
if number != 0 {
    println!("number is non-zero");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

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

// 范围匹配
fn classify(n: i32) -> &'static str {
    match n {
        0 => "零",
        1..=9 => "个位数",
        10..=99 => "两位数",
        _ => "其他",
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() {
    // loop —— 无限循环，必须用 break 跳出
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 10 {
            break count * 2;  // break 可以返回值
        }
    };

    // while —— 条件循环
    let mut i = 0;
    while i < 10 {
        println!("{}", i);
        i += 1;
    }

    // for —— 迭代器循环
    let a = [10, 20, 30, 40, 50];
    for element in a {
        println!("the value is: {}", element);
    }

    // for 范围
    for number in 1..4 {  // 1, 2, 3（不包括 4）
        println!("{}", number);
    }

    for number in 1..=4 {  // 1, 2, 3, 4（包括 4）
        println!("{}", number);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 基本函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最后一个表达式（无分号）是返回值
}

// 多返回值（通过元组）
fn divide(a: f64, b: f64) -> (f64, f64) {
    (a / b, a % b)
}

fn main() {
    let result = add(1, 2);
    let (quotient, remainder) = divide(10.0, 3.0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 语句（Statement）
let y = 6;  // let 是语句，不返回值
// let x = (let y = 6);  // 编译错误！expected expression, found statement

// 表达式（Expression）
{
    let x = 3;
    x + 1  // 这是表达式，返回 4
}

// if 是表达式
let number = if condition { 5 } else { 6 };

// loop 可以返回值
let result = loop {
    break 100;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 错误示例
let x = {
    let y = 3;
    y + 1;  // 加了分号，变成了语句，返回 ()
};
// x 的类型是 ()，不是 i32

// 正确示例
let x = {
    let y = 3;
    y + 1  // 无分号，返回 4
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);  // 借用 s1
    println!("The length of '{}' is {}.", s1, len);  // s1 仍然有效

    let s2 = String::from("hello world");
    let hello = &s2[0..5];  // 字符串切片
    let world = &s2[6..11];
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

1
2
3
4
5
6
7
8

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的所有权移动到 s2
    // println!("{}", s1);  // 编译错误！value borrowed here after move

    let s3 = s2.clone();  // 深拷贝，s2 仍然有效
    println!("{}", s2);
}