Biblioteca estándar de Rust: revisión completa de los módulos y capacidades principales

Biblioteca estándar de Rust: revisión completa

La biblioteca estándar de Rust (std) es un conjunto de módulos fundamentales que proporcionan al desarrollador todo lo necesario para crear aplicaciones robustas, rápidas y seguras. A diferencia de muchos otros lenguajes, Rust presta especial atención a la seguridad de la memoria y al paralelismo sin recolector de basura. En este artículo, analizaremos en detalle los componentes clave de std con ejemplos de código.

1. Módulos principales de la biblioteca estándar

La biblioteca está dividida en varios grupos lógicos. Veamos los más importantes.

1.1. Módulo std::collections

Contiene estructuras de datos para almacenar y gestionar colecciones de elementos. Los más populares:

• Vec<T> — array dinámico (análogo a ArrayList en Java).
• HashMap<K, V> — tabla hash para almacenar pares clave-valor.
• HashSet<T> — conjunto de valores únicos.
• BTreeMap y BTreeSet — colecciones ordenadas basadas en árbol rojo-negro.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 90);

    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

1.2. Módulo std::io

Se encarga de la entrada/salida: lectura desde teclado, trabajo con archivos, entrada/salida con búfer. Tipos clave: Read y Write.

use std::io::{self, BufRead};

fn main() -> io::Result<()> {    let stdin = io::stdin();    for line in stdin.lock().lines() {        println!("Usted ingresó: {}", line?);    }    Ok(())}

1.3. Módulo std::thread

Permite crear y gestionar hilos de ejecución. Rust garantiza la seguridad de los datos entre hilos mediante el sistema de propiedad y los traits Send y Sync.

use std::thread;

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

    for i in 1..5 {        println!("Hilo principal: {}", i);    }

    handle.join().unwrap();}

2. Trabajo con cadenas y texto

En Rust hay dos tipos de cadenas:

• String — cadena mutable con propiedad (almacenada en el heap).
• &str — slice de cadena inmutable (referencia a una secuencia UTF-8).

fn main() {    let mut hello = String::from("Hola, ");    hello.push_str("mundo!");    println!("{}", hello); // Salida: Hola, mundo!

    let slice: &str = &hello[0..4];    println!("Slice: {}", slice); // Salida: Hola}

3. Manejo de errores

En lugar de excepciones, Rust utiliza dos enumeraciones:

• Option<T> — para casos donde el valor puede estar ausente (Some o None).
• Result<T, E> — para operaciones que pueden fallar (Ok o Err).

use std::fs::File;use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let mut file = File::open(path)?;    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

fn main() {    match read_file("test.txt") {        Ok(content) => println!("Contenido: {}", content),        Err(e) => eprintln!("Error: {}", e),    }}

4. Iteradores y closures

Los iteradores en Rust son perezosos y potentes. Permiten procesar secuencias de datos sin bucles explícitos.

fn main() {    let numbers = vec![1,