Empezar con Rust

Vamos a poner Rust a funcionar en tu computadora y a crear tu primer programa. Si prefieres no instalar nada todavía, puedes seguir la lección en el Rust Playground (un entorno para ejecutar Rust en el navegador) y volver a esta página más tarde.

Paso 1: Instala Rust con rustup

La forma oficial de instalar Rust es con una herramienta llamada rustup. Instala el compilador de Rust y Cargo (la herramienta de compilación y gestión de proyectos), y mantiene todo actualizado.

Entra en rustup.rs y sigue las instrucciones para tu sistema:

• Windows: descarga y ejecuta rustup-init.exe, y acepta las opciones por defecto.

• macOS / Linux: pega esto en tu terminal:

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Nota

En Windows, Rust necesita las herramientas de compilación de C++. Si el instalador te lo pide, deja que instale las “Visual Studio C++ Build Tools”. Rust las usa para enlazar tus programas.

Paso 2: Comprueba que funcionó

Cierra la terminal, vuelve a abrirla y ejecuta:

rustc --version
cargo --version

Deberías ver números de versión como rustc 1.xx.0. Si los ves, ya está todo listo.

• rustc es el compilador de Rust (convierte tu código en un programa).
• cargo es la herramienta todo en uno de Rust para compilar, ejecutar, probar y gestionar proyectos. Vas a usar cargo para casi todo.

Paso 3: Crea tu primer proyecto

En lugar de crear los archivos a mano, deja que cargo prepare el proyecto por ti:

cargo new hello_rust
cd hello_rust

Esto crea una carpeta llamada hello_rust con todo lo que necesita un proyecto de Rust:

hello_rust/
├── Cargo.toml      # configuración y dependencias del proyecto
└── src/
    └── main.rs     # aquí va tu código

• Cargo.toml describe tu proyecto (su nombre, su versión y las bibliotecas que usa).
• src/main.rs es el archivo de inicio. ¡cargo incluso lo rellena con un Hola Mundo por ti!

Paso 4: Ejecútalo

Desde dentro de la carpeta del proyecto, ejecuta:

cargo run

Verás que cargo compila el proyecto y luego muestra:

Hello, world!

Listo: acabas de compilar y ejecutar un programa en Rust. (El mensaje sale en inglés porque es el que cargo escribe por defecto).

Entender el código

Abre src/main.rs y encontrarás esto:

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

• fn main() { ... } define la función principal. Todo programa de Rust empieza a ejecutarse aquí.
• println!("...") muestra una línea de texto en la pantalla.

Prueba a cambiar el mensaje y vuelve a ejecutar cargo run:

fn main() {
    println!("¡Hola desde mi primer programa en Rust!");
}

Salida:

¡Hola desde mi primer programa en Rust!

▶ Pruébalo tú mismo

cargo run vs. cargo build

Dos comandos que vas a usar todo el tiempo:

Comando	Qué hace
cargo run	Compila y ejecuta tu programa (lo mejor mientras desarrollas)
cargo build	Solo lo compila; el programa queda en target/debug/
cargo build --release	Compila una versión optimizada y más rápida para publicar

Cuando algo sale mal: leer los errores del compilador

Vas a ver errores del compilador todos los días, incluso después de años usando Rust. No significan que lo estés haciendo mal. Son el compilador haciendo su trabajo. Provoquemos uno a propósito para que la primera vez no asuste tanto.

Quita el ! de println! en src/main.rs:

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

Ejecuta cargo run y obtendrás:

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Hello, world!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Hello, world!");
  |            +

El compilador siempre escribe sus mensajes en inglés. Léelo de arriba abajo:

1. La primera línea dice qué está mal: Rust esperaba una función (expected function), pero println es una macro (found macro). En la próxima página verás qué significa eso.
2. --> src/main.rs:2:5 te dice dónde: el archivo src/main.rs, línea 2, columna 5.
3. Las marcas ^^^^^^^ señalan el trozo exacto de código (not a function: no es una función).
4. La parte help: a menudo te muestra cómo arreglarlo. Aquí incluso marca con un + el ! que falta (use ! to invoke the macro: usa ! para invocar la macro).

Vuelve a poner el ! y todo funciona otra vez:

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

Salida:

Hello, world!

▶ Pruébalo tú mismo

Una comprobación más rápida

cargo check busca errores sin generar un programa ejecutable. En proyectos grandes es mucho más rápido que cargo build, así que mucha gente lo ejecuta constantemente mientras escribe código. El código E0423 también se puede buscar: rustc --explain E0423 muestra una explicación más larga, con ejemplos (en inglés).

Paso 5: Configura tu editor (recomendado)

Para trabajar más cómodo, instala la extensión rust-analyzer en tu editor. Te da autocompletado, mensajes de error en línea y pistas de tipos mientras escribes.

• VS Code: instala la extensión rust-analyzer
• La mayoría de los demás editores (JetBrains, Neovim, etc.) también son compatibles con rust-analyzer.

Consejo

Mientras aprendes, ten a la vista los mensajes de error del compilador. Los errores de Rust son famosos por lo útiles que son: normalmente explican qué salió mal y cómo arreglarlo.

Práctica

1. Tres líneas

Haz que tu programa imprima tres líneas: tu nombre, tu comida favorita y ¡Acabo de ejecutar Rust!. Pista: un println! imprime una línea, así que usa tres.

Ver solución

fn main() {
    println!("Me llamo Sam");
    println!("Me gusta la pizza");
    println!("¡Acabo de ejecutar Rust!");
}

Salida:

Me llamo Sam
Me gusta la pizza
¡Acabo de ejecutar Rust!

▶ Pruébalo tú mismo

2. Un pequeño cartel

Imprime un cartel pequeño como el de abajo, con una línea de signos = arriba y abajo de un título. Luego rómpelo a propósito borrando un !, ejecuta cargo run, lee el error y arréglalo. Pista: las líneas de = son solo texto dentro de println!, como cualquier otro mensaje.

Ver solución

fn main() {
    println!("==============");
    println!("  HOLA, RUST");
    println!("==============");
}

Salida:

==============
  HOLA, RUST
==============

▶ Pruébalo tú mismo

Resumen

• Instala Rust con rustup desde rustup.rs.
• Compruébalo con rustc --version y cargo --version.
• Crea un proyecto con cargo new y ejecútalo con cargo run.
• Un proyecto tiene un Cargo.toml (configuración) y un src/main.rs (tu código).
• Lee los errores del compilador de arriba abajo: qué pasó, dónde, y a menudo un help: con la solución.
• Instala rust-analyzer en tu editor para que todo sea mucho más fácil.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué herramienta instala el compilador de Rust y cargo, y los mantiene actualizados?

rustup cargo rustc

2. ¿Qué archivo describe el nombre, la versión y las dependencias de un proyecto de Rust?

src/main.rs target/debug/ Cargo.toml

3. ¿Qué comando solo compila tu programa, sin ejecutarlo?

cargo run cargo build cargo new

Puntuación: 0 / 3

Para leer más

• Installation: The Rust Book (en inglés): cómo instalar Rust en cada plataforma, actualizarlo con rustup update y resolver problemas.
• Hello, Cargo!: The Rust Book (en inglés): una mirada más detallada a cargo new, cargo build, cargo run y cargo check.
• First Steps with Cargo: The Cargo Book (en inglés): qué crea cargo new y qué significa cada línea de Cargo.toml.
• The rustup book (en inglés): instalar toolchains adicionales, actualizar Rust y cambiar entre stable y nightly.
• rust-analyzer (en inglés): guías de configuración para VS Code, Neovim, Emacs y otros editores.