轉換型別

在 Rust 中該怎麼轉換型別呢？

只要加上 as 就可以了

讓我們來看一下吧

1
2
3
4
5
6
7
8
9
10
fn main() {
    let price: f32 = 18.5;
    println!("{}", price);

    let modified_price = price as i8;
    println!("{}", modified_price);
}

# 結果： 18.5
# 結果： 18

不過如果今天要把整數轉成字呢？

他會依照 Unicode 編碼來進行轉換，不過要注意的是，只有 u8 能轉換成 char 哦，因為 Unicode 的編碼並不多，所以只適用在 u8 範圍

而這個數字在 Unicode 編碼沒有對應的字，就會顯示空的

1
2
3
4
5
6
7
8
9
10
fn main() {
    let num: u8 = 33;
    println!("{}", num);

    let character = num as char;
    println!("{}", character);
}

# 結果： 33
# 結果： !

雖然 Rust 可以用 as 方式去轉換型別，不過也不是所有的型別都可以轉換過去哦

就像我們剛剛要轉換成 char 時，只有 u8 能夠轉

運算式

在介紹基本型別後，我們要開始進入邏輯階段了！

首先要來認識一下運算子

在 Rust 中有幾個運算式

  • 算術運算式
  • 複合指定運算式
  • 邏輯運算式
  • 比較運算式

我們直接一個一個來介紹

算術運算式

顧名思義就是加減乘除，還有多一個餘數

要用加法的話，使用 +
1
2
3
4
5
6
7
8
9
fn main() {
    let num1: i8 = 33;
    let num2: i8 = 20;
    let total = num1 + num2;

    println!("num1 + num2 = {}", total);
}

# 結果：num1 + num2 = 53
減法使用 -
1
2
3
4
5
6
7
8
9
fn main() {
    let num1: i8 = 33;
    let num2: i8 = 20;
    let total = num1 - num2;

    println!("num1 - num2 = {}", total);
}

# 結果：num1 + num2 = 13
乘法使用 *

這邊我把型別都改成了 i32，因為 i8 無法支援相乘後的結果

1
2
3
4
5
6
7
8
9
10
fn main() {
    let num1: i32 = 33;
    let num2: i32 = 20;

    let total = num1 * num2;

    println!("num1 * num2 = {}", total);
}

# 結果：num1 * num2 = 660
除法使用 /

這邊要注意，整數相除的結果會是整數，浮點數相除的結果會是浮點數

1
2
3
4
5
6
7
8
9
10
fn main() {
    let num1: i8 = 33;
    let num2: i8 = 20;

    let total = num1 / num2;

    println!("num1 / num2 = {}", total);
}

# 結果：num1 / num2 = 1
取餘數使用 %
1
2
3
4
5
6
7
8
9
10
fn main() {
    let num1: i8 = 33;
    let num2: i8 = 20;

    let total = num1 % num2;

    println!("num1 % num2 = {}", total);
}

# 結果：num1 % num2 = 13

以上是基本的加減乘除，相信大家到這邊應該都可以輕易理解，接下來我們就進入 複合指定運算式

複合指定運算式

在前幾天有提到，要定義變數使用 = 去變動，這是所謂的指定運算子

那 複合指定運算式 是什麼？

當我們想針對原本的數值做加減乘除，就可以使用 複合指定運算式

我們直接用舉例會比較清楚

以加法來說，假設今天有個變數 a 的值是 2 ，我希望改變他的值，讓他 +1 後變成 3，我們就可以用 += 來達成

在看範例之前，我們來了解 += 是怎麼解讀

num += 2 可以解讀成 num = num + 2

減乘除、求餘數同理，在運作子後面加上 = 即可成立囉

減乘除、求餘數會分別是(-= *= /= %=)

(記得要加上 mut ，不然會噴錯喔！)

1
2
3
4
5
6
7
8
9
fn main() {
    let mut num1: i8 = 33;

    num1 += 2;

    println!("{}", num1);
}

# 結果：35

比較運算式

基本上就是 > < = 這類的比較

結果會返回一個布林值，讓我們直接來看範例

1
2
3
4
5
6
7
fn main() {
    let greater = 5 > 3;

    println!("{}", greater);
}

# 結果：true

會有哪些比較運算式呢？

> 左邊大於右邊 成立的時候返回 true ，反之 false
>= 左邊大於或等於右邊 成立的時候返回 true，反之 false
< 左邊小於右邊 成立的時候返回 true ，反之 false
<= 左邊小於或等於右邊 成立的時候返回 true ，反之 false
== 左邊等於右邊 成立的時候返回 true ，反之 false
!= 左邊不等於右邊 成立的時候返回 true ，反之 false

邏輯運算式

這邊可能就要稍微動動理解力！

會有三個邏輯運算式，我們以下詳細講解：

&&

&& 當兩邊的條件式都成立時(結果都是 true ) 即返回 true，反之 false 

1
2
3
4
5
6
7
8
9
10
11
fn main() {
    let greater = 5 > 3;
    let less = 6 > 4;

    # greater 跟 less 都是 true，因此 operate 也會是 true
    let operation = greater && less;

    println!("{}", operation);
}

# 結果： true

來稍微動個手腳，把 less 結果變成 false

這時候 operation 就會變成 false

因為 && 是在兩個條件式都是 true 的情況下才會是 true

其中一個不是 true 或者是 第一個就是 false ，就會直接返回 false

1
2
3
4
5
6
7
8
9
10
fn main() {
    let greater = 5 > 3;
    let less = 6 < 4;

    let operation = greater && less;

    println!("{}", operation);
}

# 結果： false
||

|| 當其中一邊的條件式成立時(某一邊結果是 true) 即返回 true，反之 false

拿剛剛的例子來做範例，我們改一下運算子為 ||

1
2
3
4
5
6
7
8
9
10
11
fn main() {
    let greater = 5 > 3;
    let less = 6 < 4;

    # greater 為 true ， less 為 false，以 || 來看只要有個 true，就無條件返回 true
    let operation = greater || less;

    println!("{}", operation);
}

# 結果： true

如果兩個結果都是 false 呢？ 就會返回 false

1
2
3
4
5
6
7
8
9
10
11
fn main() {
    let greater = 5 < 3;
    let less = 6 < 4;

    # greater 為 true ， less 為 false，以 || 來看只要有個 true，就無條件返回 true
    let operation = greater || less;

    println!("{}", operation);
}

# 結果： false
!

! 代表相反的意思

1
2
3
4
5
6
7
8
9
10
fn main() {
    let less = 6 < 4;

    # 原本的 less 為 false，加了 ! 後反轉，因此 operation 就成了 true
    let operation = !less;

    println!("{}", operation);
}

# 結果： ture