FerrousPath

Nivel 1 · Fundamentos· Lección 8 de 10 · 25 min

Colecciones y cadenas

Vec, String y HashMap — las tres colecciones que usarás a diario — y por qué no se puede indexar una cadena.

Vec<T>: un array que crece

fn main() {
    let mut v: Vec<i32> = Vec::new();
    v.push(10);
    v.push(20);
    v.push(30);

    let w = vec![1, 2, 3]; // la macro vec! construye uno a partir de una lista

    println!("{v:?} {w:?} len={} first={}", v.len(), v[0]);

    // Dos formas de leer un elemento:
    let third = v[2];           // entra en pánico si está fuera de los límites
    let maybe = v.get(99);      // devuelve Option<&i32>
    println!("{third} {maybe:?}");

    // Iterar: por referencia compartida, por referencia mutable, por valor.
    for x in &v {
        print!("{x} ");
    }
    for x in &mut v {
        *x *= 2; // desreferencia para modificar el elemento
    }
    println!("\n{v:?}");
    for x in v {
        print!("{x} "); // consume v
    }
    // v ya no existe.
}

Un Vec es dueño de sus elementos: liberar el vector libera todo lo que contiene. Métodos útiles: pop, insert, remove, contains, sort, dedup, retain, extend, iter, first, last, is_empty.

Cadenas

Rust tiene dos tipos principales de cadena:

Tipo ¿Tiene dueño? ¿Puede crecer? Dónde viven los bytes
String sí sí en el heap
&str no: es un slice prestado no en cualquier parte: un String, el binario del programa, …

Los literales de cadena como "hello" son &'static str, incrustados en el binario. Ambos tipos son siempre UTF-8 válido.

fn main() {
    let mut s = String::new();
    s.push_str("hello");
    s.push(' ');
    s += "world";

    let name = "Ferris";
    let greeting = format!("{s}, {name}!"); // format! construye un String
    println!("{greeting}");

    let owned: String = "literal".to_string();
    let borrowed: &str = &owned;
    println!("{owned} {borrowed}");
}

Por qué no existe s[0]

fn main() {
    let word = "naïve 🦀";
    println!("bytes: {}", word.len());            // 11, no 7
    println!("chars: {}", word.chars().count());  // 7

    for c in word.chars() {
        print!("[{c}]");
    }
    println!();
    println!("{:?}", word.bytes().take(4).collect::<Vec<u8>>());

    println!("{}", &word[0..2]);  // rango de bytes: correcto, "na"
    // println!("{}", &word[0..3]); // entraría en pánico: el byte 3 está dentro de 'ï'
    println!("{:?}", word.char_indices().nth(2));
}

En UTF-8, ï ocupa dos bytes y 🦀 ocupa cuatro. Indexar con un entero tendría que elegir entre devolver un byte (a menudo sin sentido) y recorrer la cadena desde el principio (lento, y oculto). Rust no ofrece ninguna de las dos cosas; eliges explícitamente .bytes(), .chars() o un slice por rango de bytes.

Métodos de cadena útiles: trim, split, split_whitespace, lines, contains, starts_with, replace, to_uppercase, parse, find.

HashMap<K, V>

use std::collections::HashMap;

fn main() {
    let mut stock: HashMap<String, u32> = HashMap::new();
    stock.insert(String::from("apples"), 3);
    stock.insert(String::from("pears"), 5);

    if let Some(n) = stock.get("apples") {
        println!("{n} apples");
    }
    println!("kiwis: {}", stock.get("kiwis").copied().unwrap_or(0));

    // La API entry: actualizar o insertar con una sola búsqueda.
    let text = "the quick brown fox jumps over the lazy dog the end";
    let mut counts: HashMap<&str, u32> = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }

    let mut pairs: Vec<_> = counts.into_iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(b.0)));
    for (word, n) in pairs.iter().take(3) {
        println!("{word}: {n}");
    }
}

El orden de iteración de un HashMap es arbitrario y cambia de una ejecución a otra. Usa BTreeMap cuando necesites las claves ordenadas. Insertar una clave con dueño, como un String, la mueve dentro del mapa.

Otras colecciones de std::collections: HashSet, BTreeMap, BTreeSet, VecDeque (una cola de doble extremo) y BinaryHeap (una cola de prioridad).

Ejercicios

  1. Dado un Vec<i32>, calcula la media, la mediana (ordena primero) y la moda (usa un HashMap).
  2. Escribe fn is_palindrome(s: &str) -> bool que ignore las mayúsculas y los caracteres no alfanuméricos.
  3. Escribe fn pig_latin(word: &str) -> String: a las palabras que empiezan por vocal se les añade -hay; en las demás, la primera letra pasa al final seguida de ay (first → irst-fay).
Solución del 2
fn is_palindrome(s: &str) -> bool {
    let cleaned: Vec<char> = s
        .chars()
        .filter(|c| c.is_alphanumeric())
        .flat_map(|c| c.to_lowercase())
        .collect();
    cleaned.iter().eq(cleaned.iter().rev())
}

fn main() {
    println!("{}", is_palindrome("A man, a plan, a canal: Panama"));
    println!("{}", is_palindrome("Rust"));
}

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Por qué no compila let s = String::from("héllo"); let c = s[1];?

  2. 2.¿Qué devuelve v.get(10) en un vector de 3 elementos?

  3. 3.¿Qué hace *map.entry(k).or_insert(0) += 1?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?