Até o momento aprendemos a como declarar variáveis e constantes, estudamos vários operadores, casting de tipos e etc. Porém, precisamos estudar também como recuperar informações digitadas pelo usuário e também como exibir informações na saída padrão.

Rust também fornece formas para exibição de informações na saída de erro padrão. Porém, essas serão vistas em Rust: Tratando erros.

A formatação de dados númericos, structs, enum, formatação com alinhamento, casas decimais e outros podem ser vistos com mais detalhes em Rust: Formatação de dados

Para a exibição de informações vamos utilizar as macros println! e print!. Essas macros permitem a exibição de informações na saída padrão(stdout). A primeira macro adiciona uma quebra de linha na saída.

Sintaxe

println!(<string>, valor1, …, valorN)
print!(<string>, valor1, …, valorN)

Onde

<string>: Uma string formatada exibição dos dados. Formatação opcional
valor1…N: Valores que desejamos exibir. Esses argumentos são opcionais.

Exemplo 1

fn main() {

 //com quebra de linha
 println!("Hello,");
 println!("Rust!");
   
 //sem quebra e linha
 print!("Hello,");
 print!("Rust!");
}

Saída

Hello,
Rust!
Hello,Rust!

Com essa mesma macro println! por exemplo, podemos formatar as informações utilizando um placeholder ({}). Cada valor passado como argumento para formatação ficará associado a um placeholder.

Sintaxe

println!("{},{},...", valor1, valor2, ...)

Exemplo 2

fn main() {

    let valor1:u8 = 255;
    println!("{},{}","Hello","World");
    println!("Valor:{}",valor1);
}

Saída

Hello,World
Valor:255

Para impressão de tipos mais complexos de dados como array, struct e outros, utilizamos o identificador de formatação (:?) dentro de um placeholder. A formato da saída é de acordo com o padrão definido para o tipo.

Sintaxe

println!("{:?}", nome_variavel)

Exemplo 3

fn main() 
{
    let valores = [1,2,3];
    println!("{:?}", valores);
}

Saída

[1, 2, 3]

A uma formatação customizada de structs, por exemplo, é necessário a implementação de Traits especfíficas para saída de dados. O assunto Trait será visto com mais detalhes em Rust: POO >Traits e Rust: Formatação.

Outra forma para formatação utilizando os placeholders é utilizando interpolação de string. Nessa forma, a própria da variável é declarada dentro de um placeholder como mostrado abaixo:

Sintaxe

println!("{nome_variavel}")

Exemplo 4

fn main() 
{
    let variavel:i8=100;
    println!("{variavel}");
}

Saída

100

Para capturar palavras ou valores digitados pelos usuários, Rust fornece a função nativa read_line que pertence à biblioteca std::io.

Sintaxe

use std::io

Sintaxe

read_line(<buf>: &mut String) -> Result<usize>

A conversão da informação digitada não é feita automaticamente por essa função, sendo necessário utilizar funções para conversão de dados. Além dessas, outros tratamentos como remoção de espaço devem ser feitos.

Sintaxe

variavel_string.parse()

Como o usuário pode inserir uma valor que não seja possível a conversão, o tratamento dessas s ituações deve ser feito. Mais sobre tratamento de erros será visto em Rust: Tratando Erros.

No exemplo abaixo vamos utilizar o construtor String::new para criar um string. O método unwrap recupera o valor contido no retorno(Result) do método parse que faz a "conversão" da entrada.

O método trim é usado para remover espaços em branco do início e fim da string que armazena o valor capturado por read_line.

O comando match é um comando de escolha semelhante ao switch de outras linguagens. No exemplo abaixo, o match é usado para verificar o retorno do método parse.

Exemplo 5

use std::io;

fn main() 
{
    let mut nome: String = String::new();
    
    println!("Digite uma string:");
    let _ = io::stdin().read_line(&mut nome); //sem tratamento de erro
    println!("{}",nome);
    
    println!("{}","Digite um número inteiro:");
    let mut inum: String = String::new();
    let _ = io::stdin().read_line(&mut inum);
    //Result
    match inum.trim().parse::<i32>() {
        Ok(n) => println!("{}", n),
        Err(e) => println!("Erro: {}", e),
    }

    println!("{}","Digite um número float:");  
    let mut fnum: String = String::new();
    let _ = io::stdin().read_line(&mut fnum);
    //Sem Result
    let vfloat: f64 = fnum.trim().parse().unwrap();
    println!("{}",vfloat); 
    /*
}

Entrada

Rust
10
1.9

Saída

Digite uma string
Rust
Digite um inteiro
10
Digite um float
1.9

1. 12/11/2025 - versão inicial