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

การควบคุมโฟลว์แบบกระชับด้วย if let และ let...else

ไวยากรณ์ if let ช่วยให้เราสามารถรวม if และ let เข้าด้วยกันเพื่อจัดการกับค่าที่ตรงกับแพตเทิร์นเพียงรูปแบบเดียวได้อย่างกระชับ โดยไม่ต้องสนใจกรณีอื่นๆ ที่เหลือ ลองพิจารณาโปรแกรมในลิสติ้ง 6-6 ที่นำค่า Option<u8> ในตัวแปร config_max มาจับคู่กับแพตเทิร์น แต่ต้องการให้โค้ดทำงานเฉพาะในกรณีที่ค่านั้นเป็นวาเรียนต์ Some เท่านั้น

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is configured to be {max}"),
        _ => (),
    }
}

หากค่านั้นเป็น Some เราจะพิมพ์ค่าที่บรรจุอยู่ภายในวาเรียนต์ Some ออกมา โดยการผูกค่านั้นเข้ากับตัวแปร max ในแพตเทิร์น และเราไม่ได้ต้องการทำอะไรกับค่า None เลย แต่เพื่อให้ตรงตามข้อกำหนดของนิพจน์ match ที่ต้องครอบคลุมทุกกรณี เราจึงจำใจต้องเพิ่ม _ => () ต่อท้ายหลังจากจัดการวาเรียนต์แรกไปแล้ว ซึ่งกลายเป็นโค้ดส่วนเกินที่ซ้ำซากและน่ารำคาญ (boilerplate code)

แทนที่จะทำเช่นนั้น เราสามารถเขียนให้สั้นและกระชับขึ้นได้ด้วยการใช้ if let โดยโค้ดด้านล่างนี้จะทำงานเหมือนกับคำสั่ง match ในลิสติ้ง 6-6 ทุกประการ:

fn main() {
    let config_max = Some(3u8);
    if let Some(max) = config_max {
        println!("The maximum is configured to be {max}");
    }
}

ไวยากรณ์ if let จะรับแพตเทิร์นและนิพจน์โดยคั่นด้วยเครื่องหมายเท่ากับ (=) หลักการทำงานของมันเหมือนกับ match ทุกอย่าง โดยนิพจน์ทางขวาจะถูกส่งเข้าไปเปรียบเทียบ และแพตเทิร์นทางซ้ายจะทำหน้าที่เป็นอาร์มแรกของ match ในตัวอย่างนี้ แพตเทิร์นคือ Some(max) และตัวแปร max จะถูกผูกเข้ากับค่าที่อยู่ภายใน Some จากนั้นเราก็สามารถนำ max มาใช้งานภายในบล็อกของ if let ได้ในลักษณะเดียวกับที่เราใช้ max ในอาร์มของ match โดยโค้ดในบล็อก if let จะทำงานก็ต่อเมื่อค่านั้นตรงกับแพตเทิร์นที่กำหนดไว้เท่านั้น

การใช้ if let ช่วยให้พิมพ์โค้ดน้อยลง ย่อหน้าน้อยลง และลดโค้ด boilerplate ลงไปได้มาก อย่างไรก็ดี สิ่งที่ต้องแลกมาคือเราจะสูญเสียการตรวจสอบความครอบคลุมทุกกรณี (exhaustive checking) ที่ match บังคับใช้เพื่อป้องกันไม่ให้เราลืมจัดการกรณีใดกรณีหนึ่งไป การตัดสินใจเลือกระหว่าง match กับ if let จึงขึ้นอยู่กับสถานการณ์และลักษณะงานของคุณ ว่าความกระชับที่ได้มานั้นคุ้มค่ากับการยอมแลกการตรวจสอบความครบถ้วนของกรณีต่างๆ หรือไม่

พูดอีกอย่างหนึ่งก็คือ เราสามารถมองว่า if let เป็นน้ำตาลทางไวยากรณ์ (syntax sugar) ของคำสั่ง match ที่สั่งให้โค้ดทำงานเมื่อค่าตรงกับแพตเทิร์นหนึ่ง แล้วละเว้นค่าอื่นๆ ทั้งหมดที่เหลือ

นอกจากนี้ เรายังสามารถใส่ else คู่กับ if let ได้ด้วย โดยบล็อกโค้ดในส่วนของ else จะเทียบเท่ากับบล็อกโค้ดในกรณี _ ของนิพจน์ match หากเขียนเทียบเคียงกัน ย้อนกลับไปดูนิยามของ enum Coin ในลิสติ้ง 6-4 ที่วาเรียนต์ Quarter มีการเก็บค่า UsState เอาไว้ข้างใน หากเราต้องการนับจำนวนเหรียญทั้งหมดที่ไม่ใช่เหรียญควอเตอร์ ควบคู่ไปกับการขานชื่อรัฐของเหรียญควอเตอร์ที่พบ เราสามารถเขียนด้วยนิพจน์ match ได้ดังนี้:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    match coin {
        Coin::Quarter(state) => println!("State quarter from {state:?}!"),
        _ => count += 1,
    }
}

หรือเราสามารถเขียนด้วยนิพจน์ if let และ else ได้เช่นกัน ดังนี้:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("State quarter from {state:?}!");
    } else {
        count += 1;
    }
}

อยู่บน “เส้นทางราบรื่น” ด้วย let...else

รูปแบบการเขียนที่พบได้บ่อยมากคือ การทำงานคำนวณบางอย่างเมื่อมีค่าอยู่ และส่งค่าดีฟอลต์ (default value) หรือออกจากฟังก์ชันหากไม่มีค่านั้น ต่อเนื่องจากตัวอย่างเหรียญที่เก็บค่า UsState หากเราอยากจะแสดงข้อความหยอกล้อขึ้นอยู่กับว่ารัฐบนเหรียญควอเตอร์นั้นก่อตั้งมานานแค่ไหน เราอาจจะเพิ่มเมธอดบน UsState เพื่อตรวจสอบอายุของรัฐ ดังนี้:

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

จากนั้น เราอาจจะใช้ if let ในการตรวจสอบชนิดของเหรียญ พร้อมทั้งประกาศตัวแปร state ขึ้นมาใช้งานภายในบล็อกเงื่อนไข ดังที่แสดงในลิสติ้ง 6-7

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

โค้ดนี้ทำงานได้ตามต้องการก็จริง แต่เป็นการผลักภาระงานทั้งหมดเข้าไปซ้อนอยู่ลึกข้างในบล็อกของคำสั่ง if let และถ้าหากงานที่ต้องทำมีความซับซ้อนมากยิ่งขึ้น ก็อาจทำให้ไล่อ่านและทำความเข้าใจความสัมพันธ์ของกิ่งเงื่อนไขระดับบนได้ยาก เราสามารถใช้ประโยชน์จากข้อเท็จจริงที่ว่านิพจน์จะส่งคืนค่าออกมา เพื่อดึงค่า state ออกมาจาก if let หรือใช้ return ออกจากฟังก์ชันก่อนกำหนด (return early) ได้ ดังที่แสดงในลิสติ้ง 6-8 (ซึ่งสามารถเขียนด้วย match ในลักษณะเดียวกันได้เช่นกัน)

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let state = if let Coin::Quarter(state) = coin {
        state
    } else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

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

เพื่อให้การเขียนรูปแบบยอดนิยมนี้มีความสวยงามและเป็นธรรมชาติยิ่งขึ้น Rust จึงมีไวยากรณ์ let...else โดย let...else จะรับแพตเทิร์นไว้ทางฝั่งซ้าย และรับนิพจน์ไว้ทางฝั่งขวา คล้ายกับ if let มาก แต่จะไม่มีกิ่ง if มีเพียงแค่กิ่ง else เท่านั้น หากแพตเทิร์นจับคู่สำเร็จ มันจะผูกค่าจากแพตเทิร์นเข้ามาไว้ในขอบเขตภายนอก (outer scope) ทันที แต่ถ้าแพตเทิร์น_ไม่_ตรงกัน โปรแกรมจะวิ่งเข้าไปทำงานในส่วนของ else ซึ่งบังคับว่าจะต้องมีคำสั่ง return ออกจากฟังก์ชัน (หรือคำสั่งอื่นที่ทำให้หลุดจากโฟลว์การทำงาน)

ในลิสติ้ง 6-9 คุณจะเห็นว่าโค้ดจากลิสติ้ง 6-8 จะดูสะอาดตาขึ้นเพียงใดเมื่อเปลี่ยนมาใช้ let...else แทน if let

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

สังเกตได้ว่า โฟลว์การทำงานหลักของฟังก์ชันจะยังคงอยู่บน “เส้นทางปกติที่ราบรื่น” (happy path) เสมอ โดยไม่ต้องแยกเป็นสองกิ่งที่ควบคุมการทำงานแตกต่างกันอย่างสิ้นเชิงเหมือนกับที่ if let เคยทำ

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

สรุป

จนถึงตอนนี้ เราได้เรียนรู้วิธีการใช้ enum เพื่อสร้างชนิดข้อมูลที่กำหนดขึ้นเอง ซึ่งสามารถเลือกเป็นค่าใดค่าหนึ่งจากกลุ่มของค่าที่แจกแจงไว้ได้อย่างชัดเจน นอกจากนี้ เรายังได้เห็นว่าชนิดข้อมูล Option<T> ในไลบรารีมาตรฐานช่วยให้เราใช้ประโยชน์จากระบบชนิดข้อมูลในการป้องกันข้อผิดพลาดได้อย่างไร และเมื่อค่าของ enum มีข้อมูลบรรจุอยู่ภายใน เราก็สามารถใช้ match หรือ if let ในการดึงข้อมูลเหล่านั้นออกมาใช้งานได้ ขึ้นอยู่กับว่าเราต้องการจัดการกับกรณีต่างๆ มากน้อยเพียงใด

ตอนนี้โปรแกรม Rust ของคุณสามารถถ่ายทอดแนวคิดต่างๆ ในโดเมนของงานได้อย่างสมบูรณ์ผ่าน struct และ enum การสร้างชนิดข้อมูลที่กำหนดขึ้นเองเพื่อใช้ใน API ยังช่วยรับประกันความปลอดภัยของชนิดข้อมูล (type safety) โดยคอมไพเลอร์จะคอยตรวจสอบอย่างเข้มงวดว่า ฟังก์ชันต่างๆ จะได้รับเฉพาะค่าที่มีชนิดข้อมูลตรงตามที่ฟังก์ชันนั้นๆ คาดหวังไว้เท่านั้น

และเพื่อที่เราจะสามารถออกแบบและส่งมอบ API ที่จัดโครงสร้างอย่างเป็นระเบียบ เรียบง่ายต่อการใช้งาน และเปิดเผยให้ผู้ใช้มองเห็นเฉพาะสิ่งที่จำเป็นต้องใช้จริงๆ ในบทถัดไปเราจะมาเรียนรู้เรื่องมอดูล (modules) ของภาษารัสต์กัน