Option and Result

Option และ Result ใน TypeScript เทียบกับ Rust

TypeScript ใช้ T | null | undefined สำหรับค่าที่อาจมีหรือไม่มี และใช้ try/catch สำหรับ error ส่วน Rust เข้ารหัสทั้งสองอย่างไว้ในระบบ type:

Option<T> — เป็นได้ทั้ง Some(value) หรือ None ไม่มี null ไม่มี undefined
Result<T, E> — เป็นได้ทั้ง Ok(value) หรือ Err(error) ไม่มี exception

ระบบ type บังคับให้คุณจัดการทั้งสองกรณีก่อนที่จะใช้ค่าได้

Option — การไม่มีค่าโดยไม่ต้องมี null

// TypeScript: null can silently propagate
function findUser(id: number): User | null { ... }
const user = findUser(42);
console.log(user.name); // runtime crash if null

// Rust: the compiler won't let you use the value without handling None
fn find_user(id: u32) -> Option<User> { ... }
match find_user(42) {
    Some(user) => println!("{}", user.name),
    None       => println!("not found"),
}

Result — error ในฐานะค่า

// TypeScript: error can be thrown anywhere
function divide(a: number, b: number): number {
  if (b === 0) throw new Error("division by zero");
  return a / b;
}

// Rust: error is part of the return type
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 { Err("division by zero".to_string()) }
    else { Ok(a / b) }
}

Method อำนวยความสะดวก

TypeScript	Rust
`value ?? defaultVal`	`option.unwrap_or(defaultVal)`
`value!` (non-null assertion)	`option.unwrap()` (panic ถ้าเป็น None)
`value ?? (() => { throw ... })()`	`option.expect("msg")` (panic พร้อมข้อความ)

operator ?

ใน function ที่ return Result นั้น ? บนค่า Result จะ unwrap Ok ให้ หรือไม่ก็ return Err ออกไปก่อนกำหนด — ช่วยตัดการซ้อน match หลายชั้นออกไป:

fn read_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.trim().parse::<i32>()?; // returns Err early if parse fails
    Ok(n * 2)
}

// Option-like: null / undefined
function divide(a: number, b: number): number | null {
  if (b === 0) return null;
  return a / b;
}
const r = divide(10, 2) ?? 0;
console.log(r); // 5

// Error handling: try/catch
try {
  const val = JSON.parse("bad json");
} catch (e) {
  console.error("parse error", e);
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(v)  => println!("{v}"),    // 5
        Err(e) => println!("{e}"),
    }

    let maybe: Option<i32> = Some(42);
    let value = maybe.unwrap_or(0);
    println!("{value}"); // 42
}

ลองเล่นดู

Open in Rust Playground

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("10 / 2 = {result}"),
        Err(e) => println!("Error: {e}"),
    }
    match divide(5.0, 0.0) {
        Ok(result) => println!("5 / 0 = {result}"),
        Err(e) => println!("Error: {e}"),
    }
    let maybe: Option<i32> = Some(42);
    let value = maybe.unwrap_or(0);
    println!("Option value: {value}");
}

🟦 ไม่มี null — error คือค่า

Rust ไม่มี null และไม่มี undefined ไม่มีทางที่จะมีค่าของ type String ที่จริง ๆ แล้วไม่มีค่าอยู่อย่างลับ ๆ — type String เก็บ string จริงเสมอ การไม่มีค่าถูกเข้ารหัสเป็น Option<String> และ compiler บังคับให้คุณตรวจสอบก่อนใช้

ในทำนองเดียวกัน Rust ไม่มี exception function ที่อาจล้มเหลวจะ return Result<T, E> error เป็นค่าในระบบ type ไม่ใช่ control flow ที่มองไม่เห็นซึ่งสามารถ propagate ขึ้นไปตาม call stack อย่างเงียบ ๆ คุณรู้เสมอว่า function ใดอาจล้มเหลวได้ เพราะ signature บอกไว้ชัดว่าเป็น Result

วิธีนี้กำจัดบั๊กบน production ทั้งสองกลุ่มออกไป:

การ crash จาก null pointer / การ dereference undefined
exception ที่ไม่ถูกจับ ทำให้เกิดพฤติกรรมไม่คาดคิดตอน runtime

ในโค้ด Rust บน production นั้น unwrap() และ expect() ควรปรากฏเฉพาะใน test หรือ prototype เท่านั้น โค้ดจริงใช้ match, unwrap_or, unwrap_or_else, ? หรือ crate จัดการ error เฉพาะทางอย่าง thiserror และ anyhow