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çãomain. 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 nomecria o projeto comCargo.tomlesrc/main.rs.cargo runcompila e roda;cargo buildsó compila;cargo build --releasegera a versão otimizada;cargo checksó 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