Depuración - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Depuración

Todos los tipos que quieren usar los traits de `std::fmt` requieren unaimplementación para ser imprimible. Las implementaciones automáticas solo se proporcionanpara tipos como en la biblioteca `std`. Todos los demás tipos deben ser manualmente implementados de alguna manera.

El trait `fmt::Debug` hace que esto sea muy sencillo. Todos Los tipos pueden`Derive` (crear automáticamente) la implementación `fmt::Debug`. Esto no ciertopara `fmt::Display` el cual debe implementarse manualmente.

    #![allow(unused)]
    fn main() {
    // Esta estructura no se puede imprimir con `fmt::Display` o
    // con `fmt::Debug`.
     struct UnPrintable(i32);

    // El atributo `derive` crea automáticamente la implementación
     // requerida para hacer esta `struct` imprimible con `fmt::Debug`.
    #[derive(Debug)]
    struct DebugPrintable(i32);
    }

Todos los tipos de biblioteca `std` se pueden imprimir automáticamente con `{:?}` también:

    // Derive la implementación `fmt::Debug` para `Structure`. `Structure`
    // es una estructura que contiene un solo `i32`.
     #[derive(Debug)]
    struct Structure(i32);

    // Ponga una `Structure` dentro de la estructura `Deep`. Házlo imprimible
    // también.
    #[derive(Debug)]
    struct Deep(Structure);

    fn main() {
        // Imprimir con `{:?}` es similar a imprimir con `{}`.
        println!("{:?} meses en un año.", 12);
        println!("{1:?} {0:?} es el nombre del {actor:?}.",
                 "Slater",
                 "Christian",
                 actor="actor's");

        // ¡`Structure` también se puede imprimir!
        println!("Ahora {:?} imprimirá ", Structure(3));

        // El problema con 'derive` es que no hay control sobre cómo
       // los resultados se ven. ¿Qué pasa si quiero que esto solo muestre un `7`?
        println!("Ahora {:?} imprimirá ", Deep(Structure(7)));
    }

Entonces `fmt::Debug` definitivamente hace esto imprimible pero sacrifica algo deelegancia. Rust también proporciona “Impresión Bonita” con `{:#?}`.

    #[derive(Debug)]
    struct Person<'a> {
        name: &'a str,
        age: u8
    }

    fn main() {
        let name = "Peter";
        let age = 27;
        let peter = Person { name, age };

        // Impresión bonita    println!("{:#?}", peter);
    }

Se puede implementar manualmente `fmt::Display` para controlar la impresión.

### Ver también

`attributes`, `derive`, `std::fmt`, y `struct`