Display और Debug Traits

Display और Debug आपके type को खुद को readable text में बदलने के दो अलग तरीके सिखाते हैं: एक लोगों के लिए polished, एक developers के लिए detailed।

In this page:

Deriving Debug
Implementing Display Manually
Implementing Both Traits on the Same Type
Using write! Inside fmt

Syntax

rust

use std::fmt;

impl fmt::Display for Name {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.field)
    }
}

#[derive(Debug)]

Deriving Debug

#[derive(Debug)] अपने आप एक Debug implementation generate करता है, एक struct को quick developer-facing inspection के लिए {:?} से print होने देते हुए।

उदाहरण: Deriving Debug

markup

// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define a struct `Point` to group related fields together
struct Point {
    x: i32,
    y: i32,
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `p`, set to `Point { x: 1, y: 2 }`
    let p = Point { x: 1, y: 2 };
    // Print "{:?}" to the console, substituting in `p` (with a trailing newline)
    println!("{:?}", p);
}

Implementing Display Manually

Display में कोई automatic derive नहीं है और इसे हाथ से implement किया जाना चाहिए, बिल्कुल यह define करते हुए कि {} के ज़रिए clean, user-facing output में type कैसा दिखना चाहिए।

उदाहरण: Implementing Display Manually

markup

// Bring `std::fmt` into scope
use std::fmt;

// Define a struct `Point` to group related fields together
struct Point {
    x: i32,
    y: i32,
}

// Implement methods on `fmt`
impl fmt::Display for Point {
    // Define the function `fmt` taking `&self`, `f` and returning a `fmt::Result`
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `p`, set to `Point { x: 3, y: 4 }`
    let p = Point { x: 3, y: 4 };
    // Print "{}" to the console, substituting in `p` (with a trailing newline)
    println!("{}", p);
}

Implementing Both Traits on the Same Type

एक type एक साथ Display और Debug दोनों implement कर सकता है, इसे दो distinct textual representations देते हुए इस आधार पर कि {} या {:?} उपयोग हुआ।

उदाहरण: Implementing Both Traits on the Same Type

markup

// Bring `std::fmt` into scope
use std::fmt;

// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define a struct `Money` to group related fields together
struct Money {
    cents: i64,
}

// Implement methods on `fmt`
impl fmt::Display for Money {
    // Define the function `fmt` taking `&self`, `f` and returning a `fmt::Result`
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "${:.2}", self.cents as f64 / 100.0)
    }
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `price`, set to `Money { cents: 1999 }`
    let price = Money { cents: 1999 };
    // Print "Display: {}" to the console, substituting in `price` (with a trailing newline)
    println!("Display: {}", price);
    // Print "Debug: {:?}" to the console, substituting in `price` (with a trailing newline)
    println!("Debug: {:?}", price);
}

Using write! Inside fmt

write! macro वह तरीका है जिससे Display और Debug implementations दोनों अपना output produce करते हैं, formatted text को दिए Formatter में लिखते हुए और एक fmt::Result return करते हुए।

उदाहरण: Using write! Inside fmt

markup

// Bring `std::fmt` into scope
use std::fmt;

// Define a struct `Temperature` to group related fields together
struct Temperature(f64);

// Implement methods on `fmt`
impl fmt::Display for Temperature {
    // Define the function `fmt` taking `&self`, `f` and returning a `fmt::Result`
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:.1} degrees", self.0)
    }
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `t`, set to `Temperature(23.456)`
    let t = Temperature(23.456);
    // Print "{}" to the console, substituting in `t` (with a trailing newline)
    println!("{}", t);
}

Chapter Quiz — Complete all 7 topics to unlock

0/7 topics done

Complete these topics first:

← Previous Lesson Default Trait Implementations Next Lesson → Where Clauses

Display और Debug Traits

Deriving Debug

Implementing Display Manually

Implementing Both Traits on the Same Type

Using write! Inside fmt

Chapter Quiz — Complete all 7 topics to unlock

Login to run this code