Saída em Rust

Você já usou o println! várias vezes. Esta página mostra as outras macros de impressão que você vai encontrar e quando usar cada uma.

println! e print!

O println! imprime o texto e adiciona uma quebra de linha no final. O print! faz a mesma coisa, mas não adiciona a quebra de linha:

fn main() {
    print!("Olá, ");
    print!("mundo");
    println!("!");
}

Saída:

Olá, mundo!

▶ Experimente você mesmo

Repare que as três chamadas imprimiram na mesma linha: só o println! pula para uma nova. Na prática, você vai usar o println! quase sempre. O print! é útil principalmente quando você está montando uma linha aos poucos.

Marcadores: {} e variáveis com nome

Você já viu o {} sendo usado como marcador (placeholder). Dá para preenchê-lo passando um valor depois do texto ou colocando o nome da variável direto dentro das chaves:

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

    println!("{} tem {} anos", name, age); // por posição
    println!("{name} tem {age} anos");     // embutido (mesmo resultado)
}

Saída:

Ferris tem 10 anos
Ferris tem 10 anos

▶ Experimente você mesmo

As duas linhas imprimem a mesma coisa. O estilo embutido ({name}) é um pouco mais novo e normalmente mais fácil de ler, então prefira esse quando puder.

format!: monte uma string em vez de imprimir

Às vezes você quer o texto formatado como uma String em vez de imprimi-lo na hora, por exemplo para guardar ou passar para outra função. É para isso que serve o format!. Ele funciona exatamente como o println!, mas retorna uma String em vez de imprimir:

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

Saída:

Olá, Ferris!

▶ Experimente você mesmo

Impressão de depuração com {:?}

O {} simples só funciona com valores que sabem se mostrar como texto: números, strings, booleanos. Para valores mais complexos, como tuplas ou structs, o {} não compila. Use {:?} (o formato de “debug”) no lugar:

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

Saída:

(3, 7)

▶ Experimente você mesmo

Para valores maiores, use {:#?} (pretty-print), que mostra tudo de um jeito mais organizado, em várias linhas:

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

Saída:

(
    3,
    7,
)

▶ Experimente você mesmo

Nota

Se o Rust disser que um tipo “doesn’t implement Display” (não implementa Display), é a deixa para trocar {} por {:?}. É um dos erros mais comuns de quem está começando e quer imprimir alguma coisa.

Formatando números

Alguns truques de formatação que aparecem bastante:

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 casas decimais -> 3.14
    println!("{:5}", 42);    // largura mínima 5 -> "   42"
    println!("{:08.2}", pi); // preenche com zeros -> 00003.14
}

Saída:

3.14
   42
00003.14

▶ Experimente você mesmo

Não precisa decorar. Só saiba que eles existem para quando você precisar alinhar números ou arredondar casas decimais.

Alinhando texto e imprimindo chaves

A largura também funciona com texto, e você pode escolher para qual lado o valor fica encostado. Depois do :, coloque < (esquerda), > (direita) ou ^ (centro) e em seguida a largura. Você também pode colocar um caractere de preenchimento na frente, 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);
}

Saída:

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

▶ Experimente você mesmo

Deixamos os textos deste cardápio em inglês de propósito: aqui o resultado depende do tamanho de cada texto, e manter as mesmas palavras garante que as colunas fiquem iguais às do exemplo em qualquer idioma.

Lendo {:>8.2} parte por parte: > significa alinhar à direita, 8 é a largura e .2 significa duas casas decimais. Alinhar números à direita faz os pontos decimais ficarem um embaixo do outro, e é por isso que recibos e tabelas fazem assim.

E se você quiser um { de verdade na saída? Como as chaves significam “marcador”, você as duplica: {{ imprime { e }} imprime }.

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

Saída:

Conjunto: {1, 2}

▶ Experimente você mesmo

Imprimindo erros

Também existe o eprintln! (e o eprint!). Ele funciona exatamente como o println!, mas escreve na saída de erro em vez da saída normal. O terminal mostra as duas, mas se alguém salvar a saída do seu programa em um arquivo, as mensagens de erro ficam de fora. Use-o para avisos e mensagens de erro.

Prática

1. Uma etiqueta de preço

Guarde o item "Caderno" e o preço 2.5 e depois imprima Caderno custa $2.50. Dica: {:.2} arredonda para duas casas decimais, e também funciona embutido: {price:.2}.

Ver solução

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

Saída:

Caderno custa $2.50

▶ Experimente você mesmo

Repare que o Rust sempre usa ponto como separador decimal, e não vírgula.

2. Monte uma etiqueta e imprima de dois jeitos

Use format! para montar a etiqueta ferris-7 a partir do nome "ferris" e do número 7. Imprima uma vez com {} e outra com {:?}, e veja a diferença. Dica: o format! aceita exatamente os mesmos marcadores que o println!.

Ver solução

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

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

Saída:

ferris-7
"ferris-7"

▶ Experimente você mesmo

A impressão de depuração mostra o texto entre aspas, para você ver exatamente onde ele começa e termina. Isso ajuda quando um valor tem espaços sobrando.

Resumo

• println! imprime com quebra de linha; print! não.
• {} e {name} são marcadores para valores que sabem se mostrar com Display.
• format! funciona como o println!, mas retorna uma String em vez de imprimir.
• {:?} (e {:#?}) imprime valores para depuração, inclusive os que o {} não consegue mostrar.
• {:.2} arredonda casas decimais; <, > e ^ com uma largura alinham texto; {{ e }} imprimem chaves literais.

Teste o que aprendeu

Teste o que aprendeu

1. Qual é a diferença entre println! e print!?

println! adiciona uma quebra de linha no final, print! não print! adiciona uma quebra de linha no final, println! não Não há diferença

2. Por que usar {:?} em vez de {} para imprimir uma tupla?

{:?} é mais rápido Tuplas não implementam Display, então {} não compila {} só funciona dentro de print!, não de println!

Pontuação: 0 / 2

Para saber mais

• std::fmt — documentação da biblioteca padrão (em inglês): a lista completa de opções de formatação, incluindo largura, preenchimento, alinhamento e precisão.
• Formatted print — Rust by Example (em inglês): exemplos que você pode rodar de argumentos por posição e por nome, preenchimento e alinhamento.
• Debug — Rust by Example (em inglês): como {:?} e {:#?} funcionam e como os seus próprios tipos ganham esse formato.
• println! — documentação da biblioteca padrão (em inglês): a referência oficial do println!, com links para print! e eprintln!.
• format! — documentação da biblioteca padrão (em inglês): como montar uma String com as mesmas regras de formatação.