• Membuat Struct Sederhana
• Struct Mutable
• Shorthand Field Initialization
• Struct Update Syntax
• Tuple Struct
• Unit-Like Struct
• Kesimpulan

Halo teman-teman semuanya, pada artikel sebelumnya kita sudah mempelajari tentang slice dan string di Rust. Kita mengenal perbedaan antara String dan &str, bagaimana mengambil sebagian teks menggunakan slice, serta bagaimana slice juga bisa digunakan pada array. Kali ini kita akan melangkah ke topik baru yang sangat penting, yaitu struct di Rust.

Struct (singkatan dari structure) adalah cara untuk membuat tipe data buatan sendiri di Rust. Dengan struct, kita bisa mengelompokkan beberapa data ke dalam satu kesatuan yang lebih bermakna. Konsep ini mirip dengan object di bahasa lain, meskipun Rust tidak memiliki OOP tradisional dengan class.

Menggunakan struct membuat kode kita lebih terorganisir, lebih mudah dibaca, dan lebih jelas maksudnya. Mari kita bahas bagaimana cara mendefinisikan dan menggunakan struct di Rust.

Membuat Struct Sederhana

Struct didefinisikan menggunakan keyword struct, lalu di dalamnya kita tuliskan field yang dimiliki.

struct Person {
    name: String,
    age: u32,
    is_active: bool,
}

fn main() {
    let user1 = Person {
        name: String::from("Andi"),
        age: 25,
        is_active: true,
    };

    println!("Nama: {}, Umur: {}, Aktif: {}", user1.name, user1.age, user1.is_active);
}

Di sini kita membuat struct Person dengan tiga field: name, age, dan is_active. Lalu kita membuat sebuah instance user1 dan mengakses field-nya dengan tanda titik (.).

Struct Mutable

Kita bisa membuat struct sebagai mutable jika ingin mengubah nilainya.

struct Person {
    name: String,
    age: u32,
    is_active: bool,
}

fn main() {
    let mut user = Person {
        name: String::from("Budi"),
        age: 30,
        is_active: false,
    };

    user.age = 31; // ubah field age
    println!("Umur terbaru: {}", user.age);
}

Shorthand Field Initialization

Jika nama variabel lokal sama dengan nama field, kita bisa menggunakan shorthand.

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let name = String::from("Citra");
    let age = 22;

    let user = Person { name, age }; // tidak perlu tulis name: name, age: age
    println!("{} berusia {}", user.name, user.age);
}

Struct Update Syntax

Kita juga bisa membuat instance baru dengan menyalin sebagian field dari instance lain menggunakan syntax ...

struct Person {
    name: String,
    age: u32,
    is_active: bool,
}

fn main() {
    let user1 = Person {
        name: String::from("Dewi"),
        age: 27,
        is_active: true,
    };

    let user2 = Person {
        name: String::from("Eka"),
        ..user1
    };

    println!("{} berusia {}", user2.name, user2.age);
}

Pada contoh ini, user2 menggunakan field age dan is_active dari user1, sedangkan field name diberi nilai baru.

Tuple Struct

Selain struct biasa dengan nama field, Rust juga mendukung tuple struct, yaitu struct yang tidak memiliki nama field, hanya tipe data.

struct Color(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    println!("Warna: {}, {}, {}", black.0, black.1, black.2);
}

Unit-Like Struct

Rust juga memungkinkan membuat struct tanpa field, disebut unit-like struct. Biasanya digunakan untuk marker atau implementasi trait.

struct Marker;

fn main() {
    let _m = Marker;
}

Kesimpulan

Pada artikel ini kita sudah belajar tentang struct di Rust. Kita melihat cara membuat struct dengan field, membuat struct mutable, menggunakan shorthand field initialization, memanfaatkan struct update syntax, tuple struct, hingga unit-like struct.

Pada artikel berikutnya, kita akan membahas tentang Enum & Pattern Matching, yang akan melengkapi struct sebagai cara mendefinisikan tipe data kompleks di Rust.

Terima Kasih