官網(wǎng)：https://www.rust-lang.org/
跟著例子學(xué) Rust：https://tourofrust.com/00_zh-cn.html
Rust 基礎(chǔ)入門指南：為 Solana 合約學(xué)習(xí)鋪路 https://learnblockchain.cn/column/113
菜鳥 Rust 教程：https://www.runoob.com/rust/rust-tutorial.html

一、輸出到終端

fn main() {
    // 輸出小圖標(biāo) => 
    println!("你好，??!"); // 你好，??!
    // 占位符輸出
    let x = 12;
    println!("x is {}", x); // x is 12
    // 多占位符輸出
    println!("x is {},{}", x, x); // x is 12,12
    // 指定index占位符輸出
    println!("x is {0},{0}", x); // x is 12,12
    // 輸出占位符（轉(zhuǎn)義{}）
    println!("{{}}"); // {}
}

二、變量與常量

類型推斷

Rust 是強(qiáng)類型語言，但具有自動判斷變量類型的能力。變量的定義使用 let

let a = 1; // 等于 let a: i32 = 1

常用數(shù)據(jù)類型如下：

fn main() {
    // 整數(shù)：8位 ~ 128位（8、16、32、64、128）*（有符號i、無符號u）
    // 默認(rèn)為 i:32
    let a: i128 = -42; // 有符號整數(shù)
    let b: u32 = 42; // 無符號整數(shù)

    // 浮點數(shù)：32位、64位 默認(rèn)為 f64
    let c = 2.0; // f64
    let d: f32 = 3.0; // f32

    // 布爾數(shù)
    let e = true;
    let f: bool = false;

    // 字符類型：4字節(jié)（32位）
    // 采用 Unicode 編碼，可以存儲更廣泛的字符，如表情、數(shù)學(xué)符號
    // 而字符串 String 是多個字符的組合，組成的字符長度可變，每個字符可能占 1-4 字節(jié)（UTF-8 編碼）
    let g: char = 'A';
    let h: char = '??';
    let r: char = 'Ω';
    let j: char = '∑';

    // 元組
    // 復(fù)合類型，可以將不同類型的多個值組合進(jìn)一個復(fù)合類型
    // 結(jié)合函數(shù)，返回多個不同類型的返回值，很好用
    let k: (i32, f32, u8) = (100, 6.4, 1);
    // 可以使用 點. 來訪問元組的值；也可以用變量接收的方式
    let k1 = k.0;
    let k2 = k.1;
    let (x, y, z) = k;
    println!("y is {}", y);

    // 數(shù)組
    // 與元組不同，數(shù)組的值必須是同一類型
    let a = [1, 2, 3, 4, 5];
    let b = ["January", "February", "March"];
    let c: [i32; 5] = [1, 2, 3, 4, 5];
    let d = [3; 5]; // 等同于 let d = [3, 3, 3, 3, 3];
    // 數(shù)組訪問
    let first = a[0];
    let second = a[1];

    a[0] = 123; // 錯誤：數(shù)組 a 不可變，元素不可重新賦值
    let mut a = [1, 2, 3]; // 可變數(shù)組
    a[0] = 4; // 正確
}

可變性與類型匹配

fn main() {
    let a = 1; // 默認(rèn)不可變
    a = 2; // 失敗
    let mut b = 10; // mut 修飾為可變變量
    b = 20; // 成功
    b = 20.0; // 失敗，類型不匹配
    b = "123"; // 失敗，類型不匹配
    println!("Hello, {},{}", a,b)
}

常量

常量的定義使用 const

const A:i32 = 123;

fn main() {
    println!("a is {}", A)
}

三、函數(shù)

基本格式：fn <函數(shù)名> ( <參數(shù)> ) -> 返回類型 <函數(shù)體>，如果沒有返回，則不需要“-> 返回類型”

fn main() {
    // 函數(shù)調(diào)用方式
    let return_value = has_return_value(1, 2);
    println!("has_return_value is {}", return_value);
    has_no_return_value(1, 2);
    has_code_block();
    inner_function();
    
    // 函數(shù)嵌套
    fn inner_function() {
        println!("inner_function")
    }
}

// 測試返回值，Rust 中定義函數(shù)如果需要具備參數(shù)必須聲明參數(shù)名稱和類型
fn has_return_value(a: i32, b: i32) -> i32 {
    // 以下三種方式相同
    return a + b;
    // return a + b 不帶分號
    // a + b 不帶分號
}

// 測試沒有返回值
fn has_no_return_value(a: i32, b: i32) {
    println!("has_no_return_value is {}", a + b);
}

// 測試復(fù)雜的表達(dá)式塊
fn has_code_block() {
    let y = {
        let x = 1;
        x + 2 // 表達(dá)式塊{}中的返回表達(dá)式必須不帶分號，不可以使用return關(guān)鍵詞，函數(shù)的任何地方使用了 return 關(guān)鍵詞，就表示函數(shù)結(jié)束
    };

    println!("has_code_block is {}", y);
}

四、流程控制

條件語句

if 語句不僅可以用于條件判斷，還可以作為表達(dá)式返回值

fn main() {
    let a = 12;
    let b;
    // if 語句不需要小括號，Rust 中的條件表達(dá)式必須是 bool 類型
    if a > 0 {
        b = 1;
    } else if a < 0 {
        b = -1;
    } else {
        b = 0;
    }
    println!("b is {}", b);

    // 條件語句賦值
    let x = 3;
    let number = if x > 0 { 1 } else { -1 };
    println!("number 為 {}", number);
}

循環(huán)語句

for 語句通常用于遍歷集合，并且比 while 更安全（避免數(shù)組越界），可以使用 continue 跳過本次迭代，break 終止循環(huán)。
while 語句在滿足條件時執(zhí)行循環(huán)，但可能會導(dǎo)致索引越界錯誤
loop 適用于需要手動 break 退出的情況，可以結(jié)合 break 作為表達(dá)式返回值

fn main() {
    // while 循環(huán)
    let mut number = 1;
    while number != 4 {
        println!("{}", number);
        number += 1;
    }

    // for 循環(huán)
    let a = [10, 20, 30, 40, 50];
    // 迭代器訪問
    for i in a.iter() {
        println!("值為 : {}", i);
    }
    // 索引訪問
    for i in 0..5 {
        println!("a[{}] = {}", i, a[i]);
    }

    // loop無限循環(huán)
    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'O' {
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }
    // loop獲取返回值
    let location = loop {
        let ch = s[i];
        if ch == 'O' {
            // 返回值
            break i;
        }
        i += 1;
    };
    println!(" \'O\' 的索引為 {}", location);
}

五、模式匹配

match 匹配

match 語句必須覆蓋所有可能情況，因此 _ 用于匹配未列出的情況。

fn main() {
    let day = "Monday";
    
    match day {
        "Monday" => println!("新的一周開始了！"),
        "Friday" => println!("周五快樂！"),
        _ => println!("只是普通的一天"),
    }
}

結(jié)構(gòu)體解構(gòu)匹配

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 5, y: -3 };
    
    match point {
        Point { x: 0, y: 0 } => println!("原點"),
        Point { x, y } if y > 0 => println!("({},{}) 位于上半平面", x, y),
        Point { x, y } => println!("點的坐標(biāo): ({},{})", x, y),
    }
}

枚舉匹配

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn traffic_light_action(light: TrafficLight) {
    match light {
        TrafficLight::Red => println!("請停車！"),
        TrafficLight::Yellow => println!("準(zhǔn)備起步！"),
        TrafficLight::Green => println!("可以通行！"),
    }
}

fn main() {
    let light = TrafficLight::Green;
    traffic_light_action(light);
}

if let 簡化模式匹配

fn main() {
    let some_value = Some(42);
    
    if let Some(x) = some_value {
        println!("匹配到的值: {}", x);
    }
}