我們之所以會使用 Function 是因為有些程式碼需要重複使用，不需要重複寫方法

使用方式

在 Rust 中，Function 該怎麼使用呢？
其實跟其他程式語言差不多，只是寫法不太一樣而已

fn hello(){
    println!("hello");
}

fn main(){
    hello
}

上面有看到我們用 main 這個 function 把 hello() 包起來了，為什麼？

在 Rust 中，main() 就像是 React 中的 index.js 檔案，是這個專案的進入點，

會將所有的 function 集中在裡面，一起執行

參數

function 最大的用意是讓我們可以重複使用，
加入參數可以讓 function 更有彈性

讓我們來看一下該怎麼使用吧

fn calculator(a: i32, b: i32) {
    let result = (a + b) * b;

    println!("{}", result)
}

fn main() {
    calculator(10, 2);
}

結果： 24

return 指定型別

在 Rust 中，並不是只有定義變數及參數的時候需要指定型別，
return 也是可以給指定型別的哦

fn calculator(a: i32, b: i32) -> i32 {
    let result = (a + b) * b;

    println!("{}", result)
}

fn main() {
    calculator(10, 2);
}

結果： 24

Block

接下來我們就來談談 Rust 的作用域吧！

我們所定義的變數只會存在於產出他的 block 中，

function 跟 {} 都算是 block

讓我們來看看範例吧

fn main() {
    let character: char = 'A';
    {
        let character: char = 'B';
        println!("{}", character)
    }
    println!("{}", character)
}

結果：
B
A

現在我們知道，作用域為一個 block

在 block 以內就是全新的世界

這邊我們就必須要提到一個名詞，叫做變數遮蔽 Variable Shadowing

當我們進入到一個新的 block 時，遇到相同變數，他會蓋掉就有的定義，指向新的定義值

出了這個 block 後，又會變成原本就有的定義值

讓我們來看看範例

進入到 block 中， character 就變成了 B 了

出了 block 後，變成原本的 A

重新定義就變成了 C

fn main() {
    let character: char = 'A';
    {
        let character: char = 'B';
        println!("{}", character)
    }

    println!("{}", character);

    let character = 'C';
    println!("{}", character)
}

結果：
B
A
C

這樣看起來好像也不是說很嚴謹啊，我不管什麼時候想改都可以

如果想要讓變數不被改，我們可以將它指向某個變數，這樣你想改也都不行囉

fn main() {
    let character: char = 'A';
    {
        let character = character;

        character = 'B';
        println!("{}", character)
    }

    println!("{}", character)
}

結果：
error[E0384]: cannot assign twice to immutable variable `character`
 --> src/main.rs:6:9
  |
4 |         let character = character;
  |             ---------
  |             |
  |             first assignment to `character`
  |             help: consider making this binding mutable: `mut character`
5 |
6 |         character = 'B';
  |         ^^^^^^^^^^^^^^^ cannot assign twice to immutable variable

可是出了這個 block ，規則就會不一樣囉！

fn main() {
    let character: char = 'A';
    {
        let character = character;

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

    let character: char = 'C';

    println!("{}", character)
}

結果：
A
C

不受限於 block，我想怎麼改就怎麼改（被打

接下來來談談匿名函式吧

let withoutName = || println!("I don't have a name")

withoutName()

結果：
I don't have a name

匿名函式要帶參數怎麼帶

fn main() {
    let calculation = |x: i32, y: i32| {
        let mut sum = x + y;
        return sum;
    };

    let sum = calculation(2, 5);
    println!("the result = {}", sum)
}

結果：
the result = 7