FerrousPath

Nivel 1 · Fundamentos· Lección 1 de 10 · 15 min

Primeros pasos

Para qué sirve Rust, cómo instalarlo y tu primer programa construido con Cargo.

Por qué existe Rust

La mayoría de los lenguajes te obligan a elegir. C y C++ te dan control sobre la memoria y un rendimiento predecible, y a cambio toda una familia de errores —uso después de liberar (use-after-free), doble liberación, carreras de datos, desbordamientos de búfer— queda bajo tu responsabilidad. Java, Go, Python y JavaScript eliminan esos errores con un recolector de basura y un runtime, y a cambio renuncias a controlar cuándo se libera la memoria y cómo se disponen los datos.

Lo que Rust afirma es que no tienes que elegir. No tiene recolector de basura ni un runtime obligatorio, y aun así los programas escritos en Rust seguro no pueden tener errores de uso después de liberar ni carreras de datos. El compilador demuestra que no existen antes de que tu programa llegue a ejecutarse, mediante un conjunto de reglas llamado propiedad (ownership) que conocerás en la lección 4.

El precio se paga en tiempo de compilación: el compilador rechaza los programas cuya seguridad no puede demostrar, y al principio rechazará muchos de los tuyos. Este curso trata en gran parte de aprender a pensar como piensa el compilador, hasta que sus reglas te parezcan una descripción del buen diseño y no un obstáculo.

Instala las herramientas

Rust se instala con rustup, que gestiona por ti las versiones del compilador.

  • Windows: descarga y ejecuta rustup-init.exe desde rustup.rs. Te pedirá que instales las herramientas de compilación de C++ de Visual Studio si no las tienes.
  • macOS / Linux: ejecuta el instalador de una línea que aparece en rustup.rs.

Después abre una terminal nueva y comprueba:

rustc --version
cargo --version

Ahora tienes tres herramientas:

Herramienta Función
rustup Instala y actualiza las toolchains (rustup update)
rustc El compilador. Rara vez lo llamarás directamente
cargo Herramienta de compilación, gestor de paquetes, ejecutor de pruebas: tu herramienta diaria

Como editor, instala rust-analyzer (es una extensión para VS Code y para la mayoría de los demás editores). Muestra los tipos y los errores mientras escribes y es casi imprescindible.

Puedes saltarte la instalación por ahora. Todos los ejemplos de este curso tienen un botón Ejecutar que compila el código en el Rust Playground oficial. Instala Rust en tu máquina cuando llegues al primer proyecto.

Hola, mundo

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

Pulsa Ejecutar. Después pulsa Editar, cambia el mensaje y ejecútalo de nuevo.

Fíjate en tres cosas:

  1. fn main() declara la función por la que empieza todo ejecutable.
  2. println! lleva un ! porque es una macro, no una función. Las macros generan código en tiempo de compilación; esta comprueba tu cadena de formato contra sus argumentos.
  3. Las sentencias terminan en punto y coma y los bloques usan llaves. La sangría es de cuatro espacios por convención: cargo fmt la aplicará por ti.

Tu primer proyecto con Cargo

cargo new hello
cd hello
cargo run

cargo new crea esta estructura:

hello/
├── Cargo.toml      # nombre del paquete, versión, edición, dependencias
└── src/
    └── main.rs     # tu código

Los comandos que usarás todos los días:

Comando Qué hace
cargo check Comprueba los tipos rápidamente, sin generar un binario
cargo run Compila y ejecuta (modo debug: compila rápido, se ejecuta lento)
cargo run --release Compila con optimizaciones
cargo test Ejecuta las pruebas
cargo fmt Formatea el código con el estilo estándar
cargo clippy Linter: cientos de comprobaciones de errores y de código poco idiomático
cargo doc --open Genera y abre la documentación de tu crate y de sus dependencias

Imprimir valores

println! usa marcadores {}. Puedes poner el nombre de una variable directamente dentro de las llaves.

fn main() {
    let language = "Rust";
    let year = 2015;
    println!("{language} 1.0 was released in {year}.");
    println!("{} + {} = {}", 2, 3, 2 + 3);
    println!("debug view: {:?}", (language, year));
    println!("padded: [{:>8}] [{:<8}] [{:08.3}]", "right", "left", 3.14159);
}

{} es para la salida destinada al usuario; {:?} es el formato de depuración (debug), que funciona con casi todos los tipos y es el que usarás cuando investigues un problema.

Leer un error del compilador

Ejecuta esto. Falla a propósito.

fn main() {
    let answer = 42;
    println!("The answer is {anwser}"); // ❌ error[E0425]
}

Lee el mensaje entero. Tiene un código de error (E0425), la ubicación exacta y una sugerencia con el nombre que probablemente querías escribir. Los diagnósticos de Rust están escritos para ser leídos, y puedes obtener una explicación más larga de cualquier código con rustc --explain E0425. Acostúmbrate a leer los errores de arriba abajo antes de cambiar nada: el primer error suele ser el de verdad.

Ejercicios

  1. Cambia el programa hola-mundo para que imprima tu nombre en una línea y tu número favorito en la siguiente, usando una variable para cada uno.
  2. Imprime el valor de 7 / 2 y después el de 7.0 / 2.0. Explícate la diferencia antes de seguir (la próxima lección la confirma).
  3. Instala Rust en tu máquina, ejecuta cargo new playground y ejecuta cargo clippy dentro.
Solución del 2
fn main() {
    println!("{}", 7 / 2);     // 3   — los dos operandos son enteros, así que es una división entera
    println!("{}", 7.0 / 2.0); // 3.5 — división en coma flotante
}

Rust nunca convierte implícitamente entre tipos enteros y de coma flotante.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué herramienta usas para crear, compilar y ejecutar un proyecto de Rust?

  2. 2.¿Por qué println! termina con un signo de exclamación?

  3. 3.¿Qué hace cargo check?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?