Salida en Rust

Ya has usado println! un montón de veces. En esta página verás las otras macros para imprimir que te vas a encontrar, y cuándo conviene usar cada una.

println! y print!

println! imprime texto y añade un salto de línea al final. print! hace lo mismo, pero no añade el salto de línea:

fn main() {
    print!("¡Hola, ");
    print!("mundo");
    println!("!");
}

Salida:

¡Hola, mundo!

▶ Pruébalo tú mismo

Fíjate en que las tres llamadas imprimieron en la misma línea: solo println! pasa a una línea nueva. En la práctica usarás println! casi siempre. print! sirve sobre todo cuando vas armando una línea poco a poco.

Marcadores: {} y variables con nombre

Ya has visto {} como marcador de posición. Puedes rellenarlo de dos formas: pasando un valor después del texto, o poniendo el nombre de la variable directamente dentro de las llaves:

fn main() {
    let name = "Ferris";
    let age = 10;

    println!("{} tiene {} años", name, age); // por posición
    println!("{name} tiene {age} años");     // en línea (mismo resultado)
}

Salida:

Ferris tiene 10 años
Ferris tiene 10 años

▶ Pruébalo tú mismo

Las dos líneas imprimen lo mismo. El estilo en línea ({name}) es un poco más reciente y suele leerse mejor, así que úsalo siempre que puedas.

format!: crea un String en lugar de imprimirlo

A veces quieres el texto formateado como un String en vez de imprimirlo en el momento. Por ejemplo, para guardarlo o pasárselo a otra función. Para eso existe format!. Funciona exactamente igual que println!, pero devuelve un String en lugar de imprimir:

fn main() {
    let name = "Ferris";
    let message = format!("¡Hola, {name}!");
    println!("{message}");
}

Salida:

¡Hola, Ferris!

▶ Pruébalo tú mismo

Impresión de depuración con {:?}

El {} normal solo funciona con valores que saben mostrarse como texto: números, cadenas de texto, booleanos. Con valores más complejos, como tuplas o structs, {} no compila. En ese caso usa {:?} (el formato de “depuración”, o debug):

fn main() {
    let point = (3, 7);
    println!("{:?}", point);
}

Salida:

(3, 7)

▶ Pruébalo tú mismo

Si el valor es grande y quieres verlo más ordenado, en varias líneas, usa {:#?} (impresión “bonita”):

fn main() {
    let point = (3, 7);
    println!("{:#?}", point);
}

Salida:

(
    3,
    7,
)

▶ Pruébalo tú mismo

Nota

Si alguna vez Rust te dice que un tipo “doesn’t implement Display” (no implementa Display), es la señal para probar {:?} en lugar de {}. Es uno de los errores más comunes de los principiantes al imprimir cosas.

Formato de números

Algunos trucos de formato que aparecen a menudo:

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 decimales -> 3.14
    println!("{:5}", 42);    // rellena hasta un ancho de 5 -> "   42"
    println!("{:08.2}", pi); // rellena con ceros -> 00003.14
}

Salida:

3.14
   42
00003.14

▶ Pruébalo tú mismo

No hace falta que te los aprendas de memoria. Basta con saber que existen, para cuando necesites alinear números o redondear decimales.

Alinear texto e imprimir llaves

El ancho también funciona con texto, y puedes elegir hacia qué lado se pega el valor. Después de los : pon < (izquierda), > (derecha) o ^ (centro), y luego el ancho. También puedes poner delante un carácter de relleno, como -:

fn main() {
    let coffee = 3.5;
    let bagel = 2.25;

    println!("{:-^20}", " MENU ");
    println!("{:<12}{:>8}", "Item", "Price");
    println!("{:<12}{:>8.2}", "Coffee", coffee);
    println!("{:<12}{:>8.2}", "Bagel", bagel);
    println!("{:<12}{:>8.2}", "Total", coffee + bagel);
}

Salida:

------- MENU -------
Item           Price
Coffee          3.50
Bagel           2.25
Total           5.75

▶ Pruébalo tú mismo

Dejamos el texto de este menú en inglés a propósito: cuando la salida depende del ancho de las columnas, cambiar las palabras cambia también la alineación del resultado.

Leamos {:>8.2} pieza por pieza: > significa alinear a la derecha, 8 es el ancho y .2 significa dos decimales. Alinear los números a la derecha hace que los puntos decimales queden en columna, y por eso lo hacen los tickets y las tablas.

¿Y si quieres un { de verdad en la salida? Como las llaves significan “marcador”, tienes que duplicarlas: {{ imprime { y }} imprime }.

fn main() {
    println!("Conjunto: {{{}, {}}}", 1, 2);
}

Salida:

Conjunto: {1, 2}

▶ Pruébalo tú mismo

Imprimir errores

También existe eprintln! (y eprint!). Funciona exactamente igual que println!, pero escribe en la salida de errores en lugar de en la normal. La terminal muestra las dos, pero si alguien guarda la salida de tu programa en un archivo, los mensajes de error no se mezclan con ella. Úsalo para avisos y mensajes de error.

Práctica

1. Una etiqueta de precio

Guarda el artículo "Cuaderno" y el precio 2.5, y luego imprime Cuaderno cuesta $2.50. Pista: {:.2} redondea a dos decimales, y también funciona en línea: {price:.2}.

Ver solución

fn main() {
    let item = "Cuaderno";
    let price = 2.5;
    println!("{item} cuesta ${price:.2}");
}

Salida:

Cuaderno cuesta $2.50

▶ Pruébalo tú mismo

2. Crea una etiqueta e imprímela de dos formas

Usa format! para crear la etiqueta ferris-7 a partir del nombre "ferris" y el número 7. Imprímela una vez con {} y otra con {:?}, y busca la diferencia. Pista: format! acepta exactamente los mismos marcadores que println!.

Ver solución

fn main() {
    let name = "ferris";
    let id = 7;
    let label = format!("{name}-{id}");

    println!("{label}");
    println!("{label:?}");
}

Salida:

ferris-7
"ferris-7"

▶ Pruébalo tú mismo

La impresión de depuración muestra el texto entre comillas, así que ves exactamente dónde empieza y dónde termina. Eso resulta muy útil cuando un valor tiene espacios de más.

Resumen

• println! imprime con salto de línea; print! no.
• {} y {name} son marcadores para valores que saben mostrarse con Display.
• format! funciona como println!, pero devuelve un String en vez de imprimir.
• {:?} (y {:#?}) imprime valores para depurar, incluso los que {} no puede mostrar.
• {:.2} redondea decimales; <, > y ^ con un ancho alinean el texto; {{ y }} imprimen llaves literales.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Cuál es la diferencia entre println! y print!?

println! añade un salto de línea al final, print! no print! añade un salto de línea al final, println! no No hay ninguna diferencia

2. ¿Por qué usarías {:?} en lugar de {} para imprimir una tupla?

{:?} es más rápido Las tuplas no implementan Display, así que {} no compila {} solo funciona dentro de print!, no de println!

Puntuación: 0 / 2

Para leer más

• std::fmt: documentación de la biblioteca estándar (en inglés): la lista completa de opciones de formato, incluidos el ancho, el relleno, la alineación y la precisión.
• Formatted print: Rust by Example (en inglés): ejemplos ejecutables de argumentos por posición y con nombre, relleno y alineación.
• Debug: Rust by Example (en inglés): cómo funcionan {:?} y {:#?}, y cómo los consiguen tus propios tipos.
• println!: documentación de la biblioteca estándar (en inglés): la referencia oficial de println!, con enlaces a print! y eprintln!.
• format!: documentación de la biblioteca estándar (en inglés): crear un String con las mismas reglas de formato.