Functions

Functions ใน TypeScript เทียบกับ Rust

function ใน TypeScript นิยามด้วย function หรือ arrow syntax พร้อม type annotation ที่ใส่หรือไม่ใส่ก็ได้ ส่วนใน Rust ทุก function นิยามด้วย fn และ ต้องระบุ type ของ parameter กับค่า return ทุกตัว — compiler จะไม่ infer ข้ามขอบเขตของ function เลย ทำให้ signature ของ function กลายเป็น contract ที่ชัดเจนและอ่านง่าย

เปรียบเทียบไวยากรณ์

TypeScript ใช้ : Type กับ parameter และ : ReturnType หลังวงเล็บปิด ส่วน Rust ใช้ : Type แบบเดียวกันกับ parameter แล้วต่อท้ายรายการ parameter ด้วย -> ReturnType

// TypeScript
function add(a: number, b: number): number {
  return a + b;
}

// Rust
fn add(a: i32, b: i32) -> i32 {
    a + b   // no semicolon — this is the return value
}

สังเกตว่าบรรทัดสุดท้ายไม่มี semicolon ใน Rust นั้น expression สุดท้ายของ block (ที่ไม่มี ;) จะถูก return โดยปริยาย ถ้าเติม semicolon เข้าไป expression นั้นจะกลายเป็น statement ที่ return () (unit) ซึ่งในกรณีนี้จะกลายเป็น type error

function add(a: number, b: number): number {
  return a + b;
}

function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(add(3, 4));      // 7
console.log(greet("Alice")); // Hello, Alice!

fn add(a: i32, b: i32) -> i32 {
    a + b  // last expression, no semicolon = return value
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    println!("{}", add(3, 4));      // 7
    println!("{}", greet("Alice")); // Hello, Alice!
}

ลองเล่นดู

Open in Rust Playground

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    let sum = add(3, 4);
    println!("3 + 4 = {sum}");
    let msg = greet("Rustacean");
    println!("{msg}");
}

🟦 ภาษาแบบ expression-oriented

ใน TypeScript นั้น if และ block เป็น statement — ไม่ให้ค่ากลับมา คุณต้องใช้ ternary ? : เพื่อให้ได้ค่าตามเงื่อนไข ส่วน Rust เป็นภาษาแบบ expression-oriented: if, match และ block expression ล้วนให้ค่ากลับมาทั้งสิ้น

// No ternary needed in Rust — if is an expression
let label = if score >= 60 { "pass" } else { "fail" };

นี่ยังหมายความว่าตัว body ของ function ไม่จำเป็นต้องมี statement return ในกรณีทั่วไป expression สุดท้ายใน body ของ function จะถูก return ให้อัตโนมัติ คุณยังคงใช้ return ได้สำหรับการ return ก่อนกำหนด (early return)

fn absolute(n: i32) -> i32 {
    if n < 0 { -n } else { n }  // the whole if is the return value
}