Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

การควบคุมโฟลว์

ความสามารถในการสั่งให้โค้ดบางส่วนทำงานตามเงื่อนไข (condition) ว่าเป็นจริง (true) หรือไม่ รวมถึงความสามารถในการสั่งให้โค้ดทำงานซ้ำๆ ตราบใดที่เงื่อนไขยังเป็นจริง ถือเป็นโครงสร้างพื้นฐานที่มีอยู่ในภาษาโปรแกรมเกือบทุกภาษา สำหรับใน Rust โครงสร้างหลักๆ ที่ใช้ควบคุมลำดับการทำงาน (control flow) ของโปรแกรมก็คือนิพจน์ if และลูป (loop)

นิพจน์ if

นิพจน์ if ช่วยให้คุณสามารถแยกสายการทำงาน (branch) ของโค้ดตามเงื่อนไขที่กำหนดได้ โดยมีหลักการคือ “หากเงื่อนไขนี้เป็นจริง ให้ทำงานในบล็อกโค้ดนี้ แต่ถ้าเงื่อนไขไม่เป็นจริง ก็ไม่ต้องทำงานในบล็อกนี้”

สร้างโปรเจกต์ใหม่ชื่อ branches ในไดเรกทอรี projects ของคุณเพื่อสำรวจนิพจน์ if ในไฟล์ src/main.rs ให้ป้อนโค้ดต่อไปนี้:

ชื่อไฟล์: src/main.rs

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

นิพจน์ if ทั้งหมดเริ่มต้นด้วยคำสงวน if ตามด้วยเงื่อนไข ในกรณีนี้ เงื่อนไขจะตรวจสอบว่าตัวแปร number มีค่าน้อยกว่า 5 หรือไม่ เราวางบล็อกโค้ดที่จะทำงานหากเงื่อนไขเป็น true ไว้หลังเงื่อนไขทันทีภายในวงเล็บปีกกา บล็อกโค้ดที่เชื่อมโยงกับเงื่อนไขในนิพจน์ if บางครั้งเรียกว่า_กิ่งกรณี_ หรือ แขนง (arm) เช่นเดียวกับกิ่งกรณีในนิพจน์ match ที่เราได้พูดถึงในหัวข้อ“การเปรียบเทียบคำทายกับตัวเลขลับ” ของบทที่ 2

นอกจากนี้ เรายังสามารถใส่นิพจน์ else เพิ่มเติมได้ด้วย ซึ่งเราเลือกใส่ในตัวอย่างนี้ เพื่อให้โปรแกรมมีบล็อกโค้ดทางเลือกที่จะทำงานในกรณีที่เงื่อนไขประเมินค่าเป็น false หากคุณไม่ได้ระบุนิพจน์ else และเงื่อนไขเป็น false โปรแกรมก็จะข้ามบล็อก if ไปทำงานที่โค้ดส่วนถัดไปทันที

ลองรันโค้ดนี้ดู คุณควรเห็นเอาต์พุตต่อไปนี้:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was true

มาลองเปลี่ยนค่าของ number เป็นค่าที่ทำให้เงื่อนไขเป็น false เพื่อดูว่าเกิดอะไรขึ้น:

fn main() {
    let number = 7;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

รันโปรแกรมอีกครั้ง แล้วดูเอาต์พุต:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was false

นอกจากนี้ สิ่งสำคัญที่ควรสังเกตคือเงื่อนไขในโค้ดนี้ จะต้อง เป็นชนิดข้อมูล bool เสมอ หากเงื่อนไขไม่ใช่ bool คอมไพเลอร์จะแจ้งข้อผิดพลาดทันที ตัวอย่างเช่น ลองรันโค้ดต่อไปนี้:

ชื่อไฟล์: src/main.rs

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

คราวนี้เงื่อนไข if ประเมินค่าได้เป็น 3 และ Rust แจ้งข้อผิดพลาดออกมา:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

ข้อความแสดงข้อผิดพลาดระบุว่า Rust คาดหวังชนิดข้อมูล bool แต่ได้รับตัวเลขจำนวนเต็มมาแทน ต่างจากภาษาอย่างเช่น Ruby หรือ JavaScript ตรงที่ Rust จะไม่พยายามแปลงชนิดข้อมูลที่ไม่ใช่บูลีนให้เป็นบูลีนโดยอัตโนมัติ คุณจะต้องระบุเงื่อนไขอย่างชัดแจ้งและกำหนดให้นิพจน์ if ได้รับค่าบูลีนเป็นเงื่อนไขเสมอ ตัวอย่างเช่น หากเราต้องการให้บล็อกโค้ด if ทำงานเฉพาะเมื่อตัวเลขไม่เท่ากับ 0 เราสามารถแก้ไขนิพจน์ if ได้ดังนี้:

ชื่อไฟล์: src/main.rs

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

การรันโค้ดนี้จะพิมพ์ number was something other than zero

การจัดการหลายเงื่อนไขด้วย else if

คุณสามารถตรวจสอบหลายเงื่อนไขได้โดยการผสาน if และ else เข้าด้วยกันเป็นนิพจน์ else if ตัวอย่างเช่น:

ชื่อไฟล์: src/main.rs

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

โปรแกรมนี้มีเส้นทางที่เป็นไปได้สี่เส้นทาง หลังจากรันแล้ว คุณควรเห็นเอาต์พุตต่อไปนี้:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
number is divisible by 3

เมื่อโปรแกรมนี้ทำงาน มันจะตรวจสอบนิพจน์ if แต่ละเงื่อนไขตามลำดับ และจะสั่งให้บล็อกแรกสุดที่เงื่อนไขประเมินค่าเป็น true ทำงาน โปรดสังเกตว่าแม้ 6 จะหารด้วย 2 ลงตัว แต่เราจะไม่เห็นเอาต์พุต number is divisible by 2 และไม่เห็นข้อความ number is not divisible by 4, 3, or 2 จากบล็อก else นั่นเป็นเพราะ Rust จะรันเฉพาะบล็อกของเงื่อนไขแรกที่เป็น true เท่านั้น และเมื่อพบเงื่อนไขที่เป็นจริงแล้ว ก็จะไม่ตรวจสอบเงื่อนไขที่เหลืออีกเลย

การใช้นิพจน์ else if ต่อกันมากเกินไปอาจทำให้โค้ดดูรกรุงรังและอ่านยาก ดังนั้นหากคุณมีเงื่อนไขมากกว่าหนึ่งเงื่อนไข คุณอาจพิจารณารีแฟกเตอร์ (refactor) โค้ดของคุณ ซึ่งในบทที่ 6 จะอธิบายถึงโครงสร้างการแยกสายการทำงานอันทรงพลังของ Rust ที่ชื่อว่า match สำหรับกรณีเหล่านี้

การใช้ if ในคำสั่ง let

เนื่องจาก if เป็นนิพจน์ เราจึงสามารถนำมันไปวางไว้ทางด้านขวาของคำสั่ง let เพื่อกำหนดค่าให้กับตัวแปรได้ ดังในลิสติ้ง 3-2

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

ตัวแปร number จะถูกผูกเข้ากับค่าตามผลลัพธ์ของนิพจน์ if ลองรันโค้ดนี้เพื่อดูสิ่งที่เกิดขึ้น:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
The value of number is: 5

โปรดจำไว้ว่า บล็อกโค้ดจะประเมินค่าเป็นนิพจน์สุดท้ายในบล็อกนั้น และตัวเลขโดดๆ ก็ถือเป็นนิพจน์เช่นกัน ในกรณีนี้ ค่าของนิพจน์ if ทั้งหมดจึงขึ้นอยู่กับว่าบล็อกโค้ดใดทำงาน ซึ่งหมายความว่าค่าที่เป็นไปได้จากแต่ละกิ่งกรณีของ if จะต้องเป็นชนิดข้อมูลเดียวกัน ในลิสติ้ง 3-2 ผลลัพธ์ของทั้งกิ่ง if และกิ่ง else ต่างเป็นจำนวนเต็ม i32 แต่หากชนิดข้อมูลไม่ตรงกัน ดังในตัวอย่างต่อไปนี้ ก็จะเกิดข้อผิดพลาดขึ้น:

ชื่อไฟล์: src/main.rs

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {number}");
}

เมื่อเราพยายามคอมไพล์โค้ดนี้ เราจะพบข้อผิดพลาด เนื่องจากกิ่ง if และ else มีชนิดของค่าที่เข้ากันไม่ได้ และ Rust จะระบุตำแหน่งของปัญหาในโปรแกรมไว้อย่างชัดเจน:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

นิพจน์ในบล็อก if ประเมินค่าได้เป็นจำนวนเต็ม ส่วนนิพจน์ในบล็อก else ประเมินค่าได้เป็นสตริง โค้ดนี้ไม่สามารถทำงานได้ เนื่องจากตัวแปรต้องมีชนิดข้อมูลที่แน่นอนเพียงชนิดเดียว และ Rust จำเป็นต้องทราบอย่างแน่ชัดตั้งแต่ขั้นตอนการคอมไพล์ว่าตัวแปร number มีชนิดข้อมูลใด การทราบชนิดข้อมูลของ number ช่วยให้คอมไพเลอร์สามารถตรวจสอบความถูกต้องได้ทุกจุดที่เราเรียกใช้ number ซึ่ง Rust จะไม่สามารถตรวจสอบเช่นนั้นได้เลยหากชนิดข้อมูลของ number ถูกกำหนดเฉพาะตอนรันไทม์ (runtime) เพราะคอมไพเลอร์จะต้องมีความซับซ้อนขึ้นอย่างมาก และไม่สามารถให้การรับประกันด้านความปลอดภัยของโค้ดได้ หากต้องคอยติดตามความเป็นไปได้ของชนิดข้อมูลหลายชนิดในตัวแปรตัวหนึ่ง

การวนซ้ำด้วยลูป

การสั่งให้บล็อกโค้ดทำงานซ้ำมากกว่าหนึ่งครั้งถือเป็นงานที่พบบ่อยและมีประโยชน์อย่างยิ่ง สำหรับงานนี้ Rust มีโครงสร้าง_ลูป_ (loop) ให้เลือกใช้งานหลายรูปแบบ ซึ่งจะรันโค้ดภายในตัวลูปไปจนสุดแล้ววนกลับมาเริ่มต้นใหม่ทันที เพื่อทดลองใช้งานลูป มาสร้างโปรเจกต์ใหม่ชื่อ loops กัน

Rust มีลูปให้ใช้งานสามรูปแบบ ได้แก่ loop, while และ for มาลองดูทีละแบบกัน

การรันโค้ดซ้ำด้วย loop

คำสงวน loop จะสั่งให้ Rust รันบล็อกโค้ดซ้ำไปเรื่อยๆ อย่างไม่มีที่สิ้นสุด จนกว่าคุณจะสั่งให้มันหยุดอย่างชัดเจน

ตัวอย่างเช่น เปลี่ยนไฟล์ src/main.rs ในไดเรกทอรี loops ของคุณให้มีลักษณะดังนี้:

ชื่อไฟล์: src/main.rs

fn main() {
    loop {
        println!("again!");
    }
}

เมื่อเรารันโปรแกรมนี้ เราจะเห็นข้อความ again! ถูกพิมพ์ซ้ำไปเรื่อยๆ อย่างต่อเนื่องจนกว่าเราจะหยุดโปรแกรมด้วยตนเอง เทอร์มินัลส่วนใหญ่รองรับคีย์ลัด ctrl-C เพื่อขัดจังหวะโปรแกรมที่ติดอยู่ในลูปต่อเนื่อง ลองดูสิ:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

สัญลักษณ์ ^C แสดงถึงตำแหน่งที่คุณกด ctrl-C

คุณอาจเห็นหรือไม่เห็นคำว่า again! พิมพ์ตามหลัง ^C ขึ้นอยู่กับว่าโค้ดกำลังทำงานอยู่ที่ตำแหน่งใดของลูปเมื่อได้รับสัญญาณขัดจังหวะ

โชคดีที่ Rust ยังมีวิธีออกจากลูปโดยใช้โค้ดด้วย คุณสามารถใส่คำสงวน break ไว้ภายในลูปเพื่อสั่งให้โปรแกรมหยุดการทำงานของลูปเมื่อถึงจุดที่ต้องการ ย้อนนึกดูว่าเราได้ทำเช่นนี้ในเกมทายตัวเลขในหัวข้อ“ออกจากเกมเมื่อทายถูก” ของบทที่ 2 เพื่อออกจากโปรแกรมเมื่อผู้เล่นชนะเกมด้วยการทายตัวเลขที่ถูกต้อง

นอกจากนี้ เรายังได้ใช้ continue ในเกมทายตัวเลขด้วย ซึ่งเมื่ออยู่ในลูป มันจะสั่งให้โปรแกรมข้ามโค้ดที่เหลือทั้งหมดในรอบการวนซ้ำ (iteration) ปัจจุบัน แล้วข้ามไปยังรอบถัดไปทันที

การคืนค่าจากลูป

ประโยชน์ประการหนึ่งของ loop คือการลองทำซ้ำในงานที่คุณทราบว่าอาจมีโอกาสล้มเหลว เช่น การตรวจสอบว่าเธรด (thread) ทำงานเสร็จสิ้นแล้วหรือไม่ และคุณอาจจำเป็นต้องส่งผลลัพธ์ของงานนั้นออกจากลูปกลับไปยังโค้ดส่วนที่เหลือด้วย เพื่อทำเช่นนั้น คุณสามารถระบุค่าที่ต้องการส่งกลับไว้หลังนิพจน์ break ที่คุณใช้หยุดลูป โดยค่านั้นจะถูกส่งออกมาจากลูปเพื่อให้คุณนำไปใช้งานต่อ ดังที่แสดงที่นี่:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

ก่อนลูป เราประกาศตัวแปรชื่อ counter และกำหนดค่าเริ่มต้นเป็น 0 จากนั้นเราประกาศตัวแปรชื่อ result เพื่อเก็บค่าที่คืนกลับมาจากลูป ในทุกๆ รอบของการวนซ้ำ เราเพิ่มค่า 1 ให้กับตัวแปร counter แล้วตรวจสอบว่า counter มีค่าเท่ากับ 10 หรือไม่ เมื่อเท่ากัน เราจะใช้คำสงวน break พร้อมกับค่า counter * 2 หลังจบลูป เราใช้อัฒภาค (semicolon) เพื่อจบคำสั่งที่กำหนดค่าให้กับ result สุดท้าย เราพิมพ์ค่าใน result ออกมา ซึ่งในกรณีนี้คือ 20

คุณยังสามารถใช้ return จากภายในลูปได้เช่นกัน โดยขณะที่ break จะออกจากลูปปัจจุบันเท่านั้น คำสั่ง return จะออกจากฟังก์ชันปัจจุบันเสมอ

การแยกแยะลูปด้วยเลเบลของลูป

หากคุณมีลูปซ้อนอยู่ในลูป คำสั่ง break และ continue จะมีผลกับลูปชั้นในสุด ณ ตำแหน่งนั้น คุณสามารถระบุ_เลเบลของลูป_ (loop label) ให้กับลูปได้ตามต้องการ ซึ่งจากนั้นคุณสามารถนำมาใช้ร่วมกับ break หรือ continue เพื่อระบุว่าคำสงวนเหล่านั้นมีผลกับลูปที่มีเลเบลใด แทนที่จะเป็นลูปชั้นในสุด โดยเลเบลของลูปต้องขึ้นต้นด้วยเครื่องหมายอัญประกาศเดี่ยว (single quote) นี่คือตัวอย่างที่มีลูปซ้อนกันสองชั้น:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

ลูปชั้นนอกมีเลเบล 'counting_up และจะนับขึ้นจาก 0 ถึง 2 ลูปชั้นในที่ไม่มีเลเบลจะนับลงจาก 10 ถึง 9 break ตัวแรกที่ไม่ได้ระบุเลเบลจะออกจากลูปชั้นในเท่านั้น ส่วนคำสั่ง break 'counting_up; จะออกจากลูปชั้นนอก โค้ดนี้จะพิมพ์:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

ทำลูปแบบมีเงื่อนไขให้กระชับด้วย while

โปรแกรมมักจำเป็นต้องตรวจสอบเงื่อนไขภายในลูปอยู่เสมอ ตราบใดที่เงื่อนไขยังคงเป็น true ลูปก็จะทำงานต่อไป เมื่อเงื่อนไขไม่เป็น true อีกต่อไป โปรแกรมก็จะเรียก break เพื่อหยุดลูป ซึ่งเราสามารถสร้างพฤติกรรมเช่นนี้ได้โดยใช้การผสมผสานระหว่าง loop, if, else และ break เข้าด้วยกัน (คุณอาจลองทำในโปรแกรมตอนนี้ดูได้หากต้องการ) อย่างไรก็ตาม รูปแบบนี้พบได้บ่อยมากจน Rust มีโครงสร้างภาษาในตัวสำหรับมันโดยเฉพาะ เรียกว่าลูป while ในลิสติ้ง 3-3 เราใช้ while เพื่อวนซ้ำโปรแกรมสามรอบ โดยนับถอยหลังในแต่ละรอบ และหลังจากลูปแล้ว ก็จะพิมพ์ข้อความและจบโปรแกรม

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

โครงสร้างนี้ช่วยขจัดความซับซ้อนของการเขียนโค้ดซ้อนกันหลายชั้นที่จะจำเป็นหากคุณใช้ loop, if, else และ break อีกทั้งยังอ่านเข้าใจได้ชัดเจนกว่า ตราบใดที่เงื่อนไขประเมินค่าเป็น true โค้ดก็จะทำงานต่อไป มิฉะนั้นก็จะออกจากลูปทันที

การวนซ้ำผ่านคอลเลกชันด้วย for

คุณสามารถเลือกใช้โครงสร้าง while เพื่อวนซ้ำผ่านสมาชิกของคอลเลกชัน เช่น อาร์เรย์ได้ ตัวอย่างเช่น ลูปในลิสติ้ง 3-4 จะพิมพ์แต่ละสมาชิกในอาร์เรย์ a

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}

ในที่นี้ โค้ดจะนับขึ้นผ่านสมาชิกต่างๆ ในอาร์เรย์ มันเริ่มที่ดัชนี 0 แล้ววนซ้ำจนกว่าจะถึงดัชนีสุดท้ายในอาร์เรย์ (นั่นคือ เมื่อ index < 5 ไม่เป็น true อีกต่อไป) การรันโค้ดนี้จะพิมพ์ทุกสมาชิกในอาร์เรย์ออกมา:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

ค่าทั้งห้าตัวของอาร์เรย์จะปรากฏในเทอร์มินัลตามที่คาดไว้ แม้ว่า index จะไปถึงค่า 5 ในท้ายที่สุด แต่ลูปก็หยุดทำงานก่อนที่จะพยายามดึงค่าตัวที่หกออกมาจากอาร์เรย์

อย่างไรก็ตาม วิธีการนี้เสี่ยงต่อข้อผิดพลาดได้ง่าย (error-prone) เราอาจทำให้โปรแกรมเกิดการแพนิก (panic) ได้หากค่าดัชนีหรือเงื่อนไขการทดสอบไม่ถูกต้อง ตัวอย่างเช่น หากคุณเปลี่ยนนิยามของอาร์เรย์ a ให้มีสมาชิกสี่ตัวแต่ลืมอัปเดตเงื่อนไขเป็น while index < 4 โค้ดก็จะเกิดการแพนิกทันที นอกจากนี้ยังทำงานช้ากว่าด้วย เพราะคอมไพเลอร์ต้องเพิ่มโค้ดตอนรันไทม์เพื่อตรวจสอบเงื่อนไขว่าดัชนีอยู่ในขอบเขตของอาร์เรย์หรือไม่ในทุกๆ รอบของการวนซ้ำ

เพื่อเป็นทางเลือกที่กระชับกว่า คุณสามารถใช้ลูป for และสั่งให้โค้ดทำงานกับแต่ละรายการในคอลเลกชัน ลูป for มีลักษณะเหมือนโค้ดในลิสติ้ง 3-5

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

เมื่อเรารันโค้ดนี้ เราจะเห็นเอาต์พุตเดียวกับในลิสติ้ง 3-4 ที่สำคัญกว่านั้น ตอนนี้เราได้เพิ่มความปลอดภัยให้กับโค้ดและขจัดโอกาสเกิดบั๊กที่อาจเกิดจากการเข้าถึงเกินจุดสิ้นสุดของอาร์เรย์ หรือการวนซ้ำไม่ครบจนพลาดบางรายการ โค้ดภาษาเครื่อง (machine code) ที่สร้างจากลูป for ยังมีประสิทธิภาพมากกว่าด้วย เพราะไม่จำเป็นต้องเปรียบเทียบดัชนีกับความยาวของอาร์เรย์ในทุกๆ รอบของการวนซ้ำ

การใช้ลูป for ช่วยให้คุณไม่จำเป็นต้องจำไปแก้ไขโค้ดส่วนอื่นหากคุณเปลี่ยนจำนวนค่าในอาร์เรย์ ซึ่งต่างจากวิธีที่ใช้ในลิสติ้ง 3-4

ความปลอดภัยและความกระชับของลูป for ทำให้มันกลายเป็นโครงสร้างลูปที่นิยมใช้งานมากที่สุดใน Rust แม้ในสถานการณ์ที่คุณต้องการรันโค้ดตามจำนวนรอบที่แน่นอน ดังในตัวอย่างการนับถอยหลังที่ใช้ลูป while ในลิสติ้ง 3-3 ชาว Rustacean ส่วนใหญ่ก็จะเลือกใช้ลูป for วิธีทำเช่นนั้นคือใช้ Range ซึ่งไลบรารีมาตรฐานจัดเตรียมไว้ให้ และจะสร้างตัวเลขทั้งหมดตามลำดับ เริ่มจากจำนวนหนึ่งและสิ้นสุดก่อนหน้าอีกจำนวนหนึ่ง

นี่คือลักษณะของการนับถอยหลังหากใช้ลูป for และเมธอดอีกตัวหนึ่งที่เรายังไม่ได้พูดถึง นั่นคือ rev เพื่อกลับลำดับของช่วงข้อมูล:

ชื่อไฟล์: src/main.rs

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

โค้ดนี้ดูดีขึ้นเยอะเลย ใช่ไหมครับ?

สรุป

คุณทำสำเร็จแล้ว! นี่เป็นบทที่มีเนื้อหาใหญ่ทีเดียว คุณได้เรียนรู้เกี่ยวกับตัวแปร, ชนิดข้อมูลสเกลาร์และข้อมูลประกอบ, ฟังก์ชัน, คอมเมนต์, นิพจน์ if และลูป! เพื่อฝึกฝนแนวคิดที่ได้เรียนรู้ในบทนี้ ลองลงมือสร้างโปรแกรมเพื่อทำสิ่งต่อไปนี้ดู:

  • แปลงอุณหภูมิระหว่างฟาเรนไฮต์และเซลเซียส
  • สร้างจำนวนฟีโบนัชชีตัวที่ n
  • พิมพ์เนื้อเพลงคริสต์มาส “The Twelve Days of Christmas” โดยนำประโยชน์จากการทำซ้ำในเพลงมาประยุกต์ใช้

เมื่อคุณพร้อมที่จะไปต่อ เราจะพูดถึงแนวคิดใน Rust ที่_แทบไม่ปรากฏ_ในภาษาโปรแกรมอื่น ซึ่งก็คือระบบสิทธิ์ความเป็นเจ้าของ (ownership)