Learn Rust Coding · Aula

Fundamentos do Cargo

Compile e execute

Fundamentos do Cargo é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What Is Cargo?

Cargo is Rust's build system and package manager. It compiles your code, downloads dependencies, runs tests, and builds documentation.

Comes bundled with the Rust toolchain
Manages a project's Cargo.toml manifest
Handles the whole build lifecycle for you

Creating a New Project

Use cargo new to scaffold a binary project. It creates a directory with a src/main.rs and a Cargo.toml.

cargo new my_app makes a binary crate
cargo new my_lib --lib makes a library crate

cargo new my_app
cd my_app

The Default main.rs

A fresh binary project starts with a tiny main.rs. The main function is the entry point of every Rust binary.

fn main() {
    println!("Hello, world!");
}

Building with cargo build

cargo build compiles your project into the target/debug directory. The first build also resolves and compiles dependencies.

Debug builds are unoptimized but fast to compile
The binary lands in target/debug/my_app

cargo build

Running with cargo run

cargo run builds (if needed) and then runs the binary in one step. It's the fastest way to iterate during development.

fn main() {
    let name = "Cargo";
    println!("Running with {name}!");
}

Checking with cargo check

cargo check analyzes your code for errors without producing a binary. It is much faster than a full build and ideal for tight edit-compile loops.

cargo check

Release Builds

Add --release to enable optimizations. Release builds are slower to compile but produce faster binaries placed in target/release.

cargo build --release
cargo run --release

Passing Arguments

Arguments after -- are passed to your program, not to Cargo. Read them with std::env::args.

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("Got {} arguments", args.len());
    for arg in &args {
        println!("{arg}");
    }
}

Cleaning Artifacts

cargo clean deletes the target directory, removing all compiled output. Use it to force a fresh build or reclaim disk space.

cargo clean

The Cargo.lock File

Cargo records the exact resolved dependency versions in Cargo.lock.

For binaries: commit it for reproducible builds
For libraries: usually not committed
It is generated and updated automatically

Common Cargo Commands

A quick reference of the everyday commands:

cargo new — create a project
cargo build — compile
cargo run — build and run
cargo check — fast error check
cargo test — run tests
cargo doc — build docs

Quick Check

Which command compiles your code without producing an executable binary?

Recap

You learned the core Cargo workflow:

cargo new scaffolds projects
cargo build compiles, cargo run builds and runs
cargo check is the fast error check
--release enables optimizations
Cargo.lock pins dependency versions

Cargo is the backbone of every Rust project.

Perguntas Frequentes

A aula “Fundamentos do Cargo” é grátis?

Sim — o texto completo de “Fundamentos do Cargo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Fundamentos do Cargo”?

Compile e execute Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Fundamentos do Cargo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding