Rust 極簡教程：最快上手 Rust 編程-
引言
Learn X in Y minutes 是一個非常棒的編程教程網站，旨在提供快速、簡潔的編程語言入門指南。這個網站的口號是 "Take a whirlwind tour of your next favorite language"(快速體驗你下一個喜歡的編程語言)。
網站的特點
-
覆蓋範圍廣：Learn X in Y minutes 提供了數十種編程語言的教程, 包括主流的語言如 Python、Rust、C++, 也包括一些相對小衆的語言如 Erlang、Haskell 等。
-
內容簡潔：每個教程都力求在儘可能短的篇幅內覆蓋語言的主要特性。通常一個教程只有一個頁面，可以在幾十分鐘內閱讀完畢，這也是網站名字 "in Y minutes" 的由來。
-
代碼示例豐富：教程中包含大量的代碼示例，通過這些示例可以快速瞭解語言的語法和用法。每個示例都有詳細的註釋解釋。
-
適合初學者：教程假設讀者已經有其他編程語言的經驗，因此省略了很多編程基礎知識，而是重點介紹語言的特性。這使得教程非常適合想要快速上手新語言的程序員。
-
開源協作：網站的所有教程都託管在 GitHub 上，任何人都可以貢獻新的教程或改進現有教程。這保證了教程的質量和更新速度。
Rust 的教程
// 這是註釋，單行註釋...
/* ...這是多行註釋 */
///////////////
// 1. 基礎 //
///////////////
// 函數 (Functions)
// `i32` 是有符號 32 位整數類型(32-bit signed integers)
fn add2(x: i32, y: i32) -> i32 {
// 隱式返回 (不要分號)
x + y
}
// 主函數(Main function)
fn main() {
// 數字 (Numbers) //
// 不可變綁定
let x: i32 = 1;
// 整形/浮點型數 後綴
let y: i32 = 13i32;
let f: f64 = 1.3f64;
// 類型推導
// 大部分時間，Rust 編譯器會推導變量類型，所以不必把類型顯式寫出來。
// 這個教程裏面很多地方都顯式寫了類型，但是隻是爲了示範。
// 絕大部分時間可以交給類型推導。
let implicit_x = 1;
let implicit_f = 1.3;
// 算術運算
let sum = x + y + 13;
// 可變變量
let mut mutable = 1;
mutable = 4;
mutable += 2;
// 字符串 (Strings) //
// 字符串字面量
let x: &str = "hello world!";
// 輸出
println!("{} {}", f, x); // 1.3 hello world
// 一個 `String` – 在堆上分配空間的字符串
let s: String = "hello world".to_string();
// 字符串分片(slice) - 另一個字符串的不可變視圖
// 基本上就是指向一個字符串的不可變指針，它不包含字符串裏任何內容，只是一個指向某個東西的指針
// 比如這裏就是 `s`
let s_slice: &str = &s;
println!("{} {}", s, s_slice); // hello world hello world
// 數組 (Vectors/arrays) //
// 長度固定的數組 (array)
let four_ints: [i32; 4] = [1, 2, 3, 4];
// 變長數組 (vector)
let mut vector: Vec<i32> = vec![1, 2, 3, 4];
vector.push(5);
// 分片 - 某個數組(vector/array)的不可變視圖
// 和字符串分片基本一樣，只不過是針對數組的
let slice: &[i32] = &vector;
// 使用 `{:?}` 按調試樣式輸出
println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
// 元組 (Tuples) //
// 元組是固定大小的一組值，可以是不同類型
let x: (i32, &str, f64) = (1, "hello", 3.4);
// 解構 `let`
let (a, b, c) = x;
println!("{} {} {}", a, b, c); // 1 hello 3.4
// 索引
println!("{}", x.1); // hello
//////////////
// 2. 類型 (Type) //
//////////////
// 結構體（Sturct)
struct Point {
x: i32,
y: i32,
}
let origin: Point = Point { x: 0, y: 0 };
// 匿名成員結構體，又叫“元組結構體”（‘tuple struct’）
struct Point2(i32, i32);
let origin2 = Point2(0, 0);
// 基礎的 C 風格枚舉類型（enum）
enum Direction {
Left,
Right,
Up,
Down,
}
let up = Direction::Up;
// 有成員的枚舉類型
enum OptionalI32 {
AnI32(i32),
Nothing,
}
let two: OptionalI32 = OptionalI32::AnI32(2);
let nothing = OptionalI32::Nothing;
// 泛型 (Generics) //
struct Foo<T> { bar: T }
// 這個在標準庫裏面有實現，叫 `Option`
enum Optional<T> {
SomeVal(T),
NoVal,
}
// 方法 (Methods) //
impl<T> Foo<T> {
// 方法需要一個顯式的 `self` 參數
fn get_bar(self) -> T {
self.bar
}
}
let a_foo = Foo { bar: 1 };
println!("{}", a_foo.get_bar()); // 1
// 接口（Traits） （其他語言裏叫 interfaces 或 typeclasses） //
trait Frobnicate<T> {
fn frobnicate(self) -> Option<T>;
}
impl<T> Frobnicate<T> for Foo<T> {
fn frobnicate(self) -> Option<T> {
Some(self.bar)
}
}
let another_foo = Foo { bar: 1 };
println!("{:?}", another_foo.frobnicate()); // Some(1)
///////////////////////////////////
// 3. 模式匹配 (Pattern matching) //
///////////////////////////////////
let foo = OptionalI32::AnI32(1);
match foo {
OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),
OptionalI32::Nothing => println!("it’s nothing!"),
}
// 高級模式匹配
struct FooBar { x: i32, y: OptionalI32 }
let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
match bar {
FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
println!("The numbers are zero!"),
FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
println!("The numbers are the same"),
FooBar { x: n, y: OptionalI32::AnI32(m) } =>
println!("Different numbers: {} {}", n, m),
FooBar { x: _, y: OptionalI32::Nothing } =>
println!("The second number is Nothing!"),
}
///////////////////////////////
// 4. 流程控制 (Control flow) //
///////////////////////////////
// `for` 循環
let array = [1, 2, 3];
for i in array {
println!("{}", i);
}
// 區間 (Ranges)
for i in 0u32..10 {
print!("{} ", i);
}
println!("");
// 輸出 `0 1 2 3 4 5 6 7 8 9 `
// `if`
if 1 == 1 {
println!("Maths is working!");
} else {
println!("Oh no...");
}
// `if` 可以當表達式
let value = if true {
"good"
} else {
"bad"
};
// `while` 循環
while 1 == 1 {
println!("The universe is operating normally.");
}
// 無限循環
loop {
println!("Hello!");
}
////////////////////////////////////////////////
// 5. 內存安全和指針 (Memory safety & pointers) //
////////////////////////////////////////////////
// 獨佔指針 (Owned pointer) - 同一時刻只能有一個對象能“擁有”這個指針
// 意味着 `Box` 離開他的作用域後，會被安全地釋放
let mut mine: Box<i32> = Box::new(3);
*mine = 5; // 解引用
// `now_its_mine` 獲取了 `mine` 的所有權。換句話說，`mine` 移動 (move) 了
let mut now_its_mine = mine;
*now_its_mine += 2;
println!("{}", now_its_mine); // 7
// println!("{}", mine); // 編譯報錯，因爲現在 `now_its_mine` 獨佔那個指針
// 引用 (Reference) – 引用其他數據的不可變指針
// 當引用指向某個值，我們稱爲“借用”這個值，因爲是被不可變的借用，所以不能被修改，也不能移動
// 借用一直持續到生命週期結束，即離開作用域
let mut var = 4;
var = 3;
let ref_var: &i32 = &var;
println!("{}", var); //不像 `mine`, `var` 還可以繼續使用
println!("{}", *ref_var);
// var = 5; // 編譯報錯，因爲 `var` 被借用了
// *ref_var = 6; // 編譯報錯，因爲 `ref_var` 是不可變引用
// 可變引用 (Mutable reference)
// 當一個變量被可變地借用時，也不可使用
let mut var2 = 4;
let ref_var2: &mut i32 = &mut var2;
*ref_var2 += 2;
println!("{}", *ref_var2); // 6
// var2 = 2; // 編譯報錯，因爲 `var2` 被借用了
}總結
總的來說, 如果你是一個有編程經驗的開發者, 想要快速瞭解一門新的編程語言, Learn X in Y minutes 是一個非常不錯的資源。當然, 它並不能替代系統的學習和實踐, 但可以作爲入門和參考資料。
參考文章
-
Learn X in Y minutes 官網：https://learnxinyminutes.com/
-
Learn X in Y minutes 倉庫地址：https://github.com/adambard/learnxinyminutes-docs
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/722roFliQeQnFNUy8VdNVA