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ñoDescripció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 ceroLas 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 miedoEl sistema de tipos y las reglas de propiedad eliminan las condiciones de carrera en tiempo de compilación.
PragmatismoPuede escribir tanto núcleos de sistemas operativos como aplicaciones web, cubriendo escenarios de pila completa.
Fuerte inferencia de tiposEl compilador deduce automáticamente la mayoría de los tipos, reduciendo el código repetitivo.
Ecosistema de herramientas ricoCargo (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ñoVersión/EventoDescripción
2006Proyecto personalGraydon Hoare comienza a diseñar Rust.
2009Patrocinio de MozillaMozilla apoya oficialmente el desarrollo de Rust y forma un equipo.
2010Primera presentación públicaEl compilador de Rust (escrito en OCaml) se presenta públicamente por primera vez en la cumbre de Mozilla.
2011Autocompilación completadaEl compilador de Rust se reescribe en Rust, eliminando la dependencia de OCaml.
Mayo de 2015Rust 1.0Se publica la primera versión estable, marcando que el lenguaje es oficialmente utilizable en producción.
Diciembre de 2018Rust 2018 EditionSe publica la primera Edition, optimizando la sintaxis y el sistema de módulos (se introduce el verificador de préstamos NLL).
2019Se consolida el ecosistema asíncronoLa sintaxis async/await se estabiliza y los runtimes asíncronos como Tokio maduran.
2021Creación de la Fundación RustAWS, Google, Huawei, Microsoft y Mozilla fundan conjuntamente la Fundación Rust.
Octubre de 2021Rust 2021 EditionSe introducen mejoras como disjoint capture, IntoIterator para arrays, etc.
2022Adopción en el kernel de LinuxLinux 6.1 incorpora oficialmente soporte para Rust, convirtiéndose en el segundo lenguaje para el desarrollo del kernel.
Febrero de 2024Rust 2024 EditionSe 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:

ReglaDescripciónSignificado
Cada valor tiene exactamente un propietarioUn valor solo puede ser propiedad de una variable a la vezElimina double-free y punteros colgantes
Cuando el propietario sale del ámbito, el valor se liberaCuando una variable sale de su ámbito, Rust llama automáticamente a drop para liberar memoriaSin gestión manual de memoria
En un mismo momento: o una referencia mutable o múltiples referencias inmutablesLectura y escritura son mutuamente excluyentes, múltiples lecturas coexistenElimina 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

fn main() {
    // 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

fn main() {
    // 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

use std::fs;

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

fn main() {
    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::sync::{Arc, Mutex};
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".

ComandoFunciónEscenario típico
cargo new projectCrear nuevo proyectoInicializa el proyecto y genera automáticamente Cargo.toml y src/main.rs
cargo buildCompilar el proyecto (modo debug)Desarrollo y depuración
cargo build --releaseCompilar el proyecto (modo optimizado)Publicación en producción, activa todas las optimizaciones del compilador
cargo runCompilar y ejecutarProbar código rápidamente
cargo testEjecutar pruebasPruebas unitarias, pruebas de integración, pruebas de documentación
cargo checkVerifica rápidamente si el código compila (sin generar binarios)Verificación de sintaxis en tiempo real en el IDE
cargo doc --openGenerar y abrir documentaciónExplorar la documentación de API de las bibliotecas dependientes
cargo clippyRevisión de estilo de código (lint)Detecta prácticas no recomendadas y problemas potenciales
cargo fmtFormateo de códigoUnifica el estilo de código
cargo publishPublicar en crates.ioPublicar 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:

HerramientaFunciónObjeto que reemplaza
ripgrep (rg)Búsqueda de código ultrarrápidagrep
fdBúsqueda rápida de archivosfind
batVisor de archivos con resaltado de sintaxiscat
deltaGit diff con resaltado de sintaxisgit diff
zoxideNavegación inteligente de directorioscd
dustAnálisis de espacio en discodu

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

[package]
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

// Ruta del archivo: src/main.rs
// 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

fn main() {
    // 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íaTipoEjemploDescripción
Enteros con signoi8, i16, i32, i64, i128, isizelet x: i32 = -42;El tipo entero por defecto es i32
Enteros sin signou8, u16, u32, u64, u128, usizelet y: u64 = 100;usize se usa para índices y longitudes
Números de punto flotantef32, f64let pi: f64 = 3.14;El tipo de punto flotante por defecto es f64
Booleanosboollet ok: bool = true;true o false
Caráctercharlet 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ámicoVec<T>let v: Vec<i32> = vec![1,2,3];Longitud variable, asignado en el montón
Cadena de caracteresString / &strlet 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

fn main() {
    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

// Función normal: toma dos i32 y devuelve su suma
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

// Definición de una estructura (similar a struct de C, pero más potente)
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

// Ruta del archivo: src/main.rs
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

// Ruta del archivo: src/main.rs
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:

ComandoFunciónDescripción
rustup updateActualizar la cadena de herramientas de RustActualiza rustc, cargo, etc. a la última versión estable
rustup component add rustfmtInstalar herramienta de formateo de códigoFormatea el código automáticamente al guardar
rustup component add clippyInstalar herramienta de análisis de códigoDetecta escrituras no recomendadas y posibles errores
rustup docAbrir documentación localVer la biblioteca estándar y The Book sin conexión
cargo add <crate>Añadir dependenciaEdita automáticamente Cargo.toml y obtiene la última versión
cargo updateActualizar versión de dependenciasActualiza Cargo.lock según las restricciones de versión de Cargo.toml
cargo treeVer árbol de dependenciasVisualiza las dependencias completas del proyecto
cargo benchEjecutar pruebas de referencia (benchmarks)Mide el rendimiento del código
cargo install <tool>Instalar herramientas CLI escritas en RustPor 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

fn main() {
    // 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ónDesempeño de Rust
Curva de aprendizajePronunciada (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ónLenta (muchas comprobaciones en tiempo de compilación), pero se mitiga con cargo check y la compilación incremental
Rendimiento en tiempo de ejecuciónAl mismo nivel que C/C++, muy por encima de los lenguajes con GC
Seguridad de memoriaGarantizada en tiempo de compilación, sin GC, sin punteros nulos, punteros colgantes ni desbordamientos de búfer
Seguridad de concurrenciaElimina las condiciones de carrera de datos en tiempo de compilación; sin miedo a la concurrencia
Madurez del ecosistemaCrece rápidamente; ya es muy maduro en programación de sistemas, WebAssembly y blockchain
Más adecuado paraProgramación de sistemas, backends de alto rendimiento, WebAssembly, sistemas embebidos, blockchain, herramientas CLI, bases de datos
Menos adecuado paraDesarrollo rápido de prototipos (tiempo de compilación), aplicaciones GUI de escritorio, desarrollo de juegos (en comparación con motores maduros)
Otras extensiones