Biblioteca estándar de Rust: revisión completa

Biblioteca estándar de Rust: revisión completa

La biblioteca estándar de Rust (std) es el núcleo del ecosistema del lenguaje, proporcionando a los desarrolladores herramientas potentes y seguras para crear aplicaciones de alto rendimiento. A diferencia de muchos otros lenguajes, Rust presta especial atención a la seguridad de la memoria y a las abstracciones de costo cero, lo que hace que std no sea solo un conjunto de utilidades, sino la base para escribir código confiable. En este artículo, analizaremos en detalle los módulos principales de la biblioteca estándar, sus funcionalidades y proporcionaremos ejemplos prácticos.

Módulos principales de la biblioteca estándar

La biblioteca estándar de Rust incluye numerosos módulos que cubren prácticamente todos los aspectos del desarrollo. Veamos los más importantes:

• std::collections — estructuras de datos (HashMap, Vec, BTreeMap, HashSet, etc.)
• std::io — entrada/salida (lectura/escritura de archivos, trabajo con consola)
• std::fs — trabajo con el sistema de archivos
• std::thread — multihilo
• std::sync — sincronización de hilos (Mutex, Arc, Barrier)
• std::net — programación de redes (TCP, UDP)
• std::path — trabajo con rutas del sistema de archivos
• std::error — manejo de errores

Trabajo con colecciones (std::collections)

El módulo std::collections proporciona estructuras de datos eficientes. La más popular es Vec<T> (arreglo dinámico). También se usan frecuentemente HashMap<K, V> para almacenar pares clave-valor y HashSet<T> para elementos únicos.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Blue"), 10);    scores.insert(String::from("Yellow"), 50);

    // Acceso por clave    match scores.get(&"Blue".to_string()) {        Some(score) => println!("Score: {}", score),        None => println!("No score found"),    }}

Entrada/salida y trabajo con archivos (std::io y std::fs)

Los módulos std::io y std::fs permiten leer y escribir archivos, así como trabajar con entrada/salida de consola. Rust garantiza un trabajo seguro con archivos gracias al sistema de propiedad.

use std::fs::File;use std::io::{BufRead, BufReader, Write};

fn main() -> std::io::Result<()> {    // Escritura en archivo    let mut file = File::create("example.txt")?;    file.write_all(b"Hello, Rust!")?;

    // Lectura de archivo línea por línea    let file = File::open("example.txt")?;    let reader = BufReader::new(file);    for line in reader.lines() {        println!("{}", line?);    }    Ok(())}

Multihilo (std::thread)

Rust proporciona un modelo seguro de multihilo a través del módulo std::thread. El compilador previene las condiciones de carrera en tiempo de compilación gracias a las reglas de propiedad y préstamo.

use std::thread;use std::time::Duration;

fn main() {    let handle = thread::spawn(|| {        for i in 1..5 {            println!("Hilo: {}", i);            thread::sleep(Duration::from_millis(100));        }    });

    for i in 1..3 {        println!("Hilo principal: {}", i);        thread::sleep(Duration::from_millis(50));    }

    handle.join().unwrap();}

Sincronización (std::sync)

Para el intercambio seguro de datos entre hilos se utilizan primitivas de std::sync: Mutex (exclusión mutua), Arc (contador de referencias atómico) y Barrier (barrera de sincronización).

use std::sync::{Arc, Mutex};use std::thread;

fn main() {    let counter = Arc::new(Mutex::new(0));    let mut handles = vec![];

    for _ in 0..10 {\