Imprimir con formatos

La impresión se maneja por una serie de macros definida enstd::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::fmtpara configurar el número de decimales desplegados)

Ver también

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