Learn Rust Coding · Lección

Fundamentos de Cargo

Compilar y ejecutar

Fundamentos de Cargo es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en 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.

Preguntas frecuentes

¿La lección «Fundamentos de Cargo» es gratis?

Sí — el texto completo de «Fundamentos de Cargo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Fundamentos de Cargo»?

Compilar y ejecutar Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de Cargo»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding