Imprimir con formatos - 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

# Imprimir con formatos

La impresión se maneja por una serie de `macros` definida en`std::fmt` algunos de los cuales son:

- `format!`: escribe el texto formateado a un `String`
- `print!`: igual que `format!` pero el texto se imprime a la consola (io::stdout).
- `println!`: es igual que `print!` pero se agrega un salto de línea
- `eprint!`: igual que `print!` pero el texto se imprime al error estándar (io::stderr).
- `eprintln!`: es igual que `eprint!` pero se agrega un salto de línea

All parse text in the same fashion. As a plus, Rust checks formatting correctness at compile time.

    fn main() {
        // In general, the `{}` will be automatically replaced with any
        // arguments. These will be stringified.
        println!("{} días", 31);

        // Se pueden usar argumentos posicionales. Especificar un entero dentro de `{}`
       // determina qué argumento adicional será reemplazado. Los argumentoscomienzan
       // en 0 inmediatamente después de la cadena de formato.
        println!("{0}, esto es {1}. {1}, este es {0}", "Alice", "Bob");

        // Como los argumentos nombrados.
        println!("{sujeto} {verbo} {objeto}",
                 object="the lazy dog",
                 subject="the quick brown fox",
                 verb="jumps over");

        // Se puede invocar diferentes formatos especificando el carácter del formato
       // después de un `:`.
        println!("Base 10:               {}",   69420); // 69420
        println!("Base 2 (binario):       {:b}", 69420); // 10000111100101100
        println!("Base 8 (octal):        {:o}", 69420); // 207454
        println!("Base 16 (hexadecimal): {:x}", 69420); // 10f2c

        // Puedes justificar el texto a la derecha con un ancho especificado. Esto será
    // salida "    1 ". (Cuatro espacios blancos y un "1", para un ancho totalde 5.)
        println!("{numero:>5}", number=1);

        // Puedes rellenar números con ceros adicionales,
        println!("{numero:0>5}", number=1); // 00001
        // y justificar a la izquierda volteando el signo. Esto imprimirá "10000".
        println!("{numero:0<5}", number=1); // 10000

        // Puede usar argumentos con nombre en el formato especificador agregando un `$`.
        println!("{numero:0>ancho$}", number=1, width=5);

        // Rust incluso verifica para asegurarse de que se usen el número correcto de argumentos.
        println!("Mi nombre es {0}, {1} {0}", "Bond");
        // FIXME ^ Add the missing argument: "James"

        // Sólo los tipos que implementan `fmt::Display` pueden formatearse con `{}`.
       // Los tipos definidos por usuario no implementan `fmt::Display` de forma predeterminada.

        #[allow(dead_code)] // deshabilita `dead_code` el cual advierte contra módulos no usados
        struct Structure(i32);

        // Esto no se compilará porque `Structure` no implementa
        // `fmt::Display`.
       // println!("esta estructura `{}` no va a imprimir... ", Structure(3));
       // TAREA ^ intente quitar el comentario de esta línea

        // Para Rust 1.58 y superior, puedes capturar directamente el argumento de una
    // variable en el entorno. Al igual que lo anterior, esto imprimirá
    // "     1", 4 espacios blancos y a "1".
        let number: f64 = 1.0;
        let width: usize = 5;
        println!("{numero:>ancho$}");
    }

`std::fmt` contiene muchos `traits` que rigen la visualización de texto. La forma básica de dos de ellos se enumera a continuación:

- `fmt::Debug`: Usa el marcador `{:?}`. Formatea el texto para fines de depuración.
- `fmt::Display`: Usa el marcador `{}`. Formatea texto de una manera más elegante y amistosa.

Aquí, usamos `fmt::Display` porque la librería std proporciona implementaciones para estos tipos. Para imprimir tipos personalizados, más pasosson necesarios

Implementar el rasgo `fmt::Display` implementa automáticamente el trait `ToString` que nos permite convertir el tipo en `String`.

En la línea 43,`#[allow(dead_code)]` es un [atributo](../ attribute.md) quesolo se aplica al módulo después de él.

### Actividades

- Solucione el problema en el código anterior (ver el ARRÉGLAME) para que se ejecute sin error.
- Intente quitar el comentario de la línea que intenta formatear la estructura `Structure`(ver TAREA)
- Agregue un macro `println!` que imprima: `Pi es aproximadamente 3.142` controlando el número de decimales mostrados. Para efectos de esteejercicio, use `let Pi = 3.141592` como una estimación para pi. (Sugerencia: puedesconsultar la documentación de `std::fmt`para configurar el número de decimales desplegados)

### Ver también

`std::fmt`, `macros`, `struct`, `traits`, y `dead_code`