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

ข้อผิดพลาดที่กู้คืนได้ด้วย Result

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

จากหัวข้อ “การจัดการความล้มเหลวที่อาจเกิดขึ้นด้วย Result” ในบทที่ 2 เราได้ทราบกันแล้วว่า enum Result ถูกนิยามให้มีสองวาเรียนต์ คือ Ok และ Err ดังนี้:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T และ E คือพารามิเตอร์ประเภทข้อมูลแบบเจเนอริก (generic type parameters) ซึ่งเราจะอธิบายรายละเอียดของเจเนอริกเพิ่มเติมในบทที่ 10 แต่สิ่งที่คุณควรรู้ในตอนนี้คือ T เป็นตัวแทนของประเภทของค่าที่จะส่งกลับเมื่อการทำงานสำเร็จภายในวาเรียนต์ Ok ส่วน E เป็นตัวแทนของประเภทของข้อผิดพลาดที่จะส่งกลับเมื่อการทำงานล้มเหลวภายในวาเรียนต์ Err และด้วยความที่ Result ใช้พารามิเตอร์ประเภทข้อมูลแบบเจเนอริกเหล่านี้ เราจึงสามารถนำประเภท Result และฟังก์ชันต่างๆ ที่นิยามไว้สำหรับมันไปประยุกต์ใช้ได้ในหลากหลายสถานการณ์ ซึ่งค่าที่ส่งกลับเมื่อสำเร็จหรือล้มเหลวอาจแตกต่างกันไปในแต่ละฟังก์ชัน

มาลองเรียกใช้ฟังก์ชันที่คืนค่าเป็น Result เพราะฟังก์ชันนั้นมีโอกาสล้มเหลวได้ ในลิสติ้ง 9-3 เราจะพยายามเปิดไฟล์ขึ้นมาไฟล์หนึ่ง

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");
}

ประเภทข้อมูลที่ส่งกลับจาก File::open คือ Result<T, E> โดยการอิมพลีเมนต์ของ File::open ได้ระบุพารามิเตอร์เจเนอริก T ให้เป็นประเภทข้อมูลเมื่อสำเร็จ นั่นคือ std::fs::File ซึ่งเป็นตัวจัดการไฟล์ (file handle) ส่วนประเภท E ที่ใช้สำหรับค่าข้อผิดพลาดคือ std::io::Error การคืนค่าประเภทนี้หมายความว่าการเรียก File::open อาจจะสำเร็จและส่งแฮนเดิลไฟล์ที่เราสามารถอ่านหรือเขียนข้อมูลกลับมา หรือการเรียกฟังก์ชันนี้อาจจะล้มเหลวก็ได้ เช่น ไฟล์นั้นอาจไม่มีอยู่จริง หรือเราอาจไม่มีสิทธิ์เข้าถึงไฟล์ดังกล่าว ดังนั้นฟังก์ชัน File::open จึงต้องมีวิธีแจ้งให้เราทราบว่าการทำงานสำเร็จหรือล้มเหลว พร้อมกับส่งคืนแฮนเดิลไฟล์หรือข้อมูลข้อผิดพลาดมาให้เรา ซึ่ง enum Result ถูกออกแบบมาเพื่อสื่อสารสิ่งเหล่านี้โดยตรง

ในกรณีที่ File::open ทำงานสำเร็จ ค่าในตัวแปร greeting_file_result จะเป็นอินสแตนซ์ของ Ok ที่บรรจุแฮนเดิลไฟล์ไว้ข้างใน ส่วนในกรณีที่ล้มเหลว ค่าใน greeting_file_result จะเป็นอินสแตนซ์ของ Err ที่บรรจุข้อมูลเพิ่มเติมเกี่ยวกับสาเหตุของข้อผิดพลาดที่เกิดขึ้น

เราจำเป็นต้องเขียนโค้ดต่อยอดจากลิสติ้ง 9-3 เพื่อจัดการให้เหมาะสมตามค่าที่ File::open ส่งกลับมา ลิสติ้ง 9-4 แสดงวิธีหนึ่งในการจัดการกับ Result โดยใช้เครื่องมือพื้นฐานอย่างนิพจน์ match ที่เราได้เรียนรู้กันไปแล้วในบทที่ 6

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {error:?}"),
    };
}

สังเกตว่าเช่นเดียวกับ enum Option ตัว enum Result และวาเรียนต์ต่างๆ ของมันถูกดึงเข้าสู่ขอบเขต (scope) โดยอัตโนมัติผ่าน prelude แล้ว ดังนั้นเราจึงไม่จำเป็นต้องใส่คำนำหน้า Result:: ให้กับวาเรียนต์ Ok และ Err ภายในแขนของ match

เมื่อผลลัพธ์เป็น Ok โค้ดนี้จะดึงค่า file ที่อยู่ภายในวาเรียนต์ Ok ออกมา จากนั้นเราจึงกำหนดค่าแฮนเดิลไฟล์นั้นให้กับตัวแปร greeting_file และหลังจากจบนิพจน์ match เราก็สามารถนำแฮนเดิลไฟล์นั้นไปใช้ในการอ่านหรือเขียนข้อมูลต่อไปได้

ส่วนอีกแขนหนึ่งของ match จะทำหน้าที่จัดการกรณีที่เราได้ค่า Err จาก File::open ในตัวอย่างนี้ เราเลือกที่จะเรียกใช้แมโคร panic! หากไม่มีไฟล์ชื่อ hello.txt อยู่ในไดเรกทอรีปัจจุบันของเราแล้วเรารันโค้ดนี้ เราจะเห็นผลลัพธ์ต่อไปนี้จากแมโคร panic!:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/error-handling`

thread 'main' (6018048) panicked at src/main.rs:8:23:
Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

เช่นเคย ข้อความผลลัพธ์นี้บอกเราได้อย่างชัดเจนว่าเกิดข้อผิดพลาดอะไรขึ้น

การจับคู่กับข้อผิดพลาดที่แตกต่างกัน

โค้ดในลิสติ้ง 9-4 จะสั่ง panic! เสมอไม่ว่า File::open จะล้มเหลวด้วยสาเหตุใดก็ตาม อย่างไรก็ดี เราอาจต้องการรับมือกับสาเหตุความล้มเหลวที่ต่างกันด้วยวิธีที่แตกต่างกันออกไป: หาก File::open ล้มเหลวเพราะยังไม่มีไฟล์นั้นอยู่ เราต้องการสร้างไฟล์ขึ้นมาใหม่แล้วส่งคืนแฮนเดิลของไฟล์ใหม่นั้น แต่ถ้า File::open ล้มเหลวด้วยเหตุผลอื่น เช่น เราไม่มีสิทธิ์ในการเปิดไฟล์ เราก็ยังคงต้องการให้โค้ดเกิด panic! เหมือนกับในลิสติ้ง 9-4 ในกรณีนี้ เราสามารถเพิ่มนิพจน์ match ซ้อนอยู่ข้างในได้ ดังที่แสดงในลิสติ้ง 9-5

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {e:?}"),
            },
            _ => {
                panic!("Problem opening the file: {error:?}");
            }
        },
    };
}

ประเภทของค่าที่ File::open ส่งกลับมาภายในวาเรียนต์ Err คือ io::Error ซึ่งเป็น struct ที่ไลบรารีมาตรฐานจัดเตรียมไว้ให้ โดย struct นี้มีเมธอดชื่อ kind ที่เราสามารถเรียกเพื่อดูค่า io::ErrorKind ได้ enum io::ErrorKind ของไลบรารีมาตรฐานมีวาเรียนต์ต่างๆ ที่เป็นตัวแทนของประเภทข้อผิดพลาดหลากหลายแบบซึ่งอาจเกิดจากการดำเนินการของ io โดยวาเรียนต์ที่เราสนใจใช้งานคือ ErrorKind::NotFound ซึ่งบ่งบอกว่าไฟล์ที่เราพยายามเปิดนั้นยังไม่มีอยู่ ดังนั้นเราจึงจับคู่กับ greeting_file_result และยังมีนิพจน์ match ชั้นในที่จับคู่กับ error.kind() อีกด้วย

เงื่อนไขที่เราต้องการตรวจสอบใน match ชั้นในคือ ค่าที่ส่งกลับมาจาก error.kind() เป็นวาเรียนต์ NotFound ของ enum ErrorKind หรือไม่ หากใช่ เราจะพยายามสร้างไฟล์ขึ้นมาใหม่ด้วย File::create ทว่าเนื่องจาก File::create เองก็มีโอกาสทำงานล้มเหลวได้เช่นกัน เราจึงต้องมีแขนที่สองในนิพจน์ match ชั้นในด้วย เพื่อให้เมื่อสร้างไฟล์ไม่สำเร็จ จะมีการพิมพ์ข้อความแจ้งข้อผิดพลาดอีกแบบหนึ่งออกมา ส่วนแขนที่สองของ match ชั้นนอกยังคงเหมือนเดิม ทำให้โปรแกรมจะเกิด panic เมื่อเจอกับข้อผิดพลาดอื่นๆ นอกเหนือจากกรณีไฟล์สูญหาย

ทางเลือกอื่นนอกจากการใช้ match กับ Result<T, E>

นั่นมีการใช้ match ซ้อนกันเยอะมาก! แม้นิพจน์ match จะมีประโยชน์อย่างยิ่ง แต่มันก็ค่อนข้างยืดยาวและเป็นเครื่องมือระดับพื้นฐาน ในบทที่ 13 คุณจะได้เรียนรู้เกี่ยวกับโคลเชอร์ (closure) ซึ่งถูกนำไปใช้ร่วมกับเมธอดตัวช่วยต่างๆ บน Result<T, E> โดยเมธอดเหล่านี้จะช่วยให้คุณจัดการกับค่า Result<T, E> ในโค้ดได้อย่างกระชับและคลีนกว่าการใช้ match มาก

ตัวอย่างเช่น นี่คืออีกวิธีในการเขียนตรรกะเดียวกันกับลิสติ้ง 9-5 โดยเปลี่ยนมาใช้โคลเชอร์และเมธอด unwrap_or_else:

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {error:?}");
            })
        } else {
            panic!("Problem opening the file: {error:?}");
        }
    });
}

แม้ว่าโค้ดนี้จะมีพฤติกรรมการทำงานเหมือนกับลิสติ้ง 9-5 ทุกประการ แต่มันกลับไม่มีนิพจน์ match ซ้อนกันเลยแม้แต่น้อย และอ่านทำความเข้าใจได้ง่ายกว่ามาก คุณสามารถย้อนกลับมาดูตัวอย่างนี้อีกครั้งหลังจากอ่านบทที่ 13 จบแล้ว และลองค้นหาเมธอด unwrap_or_else ในเอกสารของไลบรารีมาตรฐานดู ซึ่งยังมีเมธอดทำนองนี้อีกมากที่จะช่วยให้คุณไม่ต้องเขียน match ซ้อนกันจนรกตาเวลาจัดการกับข้อผิดพลาด

ทางลัดสำหรับแพนิกเมื่อเกิดข้อผิดพลาด

การใช้ match นั้นทำงานได้ดีในระดับหนึ่ง แต่มันอาจจะดูยืดยาวและไม่ได้สื่อเจตนารมณ์ของโค้ดได้ชัดเจนเสมอไป ประเภทข้อมูล Result<T, E> จึงมีเมธอดตัวช่วยมากมายสำหรับทำงานเฉพาะเจาะจงต่างๆ โดยเมธอด unwrap เป็นเมธอดทางลัดที่อิมพลีเมนต์การทำงานเหมือนกับนิพจน์ match ในลิสติ้ง 9-4 ทุกประการ: ถ้าค่า Result เป็นวาเรียนต์ Ok ตัว unwrap จะส่งคืนค่าที่อยู่ข้างใน Ok ออกมา แต่ถ้าค่า Result เป็นวาเรียนต์ Err ตัว unwrap จะเรียกแมโคร panic! ให้เราโดยอัตโนมัติ นี่คือตัวอย่างการใช้งาน unwrap:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

หากเรารันโค้ดนี้โดยไม่มีไฟล์ hello.txt เราจะเห็นข้อความแสดงข้อผิดพลาดจากการเรียก panic! ที่เมธอด unwrap ทำขึ้น:

thread 'main' panicked at src/main.rs:4:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }

ในทำนองเดียวกัน เมธอด expect ก็ทำงานคล้ายกันแต่เปิดโอกาสให้เรากำหนดข้อความแสดงข้อผิดพลาดของ panic! เองได้ การเลือกใช้ expect แทน unwrap พร้อมกับระบุข้อความแจ้งข้อผิดพลาดที่มีความหมาย จะช่วยสื่อเจตนาของโค้ดและทำให้การติดตามหาต้นตอของ panic ทำได้ง่ายขึ้นมาก โดยไวยากรณ์ของ expect มีหน้าตาดังนี้:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

เราใช้งาน expect ในลักษณะเดียวกับ unwrap นั่นคือส่งคืนแฮนเดิลไฟล์ออกมาเมื่อสำเร็จ หรือเรียกแมโคร panic! เมื่อเกิดข้อผิดพลาด โดยข้อความแจ้งข้อผิดพลาดที่ expect ใช้ส่งให้ panic! จะเป็นข้อความจากพารามิเตอร์ที่เราส่งให้ expect แทนที่จะเป็นข้อความเริ่มต้นของ unwrap ดังตัวอย่างผลลัพธ์นี้:

thread 'main' panicked at src/main.rs:5:10:
hello.txt should be included in this project: Os { code: 2, kind: NotFound, message: "No such file or directory" }

ในโค้ดระดับโปรดักชันที่ได้มาตรฐาน ชาว Rustacean ส่วนใหญ่จะนิยมใช้ expect มากกว่า unwrap พร้อมทั้งให้บริบทเพิ่มเติมว่าเหตุใดการทำงานนี้จึงคาดว่าจะสำเร็จเสมอ ด้วยวิธีนี้ หากสมมติฐานที่คุณคิดไว้เกิดผิดพลาดขึ้นมาในภายหลัง คุณก็จะมีข้อมูลที่เพียงพอสำหรับใช้ในการดีบักได้อย่างรวดเร็ว

การส่งต่อข้อผิดพลาด

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

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

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt");

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}
}

ฟังก์ชันนี้สามารถเขียนให้กระชับและสั้นลงกว่านี้ได้มาก แต่เราจะเริ่มเขียนแบบตรงไปตรงมาด้วยตัวเองก่อนเพื่อศึกษาการทำงานของการจัดการข้อผิดพลาด แล้วในตอนท้ายเราจะแสดงวิธีที่สั้นกว่าให้ดู มาเริ่มพิจารณาจากประเภทข้อมูลที่ส่งกลับของฟังก์ชันนี้ก่อน นั่นคือ Result<String, io::Error> ซึ่งหมายความว่าฟังก์ชันนี้จะส่งคืนค่าประเภท Result<T, E> โดยระบุพารามิเตอร์เจเนอริก T ให้เป็นประเภทรูปธรรม String และระบุพารามิเตอร์เจเนอริก E ให้เป็นประเภทรูปธรรม io::Error

หากฟังก์ชันนี้ทำงานสำเร็จโดยไม่ติดขัด โค้ดที่เรียกใช้ฟังก์ชันจะได้รับค่า Ok ที่บรรจุข้อมูล String ซึ่งก็คือ username ที่อ่านได้จากไฟล์ แต่หากฟังก์ชันนี้เจอปัญหาใดๆ โค้ดที่เรียกใช้จะได้รับค่า Err ที่บรรจุอินสแตนซ์ของ io::Error พร้อมรายละเอียดเกี่ยวกับปัญหาที่เกิดขึ้น สาเหตุที่เราเลือก io::Error เป็นประเภทข้อผิดพลาดที่ส่งกลับของฟังก์ชันนี้ ก็เพราะมันเป็นประเภทของข้อผิดพลาดที่ส่งกลับจากการทำงานทั้งสองอย่างภายในเนื้อหาของฟังก์ชันนี้ที่มีโอกาสล้มเหลว ได้แก่ ฟังก์ชัน File::open และเมธอด read_to_string

เนื้อหาของฟังก์ชันเริ่มต้นด้วยการเรียกใช้ฟังก์ชัน File::open จากนั้นเราจัดการกับค่า Result ด้วยนิพจน์ match ในลักษณะเดียวกับลิสติ้ง 9-4 หาก File::open ทำงานสำเร็จ แฮนเดิลไฟล์ในตัวแปรแพตเทิร์น file จะถูกนำมากำหนดให้กับตัวแปรแบบเปลี่ยนแปลงได้ username_file แล้วฟังก์ชันจะทำงานบรรทัดต่อไป แต่ในกรณี Err แทนที่เราจะสั่ง panic! เราจะใช้คีย์เวิร์ด return เพื่อส่งคืนค่าและออกจากฟังก์ชันทันที (early return) พร้อมกับส่งค่าข้อผิดพลาดจาก File::open ซึ่งอยู่ในตัวแปรแพตเทิร์น e กลับไปยังโค้ดต้นทางที่เรียกใช้ในฐานะค่าข้อผิดพลาดของฟังก์ชันนี้

หลังจากนั้น หากเราได้แฮนเดิลไฟล์มาเก็บไว้ใน username_file แล้ว ฟังก์ชันจะสร้างตัวแปร username ขึ้นมาเป็น String ใหม่ แล้วเรียกเมธอด read_to_string บนแฮนเดิลไฟล์ใน username_file เพื่ออ่านเนื้อหาทั้งหมดในไฟล์เข้ามาเก็บไว้ใน username ซึ่งเมธอด read_to_string นี้ก็คืนค่าเป็น Result เช่นกันเนื่องจากมันมีโอกาสอ่านล้มเหลวได้แม้ว่าจะเปิดไฟล์ผ่าน File::open สำเร็จก็ตาม เราจึงต้องมี match อีกตัวเพื่อจัดการกับ Result นั้น: หาก read_to_string ทำงานสำเร็จ ฟังก์ชันของเราก็จะถือว่าทำงานสำเร็จตามไปด้วย และจะส่งคืนชื่อผู้ใช้ที่อยู่ใน username ออกมาโดยห่อหุ้มไว้ใน Ok แต่ถ้า read_to_string ล้มเหลว เราก็จะส่งคืนค่าข้อผิดพลาดกลับไปในลักษณะเดียวกับที่เราเคยทำใน match ของ File::open เพียงแต่ในกรณีนี้เราไม่จำเป็นต้องใส่คีย์เวิร์ด return อย่างโจ่งแจ้ง เพราะมันเป็นนิพจน์สุดท้ายของฟังก์ชันอยู่แล้ว

โค้ดต้นทางที่เรียกใช้ฟังก์ชันนี้จะได้รับค่าไม่ว่าจะเป็น Ok ที่บรรจุชื่อผู้ใช้ หรือ Err ที่บรรจุ io::Error ซึ่งขึ้นอยู่กับโค้ดต้นทางเองว่าจะตัดสินใจจัดการกับค่านั้นอย่างไร เช่น หากได้ค่า Err มันอาจจะเลือกเรียก panic! เพื่อหยุดโปรแกรม, หันไปใช้ชื่อผู้ใช้เริ่มต้น (default), หรือลองค้นหาชื่อผู้ใช้จากแหล่งอื่นแทนไฟล์ เป็นต้น เราไม่มีข้อมูลเพียงพอที่จะรู้ว่าโค้ดต้นทางต้องการจะทำอะไรต่อ เราจึงเลือกที่จะส่งต่อข้อมูลความสำเร็จหรือข้อผิดพลาดทั้งหมดกลับขึ้นไปให้โค้ดต้นทางเป็นผู้พิจารณาเอง

รูปแบบการส่งต่อข้อผิดพลาด (propagating errors) เช่นนี้พบได้บ่อยมากในการเขียน Rust จนกระทั่ง Rust มีตัวดำเนินการเครื่องหมายคำถาม (question mark operator) ? เพื่อช่วยให้การเขียนโค้ดลักษณะนี้ทำได้ง่ายและสะดวกขึ้นอย่างมาก

ทางลัดของตัวดำเนินการ ?

ลิสติ้ง 9-7 แสดงการอิมพลีเมนต์ของ read_username_from_file ที่มีฟังก์ชันการทำงานเหมือนกับในลิสติ้ง 9-6 แต่การอิมพลีเมนต์นี้ใช้ตัวดำเนินการ ?

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}
}

การวางเครื่องหมาย ? ไว้ต่อท้ายค่า Result ถูกกำหนดให้ทำงานแทบจะเหมือนกับนิพจน์ match ที่เราเขียนเพื่อจัดการกับ Result ในลิสติ้ง 9-6: ถ้าค่าของ Result เป็น Ok ค่าที่อยู่ภายใน Ok จะถูกดึงออกมาเป็นผลลัพธ์ของนิพจน์นั้นแล้วโปรแกรมจะทำงานต่อไป แต่ถ้าค่าเป็น Err วาเรียนต์ Err นั้นจะถูกส่งคืนออกจากฟังก์ชันทั้งหมดทันทีประหนึ่งว่าเราใช้คีย์เวิร์ด return เพื่อให้ค่าข้อผิดพลาดถูกส่งต่อไปยังโค้ดต้นทางที่เรียกใช้

อย่างไรก็ตาม มีความแตกต่างประการหนึ่งระหว่างสิ่งที่นิพจน์ match ในลิสติ้ง 9-6 ทำกับสิ่งที่ตัวดำเนินการ ? ทำ: ค่าข้อผิดพลาดที่ถูกประมวลผลด้วยตัวดำเนินการ ? จะถูกส่งผ่านฟังก์ชัน from ซึ่งนิยามอยู่ในเทรต From ของไลบรารีมาตรฐาน และใช้สำหรับแปลงค่าจากประเภทหนึ่งไปเป็นอีกประเภทหนึ่ง เมื่อตัวดำเนินการ ? เรียกฟังก์ชัน from ประเภทของข้อผิดพลาดที่ได้รับมาจะถูกแปลงเป็นประเภทข้อผิดพลาดที่ระบุไว้ในประเภทส่งกลับของฟังก์ชันปัจจุบันโดยอัตโนมัติ ซึ่งมีประโยชน์มากเมื่อฟังก์ชันหนึ่งต้องการส่งคืนประเภทข้อผิดพลาดเพียงประเภทเดียวเพื่อเป็นตัวแทนของความล้มเหลวทุกรูปแบบ แม้ว่าจุดต่างๆ ภายในฟังก์ชันจะล้มเหลวด้วยสาเหตุที่แตกต่างกันอย่างสิ้นเชิงก็ตาม

ตัวอย่างเช่น เราสามารถแก้ฟังก์ชัน read_username_from_file ในลิสติ้ง 9-7 ให้ส่งคืนประเภทข้อผิดพลาดที่เรากำหนดขึ้นเองชื่อ OurError ได้ และหากเรานิยาม impl From<io::Error> for OurError เพื่อแปลง io::Error ไปเป็น OurError แล้วล่ะก็ ตัวดำเนินการ ? ภายในฟังก์ชัน read_username_from_file จะเรียกใช้ from และแปลงประเภทข้อผิดพลาดให้อัตโนมัติ โดยที่เราไม่ต้องเขียนโค้ดแปลงค่าเพิ่มเติมในฟังก์ชันเลยแม้แต่บรรทัดเดียว

ในบริบทของลิสติ้ง 9-7 เครื่องหมาย ? ที่ต่อท้ายการเรียก File::open จะส่งคืนค่าที่อยู่ภายใน Ok ออกมาเก็บไว้ในตัวแปร username_file แต่หากเกิดข้อผิดพลาดขึ้น ตัวดำเนินการ ? จะออกจากฟังก์ชันทันทีและส่งค่า Err กลับไปยังโค้ดที่เรียกใช้ และในทำนองเดียวกัน เครื่องหมาย ? ที่ต่อท้ายการเรียก read_to_string ก็ทำงานเช่นนี้เช่นกัน

ตัวดำเนินการ ? ช่วยกำจัดโค้ดพิมพ์ซ้ำซาก (boilerplate) ออกไปได้มากมาย และทำให้การเขียนฟังก์ชันนี้ดูเรียบง่ายขึ้นมาก ยิ่งไปกว่านั้น เรายังสามารถย่อโค้ดนี้ให้สั้นลงได้อีกโดยการเรียกเมธอดเชื่อมต่อ (chaining) ต่อท้าย ? ได้ทันที ดังแสดงในลิสติ้ง 9-8

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("hello.txt")?.read_to_string(&mut username)?;

    Ok(username)
}
}

เราได้ย้ายคำสั่งสร้าง String ใหม่ในตัวแปร username ไปไว้ที่บรรทัดแรกของฟังก์ชัน ซึ่งการทำงานส่วนนี้ยังคงเหมือนเดิม แต่แทนที่จะสร้างตัวแปร username_file ขึ้นมาพักไว้ เราเชื่อมการเรียกเมธอด read_to_string ต่อเข้ากับผลลัพธ์ของ File::open("hello.txt")? โดยตรง และเรายังคงใส่ ? ไว้ที่ท้ายคำสั่งเรียก read_to_string พร้อมทั้งยังคงส่งคืนค่า Ok ที่บรรจุ username ออกมาเมื่อทั้ง File::open และ read_to_string ทำงานสำเร็จ ซึ่งการทำงานทั้งหมดก็เหมือนกับในลิสติ้ง 9-6 และลิสติ้ง 9-7 ทุกประการ เพียงแต่นี่เป็นวิธีเขียนที่กระชับและสะดวกสบาย (ergonomic) กว่ามาก

และในลิสติ้ง 9-9 เรายังสามารถทำให้โค้ดสั้นลงกว่านี้ได้อีกโดยใช้ฟังก์ชัน fs::read_to_string

#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}
}

การอ่านข้อมูลจากไฟล์เข้ามาเก็บไว้ในสตริงเป็นงานที่พบได้บ่อยมาก ไลบรารีมาตรฐานจึงจัดเตรียมฟังก์ชันที่แสนสะดวกอย่าง fs::read_to_string มาให้ ซึ่งจะช่วยเปิดไฟล์, สร้าง String ใหม่, อ่านเนื้อหาในไฟล์ใส่ลงใน String นั้น แล้วส่งคืนออกมาให้ทันที แน่นอนว่าการใช้ fs::read_to_string ตั้งแต่แรกคงไม่เปิดโอกาสให้เราได้อธิบายกลไกการจัดการข้อผิดพลาดอย่างละเอียด เราจึงเริ่มต้นด้วยวิธีที่ยาวกว่าก่อน

ใช้ตัวดำเนินการ ? ได้ที่ไหน

ตัวดำเนินการ ? สามารถใช้งานได้เฉพาะภายในฟังก์ชันที่มีประเภทการส่งกลับ (return type) เข้ากันได้กับค่าที่นำ ? ไปต่อท้ายเท่านั้น สาเหตุเพราะตัวดำเนินการ ? ถูกนิยามให้ทำการส่งคืนค่าและออกจากฟังก์ชันทันที (early return) ในลักษณะเดียวกับนิพจน์ match ในลิสติ้ง 9-6 ซึ่งในลิสติ้ง 9-6 นั้น ตัว match จัดการกับค่า Result และแขนที่คืนค่าออกมาก่อนจะส่งคืนค่า Err(e) ออกมา ดังนั้นประเภทการส่งกลับของฟังก์ชันจึงต้องเป็น Result เพื่อให้เข้ากันได้กับคำสั่ง return นี้

ในลิสติ้ง 9-10 มาดูข้อผิดพลาดที่จะเกิดขึ้นหากเรานำตัวดำเนินการ ? ไปใช้ในฟังก์ชัน main ที่มีประเภทการส่งกลับไม่เข้ากันกับค่าที่เรานำ ? ไปใช้ด้วย:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")?;
}

โค้ดนี้พยายามเปิดไฟล์ซึ่งอาจล้มเหลวได้ ตัวดำเนินการ ? ถูกวางไว้ต่อท้ายค่า Result ที่ได้จาก File::open แต่ฟังก์ชัน main นี้กลับมีประเภทการส่งกลับเป็น () ไม่ใช่ Result เมื่อเราคอมไพล์โค้ดนี้ จึงได้รับข้อความแสดงข้อผิดพลาดดังนี้:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:4:48
  |
3 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
4 |     let greeting_file = File::open("hello.txt")?;
  |                                                ^ cannot use the `?` operator in a function that returns `()`
  |
help: consider adding return type
  |
3 ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
4 |     let greeting_file = File::open("hello.txt")?;
5 +     Ok(())
  |

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

ข้อผิดพลาดนี้ชี้แจงอย่างชัดเจนว่า เราได้รับอนุญาตให้ใช้ตัวดำเนินการ ? ได้เฉพาะในฟังก์ชันที่ส่งคืนค่าประเภท Result, Option หรือประเภทอื่นที่อิมพลีเมนต์ FromResidual เท่านั้น

ในการแก้ไขข้อผิดพลาดนี้ คุณมีทางเลือกอยู่สองทาง ทางเลือกแรกคือ เปลี่ยนประเภทการส่งกลับของฟังก์ชันให้เข้ากันได้กับค่าที่คุณกำลังใช้ตัวดำเนินการ ? อยู่ (ตราบใดที่ไม่มีข้อจำกัดอื่นห้ามไว้) ส่วนอีกทางเลือกหนึ่งคือ ใช้ match หรือใช้เมธอดตัวช่วยของ Result<T, E> เพื่อจัดการกับค่า Result<T, E> นั้นตามความเหมาะสม

ข้อความแสดงข้อผิดพลาดยังระบุด้วยว่า เราสามารถใช้ ? ร่วมกับค่าประเภท Option<T> ได้เช่นกัน และเช่นเดียวกับการใช้ ? บน Result คุณจะสามารถใช้ ? บน Option ได้เฉพาะในฟังก์ชันที่ส่งคืนค่าเป็น Option เท่านั้น โดยพฤติกรรมของตัวดำเนินการ ? เมื่อเรียกใช้บน Option<T> จะคล้ายคลึงกับพฤติกรรมบน Result<T, E> มาก: หากค่านั้นเป็น None ตัวฟังก์ชันจะส่งคืน None ออกไปทันที ณ จุดนั้น แต่หากค่านั้นเป็น Some ค่าที่อยู่ภายใน Some จะถูกดึงออกมาเป็นผลลัพธ์ของนิพจน์ และฟังก์ชันจะทำงานบรรทัดถัดไปต่อ ลิสติ้ง 9-11 แสดงตัวอย่างของฟังก์ชันที่ค้นหาตัวอักษรสุดท้ายของบรรทัดแรกในข้อความที่กำหนด:

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        last_char_of_first_line("Hello, world\nHow are you today?"),
        Some('d')
    );

    assert_eq!(last_char_of_first_line(""), None);
    assert_eq!(last_char_of_first_line("\nhi"), None);
}

ฟังก์ชันนี้ส่งคืนค่าเป็น Option<char> เพราะมีความเป็นไปได้ว่าอาจมีตัวอักษรอยู่ หรืออาจไม่มีตัวอักษรใดๆ อยู่เลยก็ได้ โค้ดนี้รับอาร์กิวเมนต์เป็นสตริงสไลซ์ text แล้วเรียกเมธอด lines ซึ่งจะส่งคืนตัววนซ้ำ (iterator) บนแต่ละบรรทัดของสตริง และเนื่องจากฟังก์ชันนี้ต้องการตรวจสอบเฉพาะบรรทัดแรก มันจึงเรียกเมธอด next บน iterator เพื่อดึงค่าบรรทัดแรกออกมา หาก text เป็นสตริงว่าง การเรียก next จะส่งคืน None ซึ่งในกรณีนี้เครื่องหมาย ? จะหยุดการทำงานและส่งคืน None ออกจากฟังก์ชัน last_char_of_first_line ทันที แต่ถ้า text ไม่ใช่สตริงว่าง next จะส่งคืนค่า Some ที่บรรจุสตริงสไลซ์ของบรรทัดแรกไว้

จากนั้น ? จะดึงสตริงสไลซ์นั้นออกมา และเราเรียก chars บนสตริงสไลซ์ดังกล่าวเพื่อรับ iterator ของตัวอักษรในบรรทัดนั้น และเนื่องจากเราสนใจตัวอักษรตัวสุดท้ายของบรรทัดแรก เราจึงเรียก last เพื่อส่งคืนไอเท็มตัวสุดท้ายจาก iterator ซึ่งผลลัพธ์นี้ก็เป็น Option เช่นกัน เพราะมีความเป็นไปได้ที่บรรทัดแรกจะเป็นบรรทัดว่าง เช่น กรณีที่ text เริ่มต้นด้วยการขึ้นบรรทัดใหม่แต่มีตัวอักษรในบรรทัดถัดไปอย่างใน "\nhi" แต่ถ้ามีตัวอักษรตัวสุดท้ายในบรรทัดแรกจริง มันก็จะถูกส่งคืนออกมาในวาเรียนต์ Some ตัวดำเนินการ ? ที่อยู่ตรงกลางช่วยให้เราเขียนตรรกะนี้ได้อย่างกระชับจนสามารถอิมพลีเมนต์ทั้งฟังก์ชันได้จบในบรรทัดเดียว หากเราไม่สามารถใช้ ? กับ Option ได้ เราก็คงต้องเขียนตรรกะนี้ด้วยการเรียกเมธอดซ้อนกันหลายขั้นหรือเขียนนิพจน์ match ยืดยาวแทน

โปรดทราบว่า คุณสามารถใช้ตัวดำเนินการ ? กับ Result ได้ในฟังก์ชันที่ส่งคืน Result และสามารถใช้ ? กับ Option ได้ในฟังก์ชันที่ส่งคืน Option แต่คุณไม่สามารถนำมาใช้ปะปนข้ามชนิดกันได้ ตัวดำเนินการ ? จะไม่แปลง Result เป็น Option หรือในทางกลับกันให้โดยอัตโนมัติ ในกรณีที่คุณต้องการแปลงข้ามชนิด คุณสามารถใช้เมธอดอย่าง ok บน Result หรือเมธอด ok_or บน Option เพื่อทำการแปลงประเภทข้อมูลอย่างชัดเจนก่อนได้

จนถึงตอนนี้ ฟังก์ชัน main ทั้งหมดที่เราใช้งานมาล้วนส่งคืนค่าเป็น () ฟังก์ชัน main มีความพิเศษตรงที่เป็นจุดเริ่มต้น (entry point) และจุดสิ้นสุด (exit point) ของโปรแกรมที่สามารถรันได้ จึงมีข้อจำกัดเกี่ยวกับประเภทข้อมูลส่งกลับ เพื่อให้โปรแกรมสามารถทำงานและสื่อสารกับระบบปฏิบัติการได้อย่างถูกต้อง

แต่โชคดีที่ฟังก์ชัน main สามารถส่งคืนค่าเป็น Result<(), E> ได้ด้วยเช่นกัน ในลิสติ้ง 9-12 เรานำโค้ดจากลิสติ้ง 9-10 มาปรับแก้ประเภทการส่งกลับของ main ให้เป็น Result<(), Box<dyn Error>> และเพิ่มค่าส่งกลับ Ok(()) ไว้ที่บรรทัดสุดท้าย คราวนี้โค้ดจะสามารถคอมไพล์ผ่านได้อย่างสมบูรณ์!

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let greeting_file = File::open("hello.txt")?;

    Ok(())
}

ประเภทข้อมูล Box<dyn Error> เป็นเทรตออบเจกต์ (trait object) ซึ่งเราจะอธิบายอย่างละเอียดในหัวข้อ “การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม” ในบทที่ 18 สำหรับตอนนี้ คุณสามารถมอง Box<dyn Error> ง่ายๆ ว่าหมายถึง “ข้อผิดพลาดประเภทใดก็ได้” การใช้ ? กับค่า Result ในฟังก์ชัน main ที่ระบุประเภทข้อผิดพลาดเป็น Box<dyn Error> นั้นได้รับอนุญาตเพราะมันเปิดให้ส่งคืนค่า Err ชนิดใดๆ ออกมาก่อนได้ แม้ว่าในตอนนี้เนื้อหาของฟังก์ชัน main จะส่งคืนเฉพาะข้อผิดพลาดประเภท std::io::Error แต่การระบุ Box<dyn Error> จะช่วยให้ลายเซ็นฟังก์ชัน (signature) นี้ยังคงใช้ได้เสมอ แม้ในอนาคตจะมีโค้ดส่วนอื่นใน main ที่คืนค่าข้อผิดพลาดประเภทอื่นเพิ่มเข้ามาก็ตาม

เมื่อฟังก์ชัน main ส่งคืนค่าเป็น Result<(), E> ตัวโปรแกรมจะส่งรหัสสถานะออก (exit code) เป็น 0 หาก main คืนค่า Ok(()) และจะส่งรหัสสถานะออกเป็นค่าที่ไม่ใช่ศูนย์หาก main คืนค่า Err ซึ่งโปรแกรมที่เขียนด้วยภาษา C ก็คืนค่าจำนวนเต็มเมื่อสิ้นสุดการทำงานเช่นกัน โดยโปรแกรมที่ทำงานสำเร็จสมบูรณ์จะส่งค่าจำนวนเต็ม 0 ส่วนโปรแกรมที่เกิดข้อผิดพลาดจะส่งค่าจำนวนเต็มอื่นที่ไม่ใช่ 0 และ Rust ก็ปฏิบัติตามแบบแผน (convention) เดียวกันนี้เพื่อให้ทำงานร่วมกับระบบปฏิบัติการได้อย่างราบรื่น

ฟังก์ชัน main ยังสามารถส่งคืนประเภทข้อมูลใดๆ ก็ตามที่อิมพลีเมนต์ เทรต std::process::Termination ซึ่งมีฟังก์ชัน report ที่ส่งคืนค่า ExitCode คุณสามารถศึกษาเอกสารของไลบรารีมาตรฐานเพิ่มเติมหากต้องการอิมพลีเมนต์เทรต Termination ให้กับประเภทข้อมูลของคุณเอง

เมื่อเราได้เรียนรู้รายละเอียดเกี่ยวกับการเรียกใช้ panic! และการส่งคืนค่า Result กันไปแล้ว ในหัวข้อถัดไปเราจะกลับมาดูแนวทางการตัดสินใจว่า ในสถานการณ์ใดควรเลือกใช้แบบไหนจึงจะเหมาะสมที่สุด