19 abril 2025
Rust captura constantemente el interés de los desarrolladores, asegurándose el título de lenguaje de programación “más amado” en las encuestas de Stack Overflow durante varios años consecutivos. Esto no es solo publicidad; Rust ofrece una combinación atractiva de rendimiento, seguridad y características de lenguaje modernas que abordan puntos débiles comunes encontrados en otros lenguajes de programación de sistemas. Si tienes curiosidad sobre qué hace especial a Rust y quieres comenzar tu viaje, esta guía para principiantes proporciona el conocimiento fundamental para empezar. Exploraremos la sintaxis central, conceptos únicos como la propiedad (ownership) y las herramientas esenciales que impulsan el ecosistema de Rust.
Rust se posiciona como un lenguaje para construir software fiable y eficiente. Sus ventajas principales giran en torno a la seguridad de memoria sin depender de un recolector de basura y habilitando la concurrencia sin miedo. He aquí por qué deberías considerar aprender Rust:
Antes de escribir tu primera línea de código Rust, necesitas configurar el toolchain de Rust. La forma estándar y recomendada de instalar Rust es usando rustup, el instalador del toolchain de Rust.
rustup: Esta herramienta de línea de comandos gestiona tus instalaciones de Rust. Te permite instalar, actualizar y cambiar fácilmente entre diferentes versiones de Rust (como estable, beta o nightly). Visita el sitio web oficial de Rust (https://www.rust-lang.org/tools/install) para instrucciones de instalación específicas para tu sistema operativo.rustc: Este es el compilador de Rust. Después de escribir tu código fuente de Rust en archivos .rs, rustc los compila en binarios ejecutables o bibliotecas que tu computadora puede entender. Aunque es crucial, típicamente no invocarás rustc directamente muy a menudo en tu flujo de trabajo diario.cargo: Este es el sistema de compilación y gestor de paquetes de Rust, y es la herramienta con la que interactuarás más frecuentemente. Cargo orquesta muchas tareas comunes de desarrollo:
cargo new).cargo build).cargo run).cargo test).Cargo.toml).Para experimentación rápida sin necesidad de una instalación local, plataformas en línea como el Rust Playground oficial o entornos de desarrollo integrados como Replit son excelentes opciones.
Comencemos con el tradicional programa "¡Hola, mundo!", un rito de iniciación para aprender cualquier nuevo lenguaje. Crea un archivo llamado main.rs y añade el siguiente código:
fn main() {
// Esta línea imprime texto en la consola
println!("Hello, Rust!");
}
Para compilar y ejecutar este simple programa usando las herramientas básicas:
main.rs, y ejecuta:
rustc main.rs
rustc), que crea un archivo ejecutable (p. ej., main en Linux/macOS, main.exe en Windows)../main
# En Windows, usa: .\main.exe
Sin embargo, para cualquier cosa más allá de un solo archivo, usar Cargo es el enfoque estándar y mucho más conveniente:
cargo new hello_rust
cd hello_rust
hello_rust que contiene un subdirectorio src con main.rs (ya poblado con el código "Hello, Rust!") y un archivo de configuración llamado Cargo.toml.cargo run
Desglosemos el fragmento de código:
fn main(): Esto define la función principal. La palabra clave fn significa una declaración de función. main es un nombre de función especial; es el punto de entrada donde cada programa ejecutable de Rust comienza a ejecutarse. Los paréntesis () indican que esta función no toma parámetros de entrada.{}: Las llaves definen un bloque de código o ámbito. Todo el código perteneciente a la función va dentro de estas llaves.println!("Hello, Rust!");: Esta línea realiza la acción de imprimir texto en la consola.
println! es una macro de Rust. Las macros son similares a las funciones pero tienen una diferencia clave: terminan con un signo de exclamación !. Las macros realizan generación de código en tiempo de compilación, ofreciendo más potencia y flexibilidad que las funciones regulares (como manejar un número variable de argumentos, lo cual hace println!). La macro println! imprime el texto proporcionado en la consola y automáticamente añade un carácter de nueva línea al final."Hello, Rust!" es un literal de cadena – una secuencia fija de caracteres que representa texto, encerrada entre comillas dobles.;: El punto y coma marca el final de la sentencia. La mayoría de las líneas de código Rust ejecutable (sentencias) terminan con un punto y coma.Ahora, profundicemos en los bloques de construcción fundamentales del lenguaje de programación Rust.
Las variables se usan para almacenar valores de datos. En Rust, declaras variables usando la palabra clave let.
let manzanas = 5;
let mensaje = "Llévate cinco";
Un concepto central en Rust es que las variables son inmutables por defecto. Esto significa que una vez que un valor está ligado a un nombre de variable, no puedes cambiar ese valor más tarde.
let x = 10;
// x = 15; // ¡Esta línea causará un error en tiempo de compilación! No se puede asignar dos veces a la variable inmutable `x`.
println!("El valor de x es: {}", x); // {} es un marcador de posición para el valor de x
Esta inmutabilidad por defecto es una elección de diseño deliberada que te ayuda a escribir código más seguro y predecible al prevenir la modificación accidental de datos, que puede ser una fuente común de errores. Si necesitas una variable cuyo valor pueda cambiar, debes marcarla explícitamente como mutable usando la palabra clave mut durante la declaración.
let mut contador = 0; // Declara 'contador' como mutable
println!("Contador inicial: {}", contador);
contador = 1; // Esto está permitido porque 'contador' se declaró con 'mut'
println!("Nuevo contador: {}", contador);
Rust también permite el shadowing. Puedes declarar una nueva variable con el mismo nombre que una variable anterior dentro del mismo ámbito. La nueva variable “oculta” (shadows) a la antigua, lo que significa que los usos posteriores del nombre se refieren a la nueva variable. Esto es diferente de la mutación porque estamos creando una variable completamente nueva, que incluso puede tener un tipo diferente.
let espacios = " "; // 'espacios' es inicialmente un slice de cadena (&str)
let espacios = espacios.len(); // 'espacios' ahora es ocultado por una nueva variable que contiene la longitud (un entero, usize)
println!("Número de espacios: {}", espacios); // Imprime el valor entero
Rust es un lenguaje de tipado estático. Esto significa que el tipo de cada variable debe ser conocido por el compilador en tiempo de compilación. Sin embargo, Rust tiene una excelente inferencia de tipos. En muchas situaciones, no necesitas escribir explícitamente el tipo; el compilador a menudo puede deducirlo basándose en el valor y cómo lo usas.
let cantidad = 10; // El compilador infiere i32 (el tipo entero con signo por defecto)
let precio = 9.99; // El compilador infiere f64 (el tipo de punto flotante por defecto)
let activo = true; // El compilador infiere bool (booleano)
let inicial = 'R'; // El compilador infiere char (carácter)
Si quieres o necesitas ser explícito (p. ej., por claridad o cuando el compilador necesita ayuda), puedes proporcionar anotaciones de tipo usando dos puntos : seguidos por el nombre del tipo.
let puntuacion: i32 = 100; // Explícitamente un entero de 32 bits con signo
let ratio: f32 = 0.5; // Explícitamente un flotante de precisión simple
let esta_completo: bool = false; // Explícitamente un booleano
let calificacion: char = 'A'; // Explícitamente un carácter (valor escalar Unicode)
Rust tiene varios tipos escalares incorporados (que representan valores únicos):
i8, i16, i32, i64, i128, isize) almacenan números enteros tanto positivos como negativos. Los enteros sin signo (u8, u16, u32, u64, u128, usize) almacenan solo números enteros no negativos. Los tipos isize y usize dependen de la arquitectura de la computadora (32 bits o 64 bits) y se usan principalmente para indexar colecciones.f32 (precisión simple) y f64 (precisión doble). El predeterminado es f64.bool tiene dos posibles valores: true o false.char representa un único valor escalar Unicode (más completo que solo caracteres ASCII), encerrado entre comillas simples (p. ej., 'z', 'π', '🚀').String vs &strManejar texto en Rust a menudo involucra dos tipos primarios, lo que puede ser confuso para los recién llegados:
&str (pronunciado “string slice” o “slice de cadena”): Es una referencia inmutable a una secuencia de bytes codificados en UTF-8 almacenados en algún lugar de la memoria. Los literales de cadena (como "Hola") son de tipo &'static str, lo que significa que se almacenan directamente en el binario del programa y viven durante toda la duración del programa. Los slices proporcionan una vista de los datos de la cadena sin poseerlos. Son de tamaño fijo.String: Es un tipo de cadena propio, redimensionable, mutable, codificado en UTF-8. Los datos de String se almacenan en el heap, lo que permite redimensionarlos. Típicamente usas String cuando necesitas modificar datos de cadena, o cuando la cadena necesita poseer sus propios datos y gestionar su propio tiempo de vida (a menudo al devolver cadenas desde funciones o almacenarlas en structs).// Literal de cadena (almacenado en el binario del programa, inmutable)
let slice_estatico: &'static str = "Soy inmutable";
// Crear un String propio, alojado en el heap, a partir de un literal
let mut cadena_dinamica: String = String::from("Inicio");
// Modificar el String (posible porque es mutable y posee sus datos)
cadena_dinamica.push_str(" y crecer");
println!("{}", cadena_dinamica); // Salida: Inicio y crecer
// Crear un slice de cadena que referencia parte del String
// Este slice toma prestados datos de cadena_dinamica
let slice_desde_string: &str = &cadena_dinamica[0..5]; // Referencia a "Inicio"
println!("Slice: {}", slice_desde_string);
Las funciones son fundamentales para organizar el código en unidades nombradas y reutilizables. Ya hemos encontrado la función especial main.
// Definición de función
fn saludar(nombre: &str) { // Toma un parámetro: 'nombre', que es un slice de cadena (&str)
println!("¡Hola, {}!", nombre);
}
// Función que toma dos parámetros i32 y devuelve un i32
fn sumar(a: i32, b: i32) -> i32 {
// En Rust, la última expresión en el cuerpo de una función se devuelve automáticamente,
// siempre que no termine con punto y coma.
a + b
// Esto es equivalente a escribir: return a + b;
}
fn main() {
saludar("Alice"); // Llama a la función 'saludar'
let suma = sumar(5, 3); // Llama a 'sumar', liga el valor devuelto a 'suma'
println!("5 + 3 = {}", suma); // Salida: 5 + 3 = 8
}
Puntos clave sobre las funciones:
fn para declarar funciones.->. Si una función no devuelve un valor, su tipo de retorno es implícitamente () (una tupla vacía, a menudo llamada “tipo unitario”).;) y opcionalmente terminan con una expresión (algo que evalúa a un valor).return se puede usar para retornos explícitos y tempranos desde cualquier lugar dentro de la función.Rust proporciona estructuras de flujo de control estándar para determinar el orden en que se ejecuta el código:
if/else/else if: Usado para ejecución condicional.let numero = 6;
if numero % 4 == 0 {
println!("el número es divisible por 4");
} else if numero % 3 == 0 {
println!("el número es divisible por 3"); // Esta rama se ejecuta
} else {
println!("el número no es divisible por 4 ni por 3");
}
// Importante: 'if' es una expresión en Rust, lo que significa que evalúa a un valor.
// Esto te permite usarlo directamente en sentencias 'let'.
let condicion = true;
let valor = if condicion { 5 } else { 6 }; // valor será 5
println!("El valor es: {}", valor);
// Nota: Ambas ramas de la expresión 'if' deben evaluar al mismo tipo.
loop: Crea un bucle infinito. Típicamente usas break para salir del bucle, opcionalmente devolviendo un valor.while: Se ejecuta mientras una condición especificada permanezca verdadera.for: Itera sobre los elementos de una colección o un rango. Este es el tipo de bucle más comúnmente usado y a menudo el más seguro en Rust.// Ejemplo de loop
let mut contador = 0;
let resultado = loop {
contador += 1;
if contador == 10 {
break contador * 2; // Sale del bucle y devuelve 'contador * 2'
}
};
println!("Resultado del loop: {}", resultado); // Salida: Resultado del loop: 20
// Ejemplo de while
let mut num = 3;
while num != 0 {
println!("{}!", num);
num -= 1;
}
println!("¡¡¡DESPEGUE!!!");
// Ejemplo de for (iterando sobre un array)
let a = [10, 20, 30, 40, 50];
for elemento in a.iter() { // .iter() crea un iterador sobre los elementos del array
println!("el valor es: {}", elemento);
}
// Ejemplo de for (iterando sobre un rango)
// (1..4) crea un rango incluyendo 1, 2, 3 (exclusivo de 4)
// .rev() invierte el iterador
for numero in (1..4).rev() {
println!("{}!", numero); // Imprime 3!, 2!, 1!
}
println!("¡¡¡DESPEGUE OTRA VEZ!!!");
Usa comentarios para añadir explicaciones y notas a tu código que el compilador ignorará.
// Este es un comentario de una sola línea. Se extiende hasta el final de la línea.
/*
* Este es un comentario de bloque, multilínea.
* Puede abarcar varias líneas y es útil
* para explicaciones más largas.
*/
let numero_suerte = 7; // También puedes colocar comentarios al final de una línea.
La propiedad (Ownership) es la característica más distintiva y central de Rust. Es el mecanismo que permite a Rust garantizar la seguridad de memoria en tiempo de compilación sin necesitar un recolector de basura. Comprender la propiedad es clave para entender Rust. Sigue tres reglas centrales:
{ // s no es válido aquí, todavía no se ha declarado
let s = String::from("hola"); // s es válido desde este punto en adelante;
// s 'posee' los datos del String alojados en el heap.
// Puedes usar s aquí
println!("{}", s);
} // El ámbito termina aquí. 's' ya no es válido.
// Rust llama automáticamente a una función especial 'drop' para el String que 's' posee,
// liberando su memoria del heap.
Cuando asignas un valor propio (como un String, Vec, o un struct que contiene tipos propios) a otra variable, o lo pasas a una función por valor, la propiedad se mueve. La variable original se vuelve inválida.
let s1 = String::from("original");
let s2 = s1; // La propiedad de los datos del String se MUEVE de s1 a s2.
// s1 ya no se considera válido después de este punto.
// println!("s1 es: {}", s1); // ¡Error en tiempo de compilación! Valor prestado aquí después de moverlo.
// s1 ya no posee los datos.
println!("s2 es: {}", s2); // s2 es ahora el propietario y es válido.
Este comportamiento de movimiento previene errores de “doble liberación” (double free), donde dos variables podrían intentar accidentalmente liberar la misma ubicación de memoria cuando salen del ámbito. Los tipos primitivos como enteros, flotantes, booleanos y caracteres implementan el trait Copy, lo que significa que simplemente se copian en lugar de moverse cuando se asignan o pasan a funciones.
¿Qué pasa si quieres permitir que una función use un valor sin transferir la propiedad? Puedes crear referencias. Crear una referencia se llama préstamo (borrowing). Una referencia te permite acceder a datos propiedad de otra variable sin tomar posesión de ellos.
// Esta función toma una referencia (&) a un String.
// Toma prestado el String pero no toma la propiedad.
fn calcular_longitud(s: &String) -> usize {
s.len()
} // Aquí, s (la referencia) sale del ámbito. Pero como no posee los
// datos del String, los datos NO se liberan cuando la referencia sale del ámbito.
fn main() {
let s1 = String::from("hola");
// Pasamos una referencia a s1 usando el símbolo '&'.
// s1 todavía posee los datos del String.
let len = calcular_longitud(&s1);
// s1 sigue siendo válido aquí porque la propiedad nunca se movió.
println!("La longitud de '{}' es {}.", s1, len);
}
Las referencias son inmutables por defecto, al igual que las variables. Si quieres modificar los datos prestados, necesitas una referencia mutable, denotada por &mut. Sin embargo, Rust impone reglas estrictas sobre las referencias mutables para prevenir carreras de datos:
Las Reglas del Préstamo:
&mut T).&T).Estas reglas son aplicadas por el compilador.
// Esta función toma una referencia mutable a un String
fn cambiar(alguna_cadena: &mut String) {
alguna_cadena.push_str(", mundo");
}
fn main() {
// 's' debe declararse mutable para permitir el préstamo mutable
let mut s = String::from("hola");
// Ejemplo de aplicación de la regla de préstamo (descomenta líneas para ver errores):
// let r1 = &s; // préstamo inmutable - OK
// let r2 = &s; // otro préstamo inmutable - OK (se permiten múltiples préstamos inmutables)
// let r3 = &mut s; // ¡ERROR! No se puede tomar prestado `s` como mutable mientras haya préstamos inmutables activos
// // Rust impone: o múltiples lectores (&T) O un único escritor (&mut T), nunca ambos
// println!("{}, {}", r1, r2); // Usar r1/r2 los mantiene activos, provocando el error
// // Sin este println, los NLL (Non-Lexical Lifetimes) de Rust liberarían r1/r2 antes,
// // haciendo válido &mut s aquí
// Un préstamo mutable está permitido aquí porque no hay otros préstamos activos
cambiar(&mut s);
println!("{}", s); // Salida: hola, mundo
}
Rust proporciona formas de agrupar múltiples valores en tipos más complejos.
Los Structs (abreviatura de estructuras) te permiten definir tipos de datos personalizados agrupando campos de datos relacionados bajo un solo nombre.
// Define un struct llamado Usuario
struct Usuario {
activo: bool,
nombre_usuario: String, // Usa el tipo propio String
email: String,
contador_inicio_sesion: u64,
}
fn main() {
// Crea una instancia del struct Usuario
// Las instancias deben proporcionar valores para todos los campos
let mut usuario1 = Usuario {
email: String::from("alguien@example.com"),
nombre_usuario: String::from("nombreusuario123"),
activo: true,
contador_inicio_sesion: 1,
};
// Accede a los campos del struct usando la notación de punto
// La instancia debe ser mutable para cambiar los valores de los campos
usuario1.email = String::from("otroemail@example.com");
println!("Email del usuario: {}", usuario1.email);
// Usando una función auxiliar para crear una instancia de Usuario
let usuario2 = construir_usuario(String::from("usuario2@test.com"), String::from("usuario2"));
println!("Estado activo del Usuario 2: {}", usuario2.activo);
// Sintaxis de actualización de struct: Crea una nueva instancia usando algunos campos
// de una instancia existente para los campos restantes.
let usuario3 = Usuario {
email: String::from("usuario3@domain.com"),
nombre_usuario: String::from("usuario3"),
..usuario2 // toma los valores de 'activo' y 'contador_inicio_sesion' de usuario2
};
println!("Contador de inicio de sesión del Usuario 3: {}", usuario3.contador_inicio_sesion);
}
// Función que devuelve una instancia de Usuario
fn construir_usuario(email: String, nombre_usuario: String) -> Usuario {
Usuario {
email, // Atajo de inicialización de campo: si el nombre del parámetro coincide con el nombre del campo
nombre_usuario,
activo: true,
contador_inicio_sesion: 1,
}
}
Rust también soporta structs tupla, que son tuplas nombradas (p. ej., struct Color(i32, i32, i32);), y structs unitarias, que no tienen campos y son útiles cuando necesitas implementar un trait en un tipo pero no necesitas almacenar ningún dato (p. ej., struct SiempreIgual;).
Los Enums (enumeraciones) te permiten definir un tipo enumerando sus posibles variantes. Un valor enum solo puede ser una de sus posibles variantes.
// Enum simple definiendo tipos de dirección IP
enum TipoIpAddr {
V4, // Variante 1
V6, // Variante 2
}
// Las variantes de Enum también pueden contener datos asociados
enum IpAddr {
V4(u8, u8, u8, u8), // La variante V4 contiene cuatro valores u8
V6(String), // La variante V6 contiene un String
}
// Un enum muy común e importante en la biblioteca estándar de Rust: Option<T>
// Codifica el concepto de un valor que podría estar presente o ausente.
// enum Option<T> {
// Some(T), // Representa la presencia de un valor de tipo T
// None, // Representa la ausencia de un valor
// }
// Otro enum crucial de la biblioteca estándar: Result<T, E>
// Usado para operaciones que pueden tener éxito (Ok) o fallar (Err).
// enum Result<T, E> {
// Ok(T), // Representa éxito, conteniendo un valor de tipo T
// Err(E), // Representa fallo, conteniendo un valor de error de tipo E
// }
fn main() {
let cuatro = TipoIpAddr::V4;
let seis = TipoIpAddr::V6;
// Creando instancias del enum IpAddr con datos asociados
let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));
// Ejemplo con Option<T>
let algun_numero: Option<i32> = Some(5);
let ningun_numero: Option<i32> = None;
// El operador de flujo de control 'match' es perfecto para trabajar con enums.
// Te permite ejecutar código diferente basado en la variante del enum.
match algun_numero {
Some(i) => println!("Obtuve un número: {}", i), // Si es Some, liga el valor interno a i
None => println!("No obtuve nada."), // Si es None
}
// 'match' debe ser exhaustivo: debes manejar todas las variantes posibles.
// El guion bajo '_' se puede usar como un patrón comodín para capturar cualquier variante
// no listada explícitamente.
}
Option<T> y Result<T, E> son centrales en el enfoque de Rust para manejar robustamente valores potencialmente ausentes y errores.
Cargo es una parte indispensable del ecosistema de Rust, agilizando el proceso de construir, probar y gestionar proyectos de Rust. Es una de las características que los desarrolladores suelen elogiar.
Cargo.toml: Este es el archivo de manifiesto para tu proyecto Rust. Está escrito en el formato TOML (Tom's Obvious, Minimal Language). Contiene metadatos esenciales sobre tu proyecto (como su nombre, versión y autores) y, crucialmente, lista sus dependencias (otros crates externos en los que tu proyecto se basa).
[package]
name = "mi_proyecto"
version = "0.1.0"
edition = "2021" # Especifica la edición de Rust a usar (influye en las características del lenguaje)
# Las dependencias se listan a continuación
[dependencies]
# Ejemplo: Añadir el crate 'rand' para generación de números aleatorios
# rand = "0.8.5"
# Cuando compiles, Cargo descargará y compilará 'rand' y sus dependencias.
cargo new <nombre_proyecto>: Crea una nueva estructura de proyecto de aplicación binaria (ejecutable).cargo new --lib <nombre_biblioteca>: Crea una nueva estructura de proyecto de biblioteca (crate destinado a ser usado por otros programas).cargo build: Compila tu proyecto y sus dependencias. Por defecto, crea una compilación de depuración no optimizada. La salida se coloca en el directorio target/debug/.cargo build --release: Compila tu proyecto con optimizaciones habilitadas, adecuado para distribución o pruebas de rendimiento. La salida se coloca en el directorio target/release/.cargo run: Compila (si es necesario) y ejecuta tu proyecto binario.cargo check: Comprueba rápidamente tu código en busca de errores de compilación sin producir realmente el ejecutable final. Esto es típicamente mucho más rápido que cargo build y útil durante el desarrollo para obtener retroalimentación rápida.cargo test: Ejecuta cualquier prueba definida dentro de tu proyecto (generalmente ubicadas en el directorio src o en un directorio separado tests).Cuando añades una dependencia a tu archivo Cargo.toml y luego ejecutas un comando como cargo build o cargo run, Cargo maneja automáticamente la descarga del crate requerido (y sus dependencias) desde el repositorio central crates.io y compila todo junto.
Esta guía de inicio ha cubierto lo básico absoluto para ponerte en marcha. El lenguaje Rust ofrece muchas más características poderosas para explorar a medida que progresas:
Result, la propagación de errores usando el operador ? y la definición de tipos de error personalizados.Vec<T> (arrays/vectores dinámicos), HashMap<K, V> (mapas hash), HashSet<T>, etc.<T>).'a).Mutex y Arc, y la potente sintaxis async/await de Rust para programación asíncrona.Rust presenta una propuesta única y atractiva: el rendimiento bruto esperado de lenguajes de bajo nivel como C++, combinado con fuertes garantías de seguridad en tiempo de compilación que eliminan clases enteras de errores comunes, particularmente en torno a la gestión de memoria y la concurrencia. Aunque la curva de aprendizaje implica internalizar nuevos conceptos como la propiedad y el préstamo (y escuchar al compilador, a veces estricto), la recompensa es un software altamente fiable, eficiente y a menudo más fácil de mantener a largo plazo. Con sus excelentes herramientas a través de Cargo y una comunidad de apoyo, Rust es un lenguaje gratificante para aprender.
Empieza poco a poco, experimenta usando Cargo, acepta los útiles (aunque a veces verbosos) mensajes de error del compilador como guía, y estarás bien encaminado para dominar este lenguaje potente y cada vez más popular. ¡Feliz Rusting!