Tutorial Rust: Aprende Rust paso a paso para programadores principiantes

Introducción

Rust se ha consolidado como un lenguaje de programación moderno y eficiente, ideal para quienes buscan rendimiento y seguridad en sus aplicaciones. En este tutorial Rust, te guiaré paso a paso para que, como programador principiante, puedas dominar los conceptos básicos Rust y comenzar a escribir código con confianza.

Este tutorial está enfocado en programación Rust para principiantes, explicando desde la instalación hasta conceptos avanzados como ownership y borrowing.

¡Comencemos!

Instalación del entorno para Rust

Antes de escribir código, debemos preparar nuestro entorno.

Paso 1: Instalar Rust con rustup

Rust recomienda usar rustup, un instalador y gestor de versiones.

Abre una terminal (PowerShell en Windows, Terminal en macOS o Linux).
Ejecuta el siguiente comando para instalar Rust:

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

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

Sigue las instrucciones en pantalla (normalmente la opción por defecto es adecuada).
Cuando termine, cierra y abre nuevamente la terminal, o ejecuta:

source $HOME/.cargo/env

1 2	source $HOME/.cargo/env

Paso 2: Verificar la instalación

Para comprobar que Rust está correctamente instalado, escribe:

rustc --version

1 2	rustc --version

Deberías ver la versión de Rust instalada, algo así como:

rustc 1.70.0 (90c541806 2024-06-xx)

1 2	rustc 1.70.0 (90c541806 2024-06-xx)

Paso 3: Usar Cargo

Cargo es la herramienta de gestión de proyectos y dependencias que viene con Rust. Verifica que funciona:

cargo --version

1 2	cargo --version

Conceptos básicos del lenguaje Rust

Crear y ejecutar un proyecto nuevo

Rust facilita iniciar proyectos con Cargo:

cargo new hola_mundo
cd hola_mundo

cargo new hola_mundo

cd hola_mundo

Esto crea una carpeta llamada hola_mundo con la estructura básica.

Para ejecutar el programa de ejemplo:

cargo run

cargo run

Deberías ver:

Hola, mundo!

1 2	Hola, mundo!

Estructura básica de un programa Rust

Veamos el contenido del archivo src/main.rs:

fn main() {
    println!("Hola, mundo!");
}

fn main() {

println!("Hola, mundo!");

}

fn main() define la función principal.
println! es una macro que imprime texto en la consola.

Manejo de variables

Declarar variables mutables e inmutables

Por defecto, las variables en Rust son inmutables.

fn main() {
    let x = 5; // Inmutable
    println!("x: {}", x);

    let mut y = 10; // Mutable
    println!("y antes: {}", y);
    y = 15;
    println!("y después: {}", y);
}

fn main() {

let x = 5; // Inmutable

println!("x: {}", x);

let mut y = 10; // Mutable

println!("y antes: {}", y);

y = 15;

println!("y después: {}", y);

}

let declara la variable.
mut indica que se puede modificar.

Tipos de datos básicos

Rust tiene tipos estáticos. Algunos ejemplos:

let entero: i32 = 42;
let flotante: f64 = 3.14;
let booleano: bool = true;
let caracter: char = '⭐';
let cadena: &str = "hola";

let entero: i32 = 42;

let flotante: f64 = 3.14;

let booleano: bool = true;

let caracter: char = '⭐';

let cadena: &str = "hola";

Puedes indicar el tipo explícitamente o que Rust lo infiera.

Funciones

Las funciones son bloques reutilizables de código.

fn saludar(nombre: &str) {
    println!("Hola, {}!", nombre);
}

fn main() {
    saludar("Mundo");
}

fn saludar(nombre: &str) {

println!("Hola, {}!", nombre);

}

fn main() {

saludar("Mundo");

}

Funciones que retornan valores

fn suma(a: i32, b: i32) -> i32 {
    a + b // no se usa ; para indicar el valor devuelto
}

fn main() {
    let resultado = suma(3, 4);
    println!("3 + 4 = {}", resultado);
}

fn suma(a: i32, b: i32) -> i32 {

a + b // no se usa ; para indicar el valor devuelto

}

fn main() {

let resultado = suma(3, 4);

println!("3 + 4 = {}", resultado);

}

Control de flujo

Condicionales: if / else

fn main() {
    let edad = 18;

    if edad >= 18 {
        println!("Eres mayor de edad");
    } else {
        println!("Eres menor de edad");
    }
}

fn main() {

let edad = 18;

if edad >= 18 {

println!("Eres mayor de edad");

} else {

println!("Eres menor de edad");

}

Bucles: loop, while, for

fn main() {
    // loop infinito hasta break
    let mut contador = 0;
    loop {
        contador += 1;
        println!("Contador: {}", contador);
        if contador == 5 {
            break;
        }
    }

    // while
    let mut n = 3;
    while n > 0 {
        println!("{}...", n);
        n -= 1;
    }

    // for
    for i in 1..=3 {
        println!("for i = {}", i);
    }
}

fn main() {

// loop infinito hasta break

let mut contador = 0;

loop {

contador += 1;

println!("Contador: {}", contador);

if contador == 5 {

break;

}

// while

let mut n = 3;

while n > 0 {

println!("{}...", n);

n -= 1;

}

// for

for i in 1..=3 {

println!("for i = {}", i);

}

Concepts fundamental: Ownership y Borrowing

Rust introduce un sistema único para gestionar memoria de forma segura sin un recolector de basura.

Ownership (Propiedad)

Cada valor en Rust tiene un único propietario (variable), y cuando este sale de alcance, Rust libera la memoria automáticamente.

fn main() {
    let s1 = String::from("Hola"); // s1 es dueño
    let s2 = s1;                   // ownership movido a s2
    // println!("{}", s1);        // ERROR, s1 ya no es válido
    println!("{}", s2);          // OK
}

fn main() {

let s1 = String::from("Hola"); // s1 es dueño

let s2 = s1; // ownership movido a s2

// println!("{}", s1); // ERROR, s1 ya no es válido

println!("{}", s2); // OK

}

Se dice que s1 fue movido a s2. Esto evita condiciones de carrera y frees dobles.

Borrowing (Préstamo)

Puedes prestar el valor a otra función sin transferir la propiedad, usando referencias.

fn imprimir(cadena: &String) {
    println!("La cadena es: {}", cadena);
}

fn main() {
    let s = String::from("Rust");
    imprimir(&s); // prestamo inmutable
    println!("Todavía puedo usar s: {}", s);
}

fn imprimir(cadena: &String) {

println!("La cadena es: {}", cadena);

}

fn main() {

let s = String::from("Rust");

imprimir(&s); // prestamo inmutable

println!("Todavía puedo usar s: {}", s);

}

Reglas importantes

Solo puede haber una referencia mutable o múltiples referencias inmutables simultáneamente.
No puedes modificar algo mientras está siendo prestado.

fn main() {
    let mut s = String::from("Hola");
    let r1 = &s; // referencia inmutable
    let r2 = &s; // otra referencia inmutable
    println!("{} y {}", r1, r2);

    // let r3 = &mut s;  // ERROR: no se puede tener mutable con otras inmutables
}

fn main() {

let mut s = String::from("Hola");

let r1 = &s; // referencia inmutable

let r2 = &s; // otra referencia inmutable

println!("{} y {}", r1, r2);

// let r3 = &mut s; // ERROR: no se puede tener mutable con otras inmutables

}

Esto garantiza seguridad en concurrencia y gestión de memoria.

Conclusión y buenas prácticas

Hemos recorrido un tutorial Rust para principiantes muy completo desde la instalación, pasando por básicos de variables, funciones y control de flujo, hasta los poderosos conceptos de ownership y borrowing que definen Rust.

¿Qué sigue?

Practica creando pequeños proyectos.
Lee la documentación oficial The Rust Programming Language.
Experimenta con crates (bibliotecas) y la gestión mediante Cargo.

Llamada a la acción

Si te ha gustado este tutorial Rust y quieres seguir aprendiendo programación Rust para principiantes, suscríbete a nuestro blog y comparte este artículo con otros que también quieran dominar conceptos básicos Rust.

Buenas prácticas para aprender Rust:

Lee y escribe código menudo: la mejor manera de aprender es practicar.
Entiende ownership y borrowing desde el principio: te evitará muchos errores.
Usa herramientas como cargo check y rustfmt para mejorar tu código.
Lee los mensajes del compilador: son claros y te ayudan a corregir código.

¡Feliz codificación en Rust! 🚀