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
- Dado un
Vec<i32>, calcula la media, la mediana (ordena primero) y la moda (usa unHashMap). - Escribe
fn is_palindrome(s: &str) -> boolque ignore las mayúsculas y los caracteres no alfanuméricos. - 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 deay(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.¿Por qué no compila
let s = String::from("héllo"); let c = s[1];?2.¿Qué devuelve
v.get(10)en un vector de 3 elementos?3.¿Qué hace
*map.entry(k).or_insert(0) += 1?