Sintaks Method di Rust

Di Rust, Method menyediakan cara yang kuat untuk mendefinisikan perilaku yang terkait langsung dengan struct, enum, atau tipe lainnya. Method membuat kode lebih modular, mudah dibaca, dan dapat dipelihara dengan mengenkapsulasi fungsionalitas di dalam tipe itu sendiri. Panduan ini membahas sintaks Method di Rust, mencakup dasar-dasar, penggunaan self, Method Chaining, dan praktik terbaik.

Apa itu Method di Rust?

Method adalah sebuah function yang didefinisikan dalam konteks tipe tertentu, biasanya menggunakan blok impl. Tidak seperti function biasa, Method dipanggil pada sebuah instance menggunakan notasi titik (.). Method memungkinkan kita mengenkapsulasi perilaku yang secara logis milik tipe tersebut, sehingga kode lebih intuitif.

Mendefinisikan Method Menggunakan impl

struct Circle {
    radius: f64,
}

impl Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }

    fn circumference(&self) -> f64 {
        2.0 * std::f64::consts::PI * self.radius
    }
}

fn main() {
    let circle = Circle { radius: 5.0 };

    println!("Area: {:.2}", circle.area());
    println!("Circumference: {:.2}", circle.circumference());
}

• impl Circle mendefinisikan blok implementasi untuk struct Circle.
• Parameter &self merujuk pada instance dari struct.
• Method dipanggil menggunakan notasi titik, misalnya circle.area().

Memahami self, &self, dan &mut self

1. self – Mengambil kepemilikan dari instance:

struct Container { items: Vec<i32> }

impl Container {
    fn consume(self) -> Vec<i32> { self.items }
}

fn main() {
    let container = Container { items: vec![1,2,3] };
    let items = container.consume();
    println!("{:?}", items);
}

2. &self – Meminjam instance secara immutable (hanya baca):

struct Rectangle { width: u32, height: u32 }

impl Rectangle {
    fn area(&self) -> u32 { self.width * self.height }
}

3. &mut self – Meminjam instance secara mutable (dapat diubah):

struct Counter { value: i32 }

impl Counter {
    fn increment(&mut self) { self.value += 1; }
}

fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment();
    println!("Counter value: {}", counter.value);
}

Method Chaining

Method Chaining memungkinkan memanggil beberapa Method dalam satu ekspresi. Hal ini dilakukan dengan mengembalikan self atau referensi ke self.

struct Builder { name: String, count: u32 }

impl Builder {
    fn new(name: &str) -> Self { Builder { name: name.to_string(), count: 0 } }
    fn increment(&mut self) -> &mut Self { self.count += 1; self }
    fn set_name(&mut self, name: &str) -> &mut Self { self.name = name.to_string(); self }
    fn build(&self) { println!("Builder: {}, Count: {}", self.name, self.count); }
}

fn main() {
    Builder::new("Initial")
        .increment()
        .increment()
        .set_name("Updated")
        .build();
}

• &mut Self memungkinkan perantaian Method dengan mengembalikan referensi mutable ke instance.
• Membuat kode lebih ringkas dan mudah dibaca.

Static Method dan Associated Function

Rust mendukung static Method (tidak mengambil self) dan associated function (sering digunakan sebagai konstruktor):

struct Calculator;

impl Calculator {
    fn add(a: i32, b: i32) -> i32 { a + b }  // Static Method
    fn new() -> Self { Calculator }          // Associated Function
}

fn main() {
    Calculator::new();                     
    let sum = Calculator::add(10, 20);
    println!("Sum: {}", sum);
}

• Static Method dipanggil pada tipe itu sendiri, bukan pada instance.
• Associated Function digunakan untuk membuat instance, contohnya new().

Praktik Terbaik

1. Gunakan &self untuk Method hanya-baca.
2. Gunakan &mut self untuk Method yang memodifikasi instance.
3. Rancang Method agar mendukung Method Chaining bila relevan.
4. Jaga Method tetap fokus dan ringkas, satu tanggung jawab per Method.
5. Manfaatkan Static Method untuk fungsionalitas yang tidak terikat pada instance.

Kesimpulan

Menguasai sintaks Method di Rust memungkinkan menulis kode yang lebih terstruktur, modular, dan mudah dipelihara. Dari pemahaman dasar self, hingga Method Chaining dan Static Method, pengetahuan ini membantu Anda mengelola perilaku tipe dengan intuitif dan menulis kode Rust yang lebih bersih.