Pular para o conteúdo
Rust em Português

Lição 3 de 18 · 15 min

Olá, mundo e o Cargo

Crie seu primeiro projeto com cargo new, entenda o Cargo.toml e o main.rs, compile, rode e formate textos com println!.

Ao terminar, você vai saber:

  • Criar um projeto novo com cargo new
  • Entender o papel do Cargo.toml e do src/main.rs
  • Usar cargo run, cargo build, cargo build --release e cargo check
  • Imprimir valores com println! usando {} e {:?}

Daria para compilar um arquivo solto com rustc main.rs, mas quase ninguém faz isso no dia a dia. Quem organiza os projetos em Rust é o Cargo: ele cria a estrutura de pastas, compila, roda, testa e baixa bibliotecas. Nesta lição você vai usar os comandos que vai repetir pelo resto da vida de rustacean (é assim que a comunidade se chama).

Criando o projeto

No terminal, vá até a pasta onde guarda seus projetos e rode:

cargo new ola_mundo
cd ola_mundo

O Cargo cria uma pasta com esta estrutura:

ola_mundo/
├── Cargo.toml
└── src/
    └── main.rs

Ele também inicia um repositório Git e cria um .gitignore, porque já assume que você vai versionar o código.

O Cargo.toml

Abra o Cargo.toml. Ele é a ficha cadastral do projeto:

[package]
name = "ola_mundo"
version = "0.1.0"
edition = "2024"

[dependencies]
  • name: o nome do seu crate (o pacote, a unidade que o Rust compila).
  • version: a versão do seu programa, que você controla.
  • edition: a edição da linguagem. As edições agrupam pequenas mudanças de sintaxe; esta trilha usa a edição 2024.
  • [dependencies]: onde entram as bibliotecas externas. Por enquanto, nenhuma.

O formato do arquivo se chama TOML, e é bem simples: chave, sinal de igual, valor.

O main.rs

Agora abra src/main.rs:

fn main() {
    println!("Hello, world!");
}
  • fn main() declara a função main. Todo programa executável começa por ela.
  • As chaves { } marcam o corpo da função.
  • println! imprime uma linha no terminal. O ponto de exclamação indica que é uma macro, e não uma função comum. Macros geram código na hora da compilação. Por enquanto, basta lembrar: tem !, é macro.
  • A linha termina com ponto e vírgula.

Troque o texto para português, porque aqui a gente fala a nossa língua:

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

Rodando com cargo run

cargo run

O Cargo compila e já executa. A saída é parecida com esta:

   Compiling ola_mundo v0.1.0 (/home/voce/ola_mundo)
    Finished `dev` profile [unoptimized + debuginfo] target(s)
     Running `target/debug/ola_mundo`
Olá, mundo!

Rode de novo sem mudar nada e repare: ele não compila outra vez, só executa. O Cargo sabe que nada mudou.

Só compilar: cargo build

cargo build

Esse comando compila sem rodar. O executável fica em target/debug/ola_mundo (no Windows, target\debug\ola_mundo.exe). Você pode chamá-lo direto:

./target/debug/ola_mundo

A pasta target guarda tudo que o Cargo gera. Ela pode ficar grande, e não vai para o Git.

Versão otimizada: cargo build –release

O modo padrão (debug) compila rápido, mas gera um programa mais lento e cheio de informações para depuração. Quando for entregar o programa para alguém usar, compile em modo release:

cargo build --release

O resultado vai para target/release/. A compilação demora mais, porque o compilador gasta tempo otimizando, mas o programa final fica bem mais rápido. É como a diferença entre o rascunho e a versão passada a limpo.

Conferir sem gerar nada: cargo check

cargo check

Esse comando confere se o código compila, mas não gera o executável. Por isso é bem mais rápido. Muita gente roda cargo check o tempo todo enquanto escreve, e só usa cargo run quando quer ver o resultado.

Formatando a saída com println!

O println! aceita marcadores entre chaves que são trocados por valores.

O marcador {}

O {} mostra o valor do jeito “bonito”, pensado para quem vai ler:

fn main() {
    let nome = "Carla";
    let idade = 29;

    // Valores passados depois do texto, na ordem
    println!("{} tem {} anos.", nome, idade);

    // Ou o nome da variável direto dentro das chaves
    println!("{nome} tem {idade} anos.");
}

As duas linhas imprimem a mesma coisa. A segunda forma é mais curta e mais fácil de ler, então vamos preferir ela.

O marcador {:?}

Alguns valores não têm um jeito “bonito” de serem mostrados. Uma lista, por exemplo. Para eles existe o {:?}, o formato de depuração, pensado para quem programa:

fn main() {
    let frutas = ["caju", "açaí", "cupuaçu"];
    let ponto = (3, 7);

    println!("{:?}", frutas);
    println!("{ponto:?}");

    // {:#?} faz a mesma coisa, mas quebra em várias linhas
    println!("{frutas:#?}");
}

Saída:

["caju", "açaí", "cupuaçu"]
(3, 7)
[
    "caju",
    "açaí",
    "cupuaçu",
]

Repare que as aspas aparecem: o formato de depuração mostra o valor exatamente como ele é.

Se você tentar println!("{}", frutas), o compilador reclama que arrays não sabem se mostrar com {} e sugere usar {:?}. Mais um caso do compilador dando a dica.

Outros truques úteis

fn main() {
    let preco = 7.5;

    // Duas casas decimais
    println!("Preço: R$ {preco:.2}");

    // print! não pula linha no final
    print!("Carregando");
    print!("...");
    println!(" pronto!");
}

Saída:

Preço: R$ 7.50
Carregando... pronto!

Resumo

  • cargo new nome cria o projeto com Cargo.toml e src/main.rs.
  • cargo run compila e roda; cargo build só compila; cargo build --release gera a versão otimizada; cargo check só confere.
  • println! é uma macro; {} mostra o valor para quem lê e {:?} mostra para quem programa.
  • {valor:.2} limita as casas decimais.

Desafio

Crie um projeto chamado cardapio com o Cargo. No main, guarde o nome de um prato, o preço e uma lista com três ingredientes. Imprima o nome e o preço com duas casas decimais usando {} e a lista de ingredientes usando {:?}.

Ver uma resposta
fn main() {
    let prato = "Baião de dois";
    let preco = 32.9;
    let ingredientes = ["arroz", "feijão verde", "queijo coalho"];

    println!("Prato: {prato}");
    println!("Preço: R$ {preco:.2}");
    println!("Ingredientes: {ingredientes:?}");
}

Para criar e rodar:

cargo new cardapio
cd cardapio
cargo run
Salvo só neste navegador.