Ownership

JavaScript จัดการ memory ให้คุณ — Rust ไม่ทำแบบนั้น

ใน JavaScript และ TypeScript garbage collector คอย track ทุก heap value (string, array, object) ให้เอง คุณสร้าง value ได้อย่างอิสระ แล้ว GC จะดูให้ว่าเมื่อไหร่ไม่มีใครใช้แล้วค่อยคืน memory ไม่ต้องเรียก free() เอง และไม่ต้องกังวลเรื่อง use-after-free

Rust ไม่มี garbage collector แต่มี ownership: ระบบกฎ compile-time ที่ให้ทุก value มี owner แค่คนเดียว เมื่อ owner หลุด scope value จะถูกคืน memory อัตโนมัติ — ไม่ต้องการ GC

🟦 กฎสามข้อของ ownership

กฎสามข้อนี้คือรากฐานของทุกอย่างใน Rust compiler บังคับใช้ทั้งหมด:

ทุก value มี owner แค่คนเดียว
มี owner ได้แค่คนเดียวในเวลาเดียวกัน
เมื่อ owner หลุด scope value จะถูก drop (คืน memory)

ไม่มีสิ่งเทียบเท่าใน TypeScript JS object สามารถไม่มี owner (รอ GC) หรือมี reference หลายตัวชี้ไปที่ heap data เดียวกัน Rust ไม่อนุญาตทั้งสองกรณีนั้นตั้งแต่ compile time

การโอน ownership (Move)

ใน TypeScript การ assign object ไปให้ตัวแปรใหม่สร้าง reference ที่สอง ตัวแปรทั้งสองชี้ไปที่ data เดียวกัน ใน Rust การ assign heap value move ownership: ตัวแปรเดิมจะใช้ไม่ได้แล้ว

// TypeScript — สอง reference, object เดียวกัน
const a = { name: "Alice" };
const b = a;          // b ชี้ไปที่ object เดียวกัน
console.log(a.name);  // "Alice" — a ยังใช้ได้
console.log(b.name);  // "Alice" — ทั้งคู่ทำงาน

// GC จะคืน object เมื่อ a และ b ทั้งคู่หลุด scope
// คุณควบคุมเวลาไม่ได้

fn main() {
    // Rust — String เป็น heap value
    let a = String::from("Alice");
    let b = a;          // ownership MOVES จาก a ไป b
    // println!("{}", a); // error[E0382]: use of moved value: `a`
    println!("{}", b);  // ใช้ได้แค่ b

    // เมื่อ b หลุด scope ปลาย main()
    // Rust คืน String data อัตโนมัติ ไม่ต้องการ GC
}

🟦 Scope-based drop — การ cleanup แบบแน่นอน

เมื่อ value ของ owner หลุด scope Rust เรียก drop function ของ value นั้นทันทีและแน่นอน ใน TypeScript คุณไม่มีทางรู้ว่า GC จะ collect object เมื่อไหร่ ใน Rust คุณรู้แน่ๆ ว่าเมื่อไหร่

fn main() {
    println!("before block");
    {
        let s = String::from("hello");
        println!("inside block: {}", s);
    } // <-- s ถูก drop ที่นี่ Memory ถูกคืนที่บรรทัดนี้พอดี
    println!("after block — s หายไปแล้ว");
}

ความแน่นอนนี้คือเหตุผลที่ Rust สามารถจัดการ file handle, network socket, mutex lock, และ database connection โดยไม่ต้องการ GC — resource จะถูกปล่อยเสมอเมื่อสิ้นสุด owning scope

Ownership ผ่าน function

การส่ง heap value เข้า function จะ move ค่านั้นเข้าไปด้วย ฝั่ง caller จึงใช้ค่าเดิมต่อไม่ได้ เว้นแต่ function จะ return กลับมาให้

// TypeScript — ส่ง object ไม่ได้ move ownership
function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const s = "world";
greet(s);
console.log(s); // ยังใช้ได้ — JS ส่ง reference สำหรับ object

fn greet(name: String) {
    // name เป็น owner ที่นี่
    println!("Hello, {}", name);
} // name ถูก drop ที่นี่

fn main() {
    let s = String::from("world");
    greet(s);           // ownership move เข้าไปใน greet()
    // println!("{}", s); // error[E0382]: use of moved value: `s`
}

🟦 ทำไม move-by-default ถึงเป็น feature ไม่ใช่ปัญหา

Move-by-default ดูเหมือนจำกัดในตอนแรก ทำไมถึงใช้ value ไม่ได้หลังส่งให้ function?

ผลตอบแทนคือ memory safety โดยไม่มี GC:

Compiler พิสูจน์แบบ static ว่าไม่มีสองส่วนของโค้ดที่ hold heap allocation เดียวกัน
ไม่มี dangling pointer ไม่มี use-after-free ไม่มี double-free
ทั้งหมดนี้ตรวจสอบตั้งแต่ compile time — ไม่มีต้นทุน runtime

ทางออกคือ borrowing (ยืมโดยไม่ move, บทถัดไป) และ cloning (deep copy แบบ explicit) คุณใช้ borrowing เป็นส่วนใหญ่; ใช้ clone เมื่อต้องการสอง copy อิสระจริงๆ

ลองเขียนเอง

Open in Rust Playground

fn takes_ownership(s: String) {
    println!("got: {}", s);
} // s dropped here

fn makes_copy(n: i32) {
    println!("copy: {}", n);
} // n dropped here, but i32 is Copy so the caller's copy is unaffected

fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // println!("{}", s); // would be a compile error — s was moved

    let x = 5;
    makes_copy(x);
    println!("x is still valid: {}", x); // fine — i32 is Copy
}