Introducción a Rust
Rust es un lenguaje de programación de sistemas desarrollado principalmente por Mozilla Research, conseguridad de memoria、abstracción de costo ceroyconcurrencia sin miedocomo objetivos de diseño centrales.
Rust nació en 2006, inicialmente como un proyecto personal de Graydon Hoare, empleado de Mozilla, y luego en 2009 fue patrocinado oficialmente por Mozilla, que formó un equipo para su desarrollo.
El propósito original de Rust fue resolver los problemas persistentes de C/C++ en la programación de sistemas:problemas de seguridad de memoria(punteros nulos, punteros colgantes, desbordamiento de búfer) yla complejidad de la programación concurrente(condiciones de carrera, interbloqueos).

La filosofía de diseño de Rust es «eliminar los bugs en tiempo de compilación»: mediante un poderoso sistema de tipos y el mecanismo de propiedad, el compilador detecta errores de memoria y condiciones de carrera, en lugar de esperar a que los problemas aparezcan en tiempo de ejecución.
La mascota del lenguaje Rust es un cangrejo llamado Ferris, amigable y entrañable, que representa la cultura amistosa e inclusiva de la comunidad Rust.
Los objetivos de diseño clave de Rust se pueden resumir en los siguientes puntos:
| Objetivo de diseño | Descripción |
|---|---|
| Seguridad de memoria (sin GC) | Garantiza la seguridad de memoria en tiempo de compilación mediante el sistema de propiedad, sin necesidad de un recolector de basura. |
| Abstracción de costo cero | Las características de alto nivel no tienen sobrecarga en tiempo de ejecución tras la compilación, con un rendimiento equivalente al código de bajo nivel escrito a mano. |
| Concurrencia sin miedo | El sistema de tipos y las reglas de propiedad eliminan las condiciones de carrera en tiempo de compilación. |
| Pragmatismo | Puede escribir tanto núcleos de sistemas operativos como aplicaciones web, cubriendo escenarios de pila completa. |
| Fuerte inferencia de tipos | El compilador deduce automáticamente la mayoría de los tipos, reduciendo el código repetitivo. |
| Ecosistema de herramientas rico | Cargo (gestión de paquetes + compilación), rustfmt (formateo), clippy (análisis de código) listos para usar. |
Historia del lenguaje Rust
Rust ha recorrido casi dos décadas de desarrollo, desde un proyecto personal hasta un lenguaje de sistemas ampliamente adoptado en todo el mundo.
| Año | Versión/Evento | Descripción |
|---|---|---|
| 2006 | Proyecto personal | Graydon Hoare comienza a diseñar Rust. |
| 2009 | Patrocinio de Mozilla | Mozilla apoya oficialmente el desarrollo de Rust y forma un equipo. |
| 2010 | Primera presentación pública | El compilador de Rust (escrito en OCaml) se presenta públicamente por primera vez en la cumbre de Mozilla. |
| 2011 | Autocompilación completada | El compilador de Rust se reescribe en Rust, eliminando la dependencia de OCaml. |
| Mayo de 2015 | Rust 1.0 | Se publica la primera versión estable, marcando que el lenguaje es oficialmente utilizable en producción. |
| Diciembre de 2018 | Rust 2018 Edition | Se publica la primera Edition, optimizando la sintaxis y el sistema de módulos (se introduce el verificador de préstamos NLL). |
| 2019 | Se consolida el ecosistema asíncrono | La sintaxis async/await se estabiliza y los runtimes asíncronos como Tokio maduran. |
| 2021 | Creación de la Fundación Rust | AWS, Google, Huawei, Microsoft y Mozilla fundan conjuntamente la Fundación Rust. |
| Octubre de 2021 | Rust 2021 Edition | Se introducen mejoras como disjoint capture, IntoIterator para arrays, etc. |
| 2022 | Adopción en el kernel de Linux | Linux 6.1 incorpora oficialmente soporte para Rust, convirtiéndose en el segundo lenguaje para el desarrollo del kernel. |
| Febrero de 2024 | Rust 2024 Edition | Se optimizan aún más la coherencia del lenguaje y la experiencia del desarrollador. |
La creación de la Fundación Rust en 2021 fue un hito. AWS, Google, Huawei, Microsoft y Mozilla, cinco gigantes tecnológicos, se comprometieron conjuntamente a garantizar el desarrollo independiente a largo plazo de Rust, disipando las preocupaciones de la comunidad sobre el «dominio de una sola empresa».
Rust adoptauna versión estable cada seis semanascomo ritmo de publicación, y además medianteEditionun mecanismo (publicado aproximadamente cada 3 años) maneja los cambios incompatibles del lenguaje.
Características principales del lenguaje Rust
Las características de Rust se organizan en torno a tres dimensiones: «seguridad, eficiencia y practicidad». A continuación se desglosan las características más esenciales del lenguaje.
Sistema de propiedad (Ownership)
La propiedad es la característica más distintiva e importante de Rust. Gestiona la memoria en tiempo de compilación, sin necesidad de un recolector de basura ni de malloc/free manual.
La propiedad tiene tres reglas fundamentales:
| Regla | Descripción | Significado |
|---|---|---|
| Cada valor tiene exactamente un propietario | Un valor solo puede ser propiedad de una variable a la vez | Elimina double-free y punteros colgantes |
| Cuando el propietario sale del ámbito, el valor se libera | Cuando una variable sale de su ámbito, Rust llama automáticamente a drop para liberar memoria | Sin gestión manual de memoria |
| En un mismo momento: o una referencia mutable o múltiples referencias inmutables | Lectura y escritura son mutuamente excluyentes, múltiples lecturas coexisten | Elimina las condiciones de carrera en tiempo de compilación |
La sensación a nivel de código: cuando una variable se asigna a otra, la propiedad se transfiere (move) y la variable original deja de ser válida.
Ejemplo
// s1 obtiene la propiedad del string (los datos se almacenan en el heap)
let s1 = String::from("Hello, EJEMPLO!");
// La propiedad se transfiere de s1 a s2, a partir de ahora s1 ya no es válido
let s2 = s1;
// println!("{}", s1); // ¡Error de compilación! s1 ha sido movido
println!("{}", s2); // Correcto: s2 es ahora el propietario
// Los tipos básicos (almacenados en la pila) implementan el trait Copy, no se produce move
let x = 42;
let y = x; // x sigue siendo válido, porque i32 implementa Copy
println!("x = {}, y = {}", x, y); // Ambos se pueden usar
// Referencias inmutables: puede haber varias a la vez
let s3 = &s2; // Préstamo inmutable
let s4 = &s2; // Otro préstamo inmutable, permitido
println!("s3 = {}, s4 = {}", s3, s4);
// Referencias mutables: solo una a la vez
let mut data = String::from("ejemplo");
let r = &mut data; // Préstamo mutable
r.push_str("!"); // Modificar el valor original a través de una referencia mutable
println!("Después de la modificación: {}", r);
// Los alcances de s3 y s4 han terminado, por lo que se puede crear una referencia mutable
}
El sistema de propiedad es la "pendiente empinada" de la curva de aprendizaje de Rust. Los principiantes a menudo "luchan" contra el compilador, pero una vez que lo entiendes, descubres que esos errores que el compilador intercepta podrían ser errores fatales de tiempo de ejecución en C/C++.
Coincidencia de patrones (Pattern Matching)
de RustmatchLa expresión es extremadamente poderosa, el compilador realizaverificación exhaustivade todos los casos, asegurando que no se omita ninguna rama.
Ejemplo
// match con números
let score = 85;
match score {
90..=100 => println!("Calificación EJEMPLO: A"), // Coincidencia por rangos
60..=89 => println!("Calificación EJEMPLO: B"),
0..=59 => println!("Calificación EJEMPLO: C"),
_ => println!("Puntuación inválida"), // Comodín, coincide con todos los casos restantes
}
// match desestructura tuplas
let pair = (3, 7);
match pair {
(0, y) => println!("El primero es 0, el segundo es {}", y),
(x, 0) => println!("El primero es {}, el segundo es 0", x),
(x, y) => println!("Dos valores: {} y {}", x, y),
}
}
Enums y Option/Result
Los enums de Rust (enum) pueden llevar datos, y junto con match permiten implementar un flujo de control seguro y altamente expresivo.
En la biblioteca estándar,Option<T>yResult<T, E>son los dos tipos enum más fundamentales, que manejan respectivamente los escenarios de "puede estar vacío" y "puede fallar". Rust no tiene null ni excepciones.
Ejemplo
fn main() {
// Option<T>: el valor puede existir o no (alternativa a null)
let numbers = vec![10, 20, 30];
let first = numbers.get(0); // Devuelve Option<&i32>
let missing = numbers.get(5); // Devuelve Option<&i32>
match first {
Some(&val) => println!("El primer elemento: {}", val),
None => println!("No encontrado"),
}
// Una forma más concisa: if let
if let Some(&val) = missing {
println!("Encontrado: {}", val);
} else {
println!("El índice 5 no existe"); // Se espera que tome esta rama
}
// Result<T, E>: la operación puede tener éxito o fallar (alternativa a las excepciones)
let content = fs::read_to_string("config.txt");
match content {
Ok(text) => println!("Contenido del archivo: {}", text),
Err(e) => println!("Error de lectura: {}", e),
}
}
Rust no tiene valores null ni mecanismo de excepciones try-catch. Option y Result se manejan obligatoriamente en tiempo de compilación: si olvidas comprobarlos, el código no compila. Esto elimina de raíz las excepciones de puntero nulo y las excepciones no capturadas.
Abstracción de costo cero
Las características de alto nivel de Rust (iteradores, cierres, genéricos) son completamente equivalentes a bucles de bajo nivel escritos a mano después de la compilación, sin incurrir en sobrecarga adicional en tiempo de ejecución.
Esto significa que puedes escribir código en un estilo similar al funcional y a la vez obtener el mismo alto rendimiento que C.
Ejemplo
let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// Llamada encadenada de iteradores: parece una abstracción de alto nivel
// Después de compilar, se expande a código máquina equivalente a un bucle for escrito a mano
let result: Vec<i32> = data
.iter() // Obtener el iterador
.filter(|&x| x % 2 == 0) // Filtrar números pares
.map(|&x| x * x) // Calcular el cuadrado
.collect(); // Recoger en un Vec
println!("{:?}", result); // [4, 16, 36, 64, 100]
}
Concurrencia sin miedo (Fearless Concurrency)
El sistema de tipos y las reglas de propiedad de Rust entiempo de compilación,eliminan las condiciones de carrera. Los traits Send y Sync marcan automáticamente si un tipo se puede transmitir o compartir de forma segura entre hilos.
Si intentas compartir datos no seguros para hilos entre múltiples hilos, el compilador te dará un error directamente, en lugar de esperar a que aparezcan extraños errores de concurrencia en producción.
Ejemplo
use std::thread;
fn main() {
// Arc (conteo de referencias atómico) se usa para compartir la propiedad entre múltiples hilos
// Mutex proporciona acceso mutuamente excluyente
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for i in 0..10 {
// Clonar Arc para que cada hilo tenga una referencia a los mismos datos
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
// lock() adquiere el bloqueo mutex y devuelve MutexGuard
let mut num = counter.lock().unwrap();
*num += 1; // Modificar el valor interno mediante desreferencia
println!("El hilo {} terminó de acumular, valor actual: {}", i, *num);
});
handles.push(handle);
}
// Esperar a que todos los hilos terminen
for handle in handles {
handle.join().unwrap();
}
println!("Conteo final: {}", *counter.lock().unwrap());
}
Cargo: herramienta de construcción integral
Cargo es el gestor de paquetes y sistema de construcción oficial de Rust, que integra gestión de dependencias, compilación, pruebas, generación de documentación y publicación.
En comparación con la experiencia fragmentada del ecosistema C/C++ donde hay que configurar manualmente CMake/Makefile y el gestor de paquetes, Cargo ofrece una experiencia integrada "lista para usar".
| Comando | Función | Escenario típico |
|---|---|---|
| cargo new project | Crear nuevo proyecto | Inicializa el proyecto y genera automáticamente Cargo.toml y src/main.rs |
| cargo build | Compilar el proyecto (modo debug) | Desarrollo y depuración |
| cargo build --release | Compilar el proyecto (modo optimizado) | Publicación en producción, activa todas las optimizaciones del compilador |
| cargo run | Compilar y ejecutar | Probar código rápidamente |
| cargo test | Ejecutar pruebas | Pruebas unitarias, pruebas de integración, pruebas de documentación |
| cargo check | Verifica rápidamente si el código compila (sin generar binarios) | Verificación de sintaxis en tiempo real en el IDE |
| cargo doc --open | Generar y abrir documentación | Explorar la documentación de API de las bibliotecas dependientes |
| cargo clippy | Revisión de estilo de código (lint) | Detecta prácticas no recomendadas y problemas potenciales |
| cargo fmt | Formateo de código | Unifica el estilo de código |
| cargo publish | Publicar en crates.io | Publicar bibliotecas de código abierto |
cargo check es un comando muy útil durante el desarrollo. Solo verifica sintaxis y tipos, no genera archivos ejecutables, y es mucho más rápido que cargo build. La mayoría de los complementos de Rust en los IDE ejecutan cargo check automáticamente al guardar archivos.
Áreas de aplicación del lenguaje Rust
Gracias a sus ventajas de seguridad de memoria y alto rendimiento, Rust se está expandiendo rápidamente en múltiples ámbitos.
Programación de sistemas y servidores de alto rendimiento
Este es el "terreno de juego" de Rust: adecuado para escenarios que requieren rendimiento extremo y altos requisitos de seguridad de memoria. El runtime asíncronoTokioy los frameworks webActix Web、Axumdestacan en escenarios de alta concurrencia.
WebAssembly
Rust esuno de los mejores lenguajes para compilar a WebAssembly. Su abstracción de costo cero y su ausencia de GC hacen que los artefactos Wasm sean pequeños y de alto rendimiento.
Frameworks frontendYewyLeptosPermiten escribir aplicaciones SPA con Rust. Figma, Cloudflare Workers, entre otros, utilizan intensivamente Rust + Wasm en entornos de producción.
Embebidos e IoT
de Rustno_stdEl patrón permite ejecutarse en metal desnudo sin sistema operativo, adecuado para dispositivos con recursos limitados como MCU, sensores, etc.
RTIC(framework de concurrencia en tiempo real basado en interrupciones) yEmbassy(framework embebido asíncrono) son proyectos representativos del Rust embebido.
Herramientas CLI
Rust se compila en binarios independientes y tiene un rendimiento excelente, lo que ha dado lugar a numerosas herramientas CLI de renombre:
| Herramienta | Función | Objeto que reemplaza |
|---|---|---|
| ripgrep (rg) | Búsqueda de código ultrarrápida | grep |
| fd | Búsqueda rápida de archivos | find |
| bat | Visor de archivos con resaltado de sintaxis | cat |
| delta | Git diff con resaltado de sintaxis | git diff |
| zoxide | Navegación inteligente de directorios | cd |
| dust | Análisis de espacio en disco | du |
Blockchain y Web3
Rust tiene una posición importante en el ámbito de blockchain.SolanaEl núcleo de la cadena está escrito en Rust,Sui、Aptos、Polkadot(Substrate)y otras nuevas cadenas públicas también usan Rust como lenguaje de desarrollo principal.
Bases de datos e infraestructura de datos
Las bases de datos de alto rendimiento y los sistemas de procesamiento de datos son un área de fortaleza para Rust:TiKV(almacenamiento distribuido KV, capa de almacenamiento de TiDB),SurrealDB、Polars(biblioteca DataFrame),Databend(almacén de datos en la nube), etc., están construidos con Rust.
Sistemas operativos e infraestructura
Rust ya ha entrado en el kernel de Linux (6.1+); Google usa Rust en Android para reescribir la pila de Bluetooth y Wi-Fi, y Microsoft también usa Rust en el kernel de Windows para reescribir algunos componentes.
En cuanto a proyectos de aficionados,Redox OSes un sistema operativo tipo Unix escrito completamente desde cero en Rust.
Inicio rápido
Rust proporciona oficialmente una herramienta de instalación extremadamente conveniente, rustup, que con un solo comando instala el compilador, el gestor de paquetes y la documentación.
Instalar Rust
# Unix/macOS $ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # 验证安装 $ rustc --version rustc 1.85.0 (4d91de4e4 2025-02-17) $ cargo --version cargo 1.85.0
Tu primer programa en Rust
Usar Cargo para crear un proyecto es la forma más recomendada, ya que genera automáticamente la estructura estándar del proyecto.
# 创建新项目
$ cargo new hello_ejemplo
Created binary (application) `hello_ejemplo` package
# 项目结构
hello_ejemplo/
├── Cargo.toml # 项目元数据和依赖配置
└── src/
└── main.rs # 程序入口文件
Cargo.toml es el archivo de configuración del proyecto, similar a package.json de Node.js:
Ejemplo
name = "hello_ejemplo" # Nombre del paquete (obligatorio, separado por guiones bajos)
version = "0.1.0" # Número de versión (obligatorio, semver)
edition = "2024" # Rust Edition (obligatorio, afecta las reglas de sintaxis del lenguaje)
[dependencies]
# Aquí se declaran las dependencias del proyecto, por ejemplo:
# serde = { version = "1.0", features = ["derive"] }
El main.rs generado por defecto contiene un programa Hello World muy simple:
Ejemplo
// Entrada del programa Rust: todo programa ejecutable debe tener una función main
fn main() {
// println! es una macro (observa el símbolo ! al final)
// Las macros se expanden en código más complejo en tiempo de compilación
println!("Hello, EJEMPLO!");
println!("Bienvenido al mundo del lenguaje Rust");
}
# 编译并运行
$ cargo run
Compiling hello_ejemplo v0.1.0
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
Running `target/debug/hello_ejemplo`
Hello, EJEMPLO!
欢迎来到 Rust 语言的世界
Resumen de sintaxis básica
La sintaxis de Rust toma prestadas las ventajas de los lenguajes funcionales y de los lenguajes de sistema. A continuación, un vistazo rápido a los elementos de sintaxis más utilizados; cada ejemplo es un programa completo que se puede ejecutar directamente.
Variables y mutabilidad
Variables en RustInmutables por defecto(immutable). Esto obliga a los desarrolladores a indicar explícitamente qué datos cambiarán, lo que hace que la intención del código sea más clara y facilita la optimización por parte del compilador.
Ejemplo
// Variable inmutable (por defecto): no se puede reasignar después de declararla
let name = "EJEMPLO";
// name = "other"; // ¡Error de compilación! Una variable inmutable no se puede reasignar
println!("Nombre: {}", name);
// Variable mutable: se declara explícitamente con la palabra clave mut
let mut score = 0;
println!("Puntuación inicial: {}", score);
score = 100; // Se puede modificar
println!("Puntuación actualizada: {}", score);
// Sombreado de variables (Shadowing): redeclarar una variable con el mismo nombre usando let
let x = 5;
let x = x + 1; // La nueva variable x sombrea a la antigua x, con valor 6
let x = x * 2; // Se sombrea de nuevo, con valor 12
println!("Valor final de x: {}", x);
// Constante: se determina en tiempo de compilación, debe anotarse el tipo, y por convención se nombra en mayúsculas
const MAX_POINTS: u32 = 100_000;
println!("Puntos máximos: {}", MAX_POINTS);
}
El sombreado de variables (Shadowing) y mut no son lo mismo. El sombreado consiste en redeclarar una nueva variable con el mismo nombre usando let, y puede cambiar el tipo; mientras que mut simplemente permite modificar el valor de la misma variable, sin cambiar el tipo.
Tipos de datos básicos
Rust es un lenguaje de tipado estático; el compilador debe conocer el tipo de todas las variables en tiempo de compilación.
| Categoría | Tipo | Ejemplo | Descripción |
|---|---|---|---|
| Enteros con signo | i8, i16, i32, i64, i128, isize | let x: i32 = -42; | El tipo entero por defecto es i32 |
| Enteros sin signo | u8, u16, u32, u64, u128, usize | let y: u64 = 100; | usize se usa para índices y longitudes |
| Números de punto flotante | f32, f64 | let pi: f64 = 3.14; | El tipo de punto flotante por defecto es f64 |
| Booleanos | bool | let ok: bool = true; | true o false |
| Carácter | char | let c = 'R'; | 4 bytes, representa un valor escalar Unicode |
| Tupla | (T1, T2, ...) | let t: (i32, f64) = (10, 3.14); | Longitud fija, los tipos pueden ser diferentes |
| Arreglo | [T; N] | let a: [i32; 3] = [1, 2, 3]; | Longitud fija, mismo tipo, asignado en la pila |
| Rebanada (slice) | &[T] | let s: &[i32] = &a[..]; | Vista de referencia a un arreglo o Vec |
| Arreglo dinámico | Vec<T> | let v: Vec<i32> = vec![1,2,3]; | Longitud variable, asignado en el montón |
| Cadena de caracteres | String / &str | let s = String::from("hi"); | String es modificable, &str es una referencia |
Flujo de control
El flujo de control de Rust incluyeif、loop、while、forymatch. Donde if y loop pueden devolver un valor como expresiones.
Ejemplo
let score = 75;
// if es una expresión, puede devolver un valor (todas las ramas deben devolver el mismo tipo)
let grade = if score >= 90 {
"A"
} else if score >= 60 {
"B"
} else {
"C"
};
println!("Clasificación EJEMPLO: {}", grade);
// bucle loop infinito (se sale con break, puede llevar un valor de retorno)
let mut count = 0;
let result = loop {
count += 1;
if count == 5 {
break count * 2; // break seguido de un valor, como valor de retorno del loop
}
};
println!("Valor de retorno del loop: {}", result);
// bucle while con condición
let mut n = 3;
while n > 0 {
println!("Cuenta regresiva: {}", n);
n -= 1;
}
// iteración for in (la más utilizada)
let items = ["apple", "banana", "cherry"];
for (i, item) in items.iter().enumerate() {
println!("Elemento {}: {}", i + 1, item);
}
// iteración for in sobre un rango
for num in 1..=3 { // 1..=3 representa 1, 2, 3 (incluye ambos extremos)
println!("Número: {}", num);
}
}
Funciones
Las funciones de Rust usanfnla palabra clave `fn` para declararse; los parámetros y el valor de retorno deben anotar explícitamente sus tipos. El valor de la última expresión es el valor de retorno (no se necesita la palabra clave `return`).
Ejemplo
fn add(a: i32, b: i32) -> i32 {
a + b // La última expresión se toma automáticamente como valor de retorno (observa que no hay punto y coma al final)
}
// Valores de retorno múltiples: se usa una tupla para devolver varios valores
fn divide(a: f64, b: f64) -> (f64, String) {
if b == 0.0 {
return (0.0, String::from("Error: el divisor no puede ser cero"));
}
(a / b, String::from("OK")) // Devuelve una tupla
}
// Función genérica: usa trait bounds para restringir el comportamiento de los parámetros de tipo
fn largest<T: PartialOrd>(list: &[T]) -> &T {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
// Llamada a una función normal
let sum = add(10, 20);
println!("10 + 20 = {}", sum);
// Llamada a una función con múltiples valores de retorno
let (result, msg) = divide(10.0, 2.0);
println!("10 / 2 = {} ({})", result, msg);
// Caso de división entre cero
let (result, msg) = divide(10.0, 0.0);
println!("10 / 0 = {} ({})", result, msg);
// Llamada a una función genérica
let nums = vec![3, 7, 2, 9, 5];
println!("El número máximo de EJEMPLO: {}", largest(&nums));
}
Estructuras y bloques impl
Rust usastruct`struct` para definir estructuras de datos, yimplbloques `impl` para implementar métodos en las estructuras. Esto es similar a la forma en que Go define métodos, pero la organización del lenguaje es más compacta.
Ejemplo
struct User {
name: String, // Tipo String, posee la propiedad de los datos
email: String,
active: bool,
login_count: u64, // u64 entero sin signo de 64 bits
}
// El bloque impl implementa métodos para User
impl User {
// Función asociada (similar a un método estático): crea una nueva instancia
fn new(name: String, email: String) -> User {
User {
name,
email,
active: true, // Valor predeterminado
login_count: 0, // Valor predeterminado
}
}
// Método: &self representa una referencia inmutable a la instancia
fn summary(&self) -> String {
format!("{} ({}) - veces de inicio de sesión: {}", self.name, self.email, self.login_count)
}
// Método: &mut self representa una referencia mutable a la instancia
fn login(&mut self) {
self.login_count += 1;
}
}
fn main() {
// Crear una instancia usando una función asociada
let mut user = User::new(
String::from("ejemplo"),
String::from("ejemplo@example.com"),
);
println!("{}", user.summary());
// Simular inicio de sesión
user.login();
user.login();
println!("Inicio de sesión {} veces", user.login_count);
}
Ejemplos comunes
A continuación, mediante dos ejemplos completos cercanos a escenarios reales, se muestran los usos típicos de Rust en el desarrollo real.
Construir un servicio HTTP API
Usar el framework Axum (basado en el runtime asíncrono Tokio) para construir una API HTTP con respuestas JSON.
Primero agrega las dependencias en Cargo.toml:
# Cargo.toml
[dependencies]
axum = "0.8" # Web 框架
tokio = { version = "1", features = ["full"] } # 异步运行时
serde = { version = "1", features = ["derive"] } # 序列化
serde_json = "1" # JSON 支持
Ejemplo
use axum::{
extract::Query,
response::Json,
routing::get,
Router,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
// Estructura de parámetros de la solicitud (deserialización)
#[derive(Deserialize)]
struct HelloParams {
name: Option<String>, // Option representa parámetros opcionales
}
// Estructura de respuesta (serialización)
#[derive(Serialize)]
struct ApiResponse {
code: u16,
message: String,
data: Option<HashMap<String, String>>, // Campo de datos opcional
}
// Maneja la solicitud GET /hello
// Query(HelloParams) extrae automáticamente name de los parámetros de consulta de la URL
async fn hello_handler(Query(params): Query<HelloParams>) -> Json<ApiResponse> {
let name = params.name.unwrap_or_else(|| String::from("EJEMPLO"));
let mut data = HashMap::new();
data.insert("name".to_string(), name.clone());
Json(ApiResponse {
code: 200,
message: format!("¡Hola, {}! Bienvenido al servicio HTTP de Rust", name),
data: Some(data),
})
}
// La macro #[tokio::main] convierte async fn main en el runtime de Tokio
#[tokio::main]
async fn main() {
// Construcción de las rutas
let app = Router::new()
.route("/hello", get(hello_handler));
// Vincular la dirección y arrancar el servicio
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
.await
.unwrap();
println!("Servidor EJEMPLO iniciado, dirección de escucha: http://localhost:8080");
println!(Ejemplo de acceso: http://localhost:8080/hello?name=RustComenzandoPublicarpersona);
axum::serve(listener, app).await.unwrap();
}
$ cargo run
EJEMPLO 服务器启动,监听地址: http://localhost:8080
访问示例: http://localhost:8080/hello?name=Rust开发者
# 使用 curl 测试
$ curl http://localhost:8080/hello?name=Rust开发者
{"code":200,"message":"你好,Rust开发者!欢迎访问 Rust HTTP 服务","data":{"name":"Rust开发者"}}
$ curl http://localhost:8080/hello
{"code":200,"message":"你好,EJEMPLO!欢迎访问 Rust HTTP 服务","data":{"name":"EJEMPLO"}}
Axum es uno de los frameworks web más populares del ecosistema de Rust, mantenido por el equipo de Tokio. Aprovecha al máximo el sistema de tipos de Rust, y operaciones como la extracción de parámetros de ruta y el compartir estado se verifican en tiempo de compilación, lo que reduce en gran medida los errores en tiempo de ejecución.
Herramienta de procesamiento por lotes de archivos
Esta es una herramienta CLI cercana a un escenario real: recorre directorios de forma recursiva, cuenta el número de líneas y el tamaño de todos los archivos, y los resume agrupándolos por extensión.
Agrega las dependencias en Cargo.toml:
# Cargo.toml [dependencies] walkdir = "2" # 递归遍历目录
Ejemplo
use std::collections::HashMap;
use std::fs;
use walkdir::WalkDir; // Biblioteca de terceros para recorrer directorios recursivamente
fn main() {
let path = "."; // Escaneo comenzando desde el directorio actual
// Información de estadísticas: agrupada por extensión de archivo
// HashMap<extensión, (número de archivos, número total de líneas, tamaño total en bytes)>
let mut stats: HashMap<String, (usize, usize, u64)> = HashMap::new();
// WalkDir recorre directorios recursivamente y omite automáticamente archivos ocultos y el directorio .git
for entry in WalkDir::new(path)
.into_iter()
.filter_map(|e| e.ok()) // Filtrar las entradas inaccesibles
.filter(|e| e.file_type().is_file()) // Solo procesar archivos
{
// Obtener la extensión del archivo
let ext = entry
.path()
.extension()
.and_then(|e| e.to_str())
.unwrap_or("(sin extensión)")
.to_lowercase();
// Leer el contenido del archivo (solo archivos de texto; los binarios pueden mostrar caracteres extraños pero no afectan las estadísticas)
if let Ok(content) = fs::read_to_string(entry.path()) {
let line_count = content.lines().count();
let size = entry.metadata().map(|m| m.len()).unwrap_or(0);
let (count, lines, total_size) = stats.entry(ext).or_insert((0, 0, 0));
*count += 1;
*lines += line_count;
*total_size += size;
}
}
// Ordenar por número de archivos en orden descendente y mostrar
let mut sorted: Vec<_> = stats.into_iter().collect();
sorted.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));
println!("=== Estadísticas de archivos del directorio EJEMPLO ===");
println!("{:<15} {:>8} {:>10} {:>12}", "Extensión", "Nº de archivos", "Total de líneas", "Tamaño total (bytes)");
println!("{}", "-".repeat(50));
for (ext, (count, lines, size)) in &sorted {
println!("{:<15} {:>8} {:>10} {:>12}", ext, count, lines, size);
}
}
$ cargo run --release === EJEMPLO 目录文件统计 === 扩展名 文件数 总行数 总大小(bytes) -------------------------------------------------- rs 12 856 28432 toml 3 45 1534 md 2 120 3412 html 1 510 14256 (无扩展名) 1 8 210
Herramientas comunes y referencia rápida de comandos
Además de las funciones integradas de Cargo, el ecosistema de Rust ofrece una serie de herramientas que mejoran la eficiencia del desarrollo:
| Comando | Función | Descripción |
|---|---|---|
| rustup update | Actualizar la cadena de herramientas de Rust | Actualiza rustc, cargo, etc. a la última versión estable |
| rustup component add rustfmt | Instalar herramienta de formateo de código | Formatea el código automáticamente al guardar |
| rustup component add clippy | Instalar herramienta de análisis de código | Detecta escrituras no recomendadas y posibles errores |
| rustup doc | Abrir documentación local | Ver la biblioteca estándar y The Book sin conexión |
| cargo add <crate> | Añadir dependencia | Edita automáticamente Cargo.toml y obtiene la última versión |
| cargo update | Actualizar versión de dependencias | Actualiza Cargo.lock según las restricciones de versión de Cargo.toml |
| cargo tree | Ver árbol de dependencias | Visualiza las dependencias completas del proyecto |
| cargo bench | Ejecutar pruebas de referencia (benchmarks) | Mide el rendimiento del código |
| cargo install <tool> | Instalar herramientas CLI escritas en Rust | Por ejemplo, cargo install ripgrep |
Precauciones y preguntas frecuentes
A continuación se presentan los desafíos más comunes para quienes empiezan con Rust y recomendaciones de buenas prácticas.
«Luchar» contra el compilador es normal
La curva de aprendizaje de Rust es reconocidamente empinada al principio y más suave después.La propiedad (ownership) y el borrow checkerson los mayores obstáculos al empezar.
Cuando el compilador rechaza tu código una y otra vez, no te desanimes: precisamente eso demuestra que el compilador te está ayudando a interceptar posibles errores en tiempo de ejecución. Con la experiencia, te acostumbrarás a pensar a la manera de Rust, y el compilador se convertirá en tu aliado más confiable, no en un enemigo.
Diferencia entre String y &str
Este es el concepto que más suele confundir a quienes empiezan con Rust.Stringes una cadena asignada en el heap que posee la propiedad (modificable),&stres una referencia inmutable a los datos de la cadena (una vista prestada), normalmente obtenida por desreferencia automática de &String.
Ejemplo
// String: posee la propiedad, modificable, en el heap
let mut s = String::from("Hello");
// &str: referencia, no modificable, normalmente como parámetro de función
let slice: &str = "EJEMPLO"; // Los literales de cadena son en sí mismos &str
s.push_str(", world!"); // String se puede modificar
println!("{}", s);
println!("{}", slice);
// Usar &str (en lugar de String) como parámetro de función es más flexible
greet("EJEMPLO"); // Se puede pasar &str directamente
greet(&s); // También se puede convertir automáticamente de &String a &str
}
fn greet(name: &str) {
println!("¡Hola, {}!", name);
}
Manejo de errores: panic! vs Result
Rust distingue entreerrores irrecuperables(que usanpanic!, y terminan el programa) yerrores recuperables(que usanResult, donde quien llama decide cómo manejarlos).
En el código de bibliotecas, se debe devolver Result en lugar de panic!, para que quien llama tenga la opción. En las aplicaciones, se puede decidir según el caso.
unsafe: usar con precaución, pero necesario
Rust proporciona launsafepalabra clave, que permite operaciones de bajo nivel como manipulación de punteros crudos y llamadas a funciones externas (FFI).
unsafe no significa "deshabilitar las comprobaciones de seguridad", sino que el desarrollador asume la parte de responsabilidad de seguridad que el compilador no puede garantizar automáticamente. La mayoría del código de aplicaciones no necesita usar unsafe; si descubres que lo usas con frecuencia, puede ser que necesites ajustar el diseño.
Los tiempos de compilación son largos
Rust es conocido por sus largos tiempos de compilación, especialmente en proyectos grandes. Esto se debe a que el compilador realiza muchas comprobaciones (análisis de propiedad, verificación de tiempos de vida, resolución de traits, etc.) y optimizaciones durante la compilación.
Medidas para mitigarlo: usarcargo checken lugar de cargo build para el desarrollo diario; dividir los crates grandes en subcrates para aprovechar la compilación incremental; usarsccachepara almacenar en caché los resultados de compilación; mejorar el hardware (especialmente SSD y más núcleos de CPU).
Sugerencias de ruta de aprendizaje
Para principiantes en Rust, se recomienda el siguiente orden de aprendizaje:
- Leer completoThe Rust Programming Language(el libro oficial, gratuito), con énfasis en el capítulo de propiedad (ownership)
- Escribir mientras se lee en Rust Playground (play.rust-lang.org) para obtener retroalimentación inmediata del compilador
- A través deRustlingshacer ejercicios pequeños para consolidar la sintaxis
- LeerRust by Example, aprender mediante ejemplos
- Intentar reescribir un pequeño proyecto conocido en Rust para entender en la práctica las decisiones de diseño de Rust.
Resumen
Rust, con susseguridad de memoria (sin GC)、abstracciones de costo ceroyconcurrencia sin miedotres ventajas principales, ocupa un nicho ecológico único en áreas como programación de sistemas, servicios de alto rendimiento, WebAssembly y blockchain.
Aunque la curva de aprendizaje es pronunciada, las estrictas comprobaciones del compilador se traducen en una altísima calidad de código y mantenibilidad en proyectos a largo plazo; por eso cada vez más empresas y proyectos de código abierto eligen Rust.
Las ventajas y los escenarios de aplicación de Rust se resumen a continuación:
| Dimensión | Desempeño de Rust |
|---|---|
| Curva de aprendizaje | Pronunciada (el sistema de propiedad requiere comprensión y adaptación), pero los conceptos son estables y, una vez aprendidos, benefician de por vida |
| Velocidad de compilación | Lenta (muchas comprobaciones en tiempo de compilación), pero se mitiga con cargo check y la compilación incremental |
| Rendimiento en tiempo de ejecución | Al mismo nivel que C/C++, muy por encima de los lenguajes con GC |
| Seguridad de memoria | Garantizada en tiempo de compilación, sin GC, sin punteros nulos, punteros colgantes ni desbordamientos de búfer |
| Seguridad de concurrencia | Elimina las condiciones de carrera de datos en tiempo de compilación; sin miedo a la concurrencia |
| Madurez del ecosistema | Crece rápidamente; ya es muy maduro en programación de sistemas, WebAssembly y blockchain |
| Más adecuado para | Programación de sistemas, backends de alto rendimiento, WebAssembly, sistemas embebidos, blockchain, herramientas CLI, bases de datos |
| Menos adecuado para | Desarrollo rápido de prototipos (tiempo de compilación), aplicaciones GUI de escritorio, desarrollo de juegos (en comparación con motores maduros) |