Trait Debug

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 35 dari 61.

Standard library Rust dilengkapi banyak trait bawaan yang menyediakan fungsi umum. Salah satu yang paling berguna untuk pengembangan adalah trait Debug, yang memungkinkan kamu mencetak isi struct untuk diperiksa.

Jika kamu mencoba mencetak struct kustom secara langsung, Rust tidak akan tahu cara menampilkannya:

struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // error! Debug belum diimplementasikan

Formatter {:?} memerlukan trait Debug. Alih-alih mengimplementasikannya secara manual, Rust menyediakan jalan pintas: atribut #[derive]. Letakkan atribut tersebut tepat di atas definisi struct-mu:

#[derive(Debug)]
struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Player { name: "Alice", score: 100 }

Atribut #[derive(Debug)] memberi tahu compiler untuk membuat implementasi Debug secara otomatis. Ini berfungsi selama semua field dalam struct-mu juga mengimplementasikan Debug (yang berlaku untuk sebagian besar tipe standar).

Untuk output yang lebih mudah dibaca dengan struktur bersarang, gunakan {:#?} untuk mencetak dengan format yang rapi:

println!("{:#?}", p);
// Player {
//     name: "Alice",
//     score: 100,
// }

Menurunkan Debug sangat penting selama pengembangan. Ini memungkinkan kamu memeriksa datamu dengan cepat tanpa menulis kode pemformatan khusus.

Tantangan

Mudah

Mari buat struct-mu dapat diperiksa dengan menurunkan trait Debug! Kamu akan membuat sistem inventaris sederhana yang item-nya dapat dicetak untuk keperluan debug.

Kamu akan mengatur kodemu dalam dua file:

inventory.rs: Definisikan struct Item publik dengan dua field publik: name (String) dan quantity (u32). Gunakan atribut #[derive(Debug)] untuk mengimplementasikan trait Debug secara otomatis pada struct-mu.
main.rs: Sertakan module inventaris dan buat instance Item menggunakan input yang diberikan. Cetak item menggunakan formatter debug {:?} untuk menampilkan struktur internalnya.

Keunggulan menurunkan Debug adalah Rust secara otomatis membuat kode pemformatan untukmu, jadi tidak perlu implementasi manual! Struct-mu hanya perlu atribut tersebut agar dapat dicetak dengan {:?}.

Output-mu harus menampilkan item dalam format debug Rust:

Item { name: "{name}", quantity: {quantity} }

Misalnya, dengan input Keyboard dan 15:

Item { name: "Keyboard", quantity: 15 }

Kamu akan menerima dua input: nama item dan jumlahnya (parse sebagai u32).

Coba sendiri

mod inventory;

use inventory::Item;

fn main() {
    // Baca input
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut quantity_str = String::new();
    std::io::stdin().read_line(&mut quantity_str).expect("Failed to read line");
    let quantity: u32 = quantity_str.trim().parse().expect("Failed to parse quantity");
    
    // TODO: Buat instance Item dengan nama dan jumlah yang diberikan
    
    // TODO: Cetak item menggunakan format debug {:?}
}