# Rust 基本教學
:::success
您正在閱讀「[Rust Taiwan 2020 讀書會筆記](https://hackmd.io/@ballfish/Hy7jJN7WI)」的一節，歡迎點擊本頁上方的 <i class="fa fa-pencil btn btn-default disabled"></i> 協助編修。
:::
[TOC]
## Hello World!
### 不使用管理工具編寫程式
1. 建立副檔名為 `.rs` 的檔案 ex: `main.rs`
2. 寫 main function，程式碼編譯過後，會以 main function 作為進入點
```rust=
fn main () {
}
```
3. 印出 `Hello World!`
```rust=
fn main () {
println!("Hello World");
}
```
4. 編譯程式碼
```shell=
rustc main.rs
```
5. 編譯完後會產生 `main`/`main.exe` 檔，執行 `main`/`main.exe` 檔
```shell=
./main
```
### 使用 Cargo 管理專案
1. 建立專案
```shell=
cargo new hello_world
```
2. 編輯 `src/main.rs` 的檔案
```rust=
fn main() {
println!("Hello, world!");
}
```
3. 檢查專案是否可以編譯得過
```shell=
cargo check
```
4. 編譯
```shell=
cargo build
```
5. 執行
```shell=
cargo run
```
6. 優化編譯
```shell=
cargo build --release
```
### Hello World 的程式碼解析
```rust=
fn main () {} // fn 是 function 的關鍵字
```
```rust=
println!("Hello World!") // println 是印出資料的語法，! 是 macro 的寫法， println! 是官方的 macro ，會在編譯時期根據目標平台轉換成相應的程式碼
```
## 宣告變數
- 在 rust 中，可以不用宣告型別，也會由編譯器自行推定
```rust=
fn main () {
let x = 5; // 會被自行推定為 i32
let y: i32 = 10; // 也可以宣告變數型別
}
```
- 預設所有變數都是不可變的
```rust=
fn main () {
let x = 5;
x = 10; // 不可以改變 x 的值
}
```
- 若要改變變數，必須宣告 `mut`
```rust=
fn main () {
let mut x = 5;
x = 10; // OK
}
```
- 可以用 tuple 或 struct 的方式宣告多個變數並同時賦值
```rust=
fn main () {
let (a, b) = (1, 2);
let (mut x, mut y) = (1, 2); // 或宣告可變的變數
}
```
- 可以事先宣告變數，但若變數被宣告後沒有初始化，同時在之後被使用到，會編譯不過
```rust=
fn main () {
let x: i32;
println!("{}", x); // use of possibly-uninitialized `x`
}
```
```rust=
fn main () {
let x: i32;
let condition = true;
if condition {
x = 1; // 因為在這裡被初始化了
println!("{}", x); // 所以可以使用
}
// 但在這裡沒有被初始化
println!("{}", x); // 在這裡會出錯
}
```
- 有的時候會在接別人的 API 時，遇到用不到，但必須寫出來的變數，可以用`底線` 帶過，就可以讓編譯器~~閉嘴~~，讓編譯器忽略沒有使用到這個變數，但同時`底線`變數也被視為不能被使用的變數，所以不可以在後面的程式碼中使用到
```rust=
fn main () {
let _ = "hello";
println!("{}", _); // expected expression
}
```
- 如果在寫程式的途中，想要命名一個跟前面名稱一模一樣的變數是可以的
```rust=
fn main () {
let x = "Hello";
println!("{}", x);
let x = 5; // 前面的變數會被 shadowing
println!("{}", x);
}
```
- 可以用 `type` 為一個型別取新的名字
```rust=
type Age = u32;
fn grow (age: Age, year: u32) -> Age {
age + year
}
```
- 宣告靜態變數
```rust=
static GLOBAL: i32 = 0;
```
- 宣告常數
```rust=
const GLOBAL: i32 = 0;
```
## 型別種類
- bool
- char
- 數字
- array
```rust=
let a = [1, 2, 3];
let first = a[0];
let second = a[1];
```
- tuple
```rust=
let a = ("hello", 1)
```
- struct
```rust=
struct Person {
age: u32,
weight: u32,
}
fn main () {
let ballfish = Person { age: 18, weight: 40 };
println!("{}, {}", age, weight);
}
```
- tuple struct
```rust=
struct Color (i32, i32, i32);
```
- enum
```rust=
enum Food {
Noodle,
Rice
}
enum Message {
Quit,
ChangeColor(i32, i32, i32),
Move { x: i32, y: i32 },
}
```
## if/else、loop、function
- 用大括號括起來的區塊，可以放在等號後面，最後一行不寫分號，會被視為回傳直傳出去
```rust=
fn main () {
let x = { println!("喵喵喵喵"); 5 };
println!("{}", x);
}
```
- if/else
```rust=
fn main () {
let n = 4;
if n < 0 {
println!("Wow");
} else if n == 0 {
println!("owo");
} else {
println!("Orz");
}
// Orz
}
```
- Rust 並沒有三元運算子（ex: n < 0 ? "owo" : "OAO"），但可以把 if/else 寫成下面這樣
```rust=
fn main () {
let n = 4;
let x = if n < 4 { "owo" } else { "OAO" };
println!("{}", x);
// OAO
}
```
- Rust 中，若 else 沒有寫出來，視為回傳 `()`，以剛剛的例子而言，由於 `x` 必須在編譯時期就確定型態，所以 if/else 回傳的值必須一致。也因此，通常 if 會伴隨 else，除非 if 沒有回傳值
```rust=
fn main () {
let n = 4;
let x = if n < 4 { "owo" } else { 5 }; // expected `&str`, found integer
println!("{}", x);
}
```
```rust=
fn main () {
let n = 4;
let x = if n < 4 { "owo" }; // expected `()`, found `&str`
}
```
```rust=
fn main () {
let n = 4;
let x = if n < 5 { println!("OAO") };
// OAO
}
```
- loop，是一個不帶條件的無限迴圈
```rust=
fn main () {
loop {
print!("喵喵喵喵");
}
}
```
- 跟其他的程式語言一樣，Rust 有 `continue` 與 `break`
```rust=
fn main () {
loop {
print!("汪汪");
break;
}
loop {
print!("喵喵喵喵");
continue;
print!("噗伊");
}
}
```
- 你可以在 `break` 後面接值，這個值會被作為回傳值
```rust=
fn main () {
let a = loop {
println!("噗伊");
break 5;
};
println!("{}", a);
// 噗伊
// 5
}
```
- while，帶有條件的迴圈
```rust=
fn main () {
let mut n = 0;
while n < 10 {
println!("喵喵喵喵");
n += 1;
}
}
```
- while 也可以接在等號後面，但因為 `break` 在 `while` 中不能接值，所以永遠會回傳 `()`
```rust=
fn main () {
let mut n = 0;
let x = while n < 10 {
n += 1;
break 5; // can only break with a value inside `loop` or breakable block
};
}
```
```rust=
fn main () {
let mut n = 0;
// OK，但 x = ()
let x = while n < 10 {
n += 1;
break;
};
}
```
- loop 與 while 的差異
- loop 是不帶條件一定會執行的迴圈
- while 是帶有條件，不一定會被執行的迴圈
- 對於編義器來說，while block 裡的程式碼不一定會被執行到，無論 while 後面接的是不是 true
- 也是因為這個差異，`break` 在 `while` 裏面才會不能接值，因為 while 沒有被執行的情況下，回傳直永遠是 `()`，所以在 while block 裡的回傳值一定要是 `()`
```rust=
fn main () {
let x;
loop { x = 1; break; }
println!("{}", x); // x 一定會在 loop 中被初始化，所以編譯會過
}
```
```rust=
fn main () {
let x;
while true { x = 1; break; }
// 因為編譯器無法保證 while block 裡的程式碼一定會被執行到，所以無法保證 x 一定會被初始化，因此編譯不會過
println!("{}", x); // use of possibly-uninitialized `x`
}
```
- for loop，Rust 中沒有其他語言常有的 `for (i = 0;i < 10;i++)`，Rust 中的 for loop形式跟其他語言的 for-each 視同義的
```rust=
fn main () {
let array = [1, 2, 3];
for i in array.iter() {
println!("{}", i);
}
}
```
- for loop 跟 while 的特性一樣，block 中的 `break` 後不可以接值， for loop 可以接在等號後面
- function
```rust=
fn add (t: (i32, i32)) -> i32 {
t.0 + t.1
}
```
- function 的 parameter 還可以直接解構
```rust=
fn add ((x, y): (i32, i32)) -> i32 {
x + y
}
```
- function 可以作為一個普通的變數
```rust=
fn add ((x, y): (i32, i32)) -> i32 {
x + y
}
fn main () {
let func = add;
println!("{}", func((1, 2))); // 3
}
```
- 不會正常回傳的 function
```rust=
fn amazing () -> ! {
panic!("crash the application~~");
}
```
- const fn，加上 const 關鍵字的 function 可以在編譯時期被執行，執行完的值也可以作為常數使用
```rust=
const fn add ((x, y): (i32, i32)) -> i32 {
x + y
}
fn main () {
const CONSTANT: i32 = add((1, 2));
println!("{}", CONSTANT);
}
```
- Rust 的 function 可以遞迴，但跟其他語言一樣過多層的遞迴會 stack overflow
Sign in with Wallet
Connect another wallet