Chuleta de Rust

Una página de consulta rápida para las cosas que querrás revisar sin volver a leer una lección entera. Cada sección enlaza a la página que lo explica a fondo.

Palabras clave

Palabra clave	Significado
`let`	Declara una variable (Variables)
`mut`	Hace mutable una variable o una referencia (Variables)
`const`	Declara una constante (Variables)
`fn`	Declara una función (Funciones)
`struct`	Declara un struct (Structs)
`enum`	Declara un enum (Enums)
`impl`	Agrega métodos a un tipo (Structs, Traits)
`trait`	Declara un trait (Traits)
`match`	Compara un valor con patrones (Match)
`if let` / `while let`	Compara con un solo patrón (If Let / While Let)
`loop` / `while` / `for`	Los tres tipos de bucle (Bucles, While, For)
`break` / `continue`	Controlan un bucle (Break/Continue)
`mod`	Declara un módulo (Módulos)
`pub`	Hace público un elemento fuera de su módulo (Módulos)
`use`	Trae una ruta al ámbito actual (Módulos)
`unsafe`	Habilita punteros crudos y otras operaciones que verificas tú (Unsafe)
`move`	Obliga a un closure a tomar el ownership de los valores que captura (Concurrencia)
`&` / `&mut`	Toma prestado un valor / lo toma prestado de forma mutable (Borrowing)

Métodos comunes de String

Método	Qué hace
`.len()`	Longitud en bytes
`.trim()`	Quita los espacios en blanco al principio y al final
`.to_uppercase()` / `.to_lowercase()`	Convierte a mayúsculas / minúsculas
`.contains(pat)`	Indica si contiene una subcadena o patrón
`.replace(from, to)`	Reemplaza todas las coincidencias
`.push_str(s)`	Agrega un `&str` al final
`.push(c)`	Agrega un solo `char` al final
`.chars()`	Recorre la cadena carácter por carácter
`.split(pat)`	Divide en un iterador de subcadenas
`.parse::<T>()`	Convierte el texto en otro tipo (devuelve un `Result`)

Consulta la página de Strings para ver más detalles y ejemplos.

Métodos comunes de Vec

Método	Qué hace
`.push(x)`	Agrega al final
`.pop()`	Quita y devuelve el último elemento (`Option`)
`.remove(i)`	Quita el elemento en el índice `i`
`.len()`	Cantidad de elementos
`.is_empty()`	Indica si el vector está vacío
`.get(i)`	Acceso seguro por índice (`Option`, no hace panic)
`.iter()`	Recorre por referencia
`.contains(&x)`	Indica si un valor está presente
`.sort()`	Ordena en el mismo vector
`.sort_by_key(\|x\| ...)`	Ordena por un campo o una clave calculada
`.dedup()`	Quita duplicados consecutivos (ordena primero)

Consulta las páginas de Vectores, Ordenar y buscar e Iteradores para ver más detalles y ejemplos.

¿Qué colección debo usar?

Tipo	Úsalo cuando necesites…
`Vec<T>`	Una lista ordenada que puede crecer
`HashMap<K, V>`	Buscar rápido un valor por su clave
`HashSet<T>`	Elementos únicos y comprobar rápido “¿está aquí?”
`BTreeMap<K, V>`	Pares clave-valor ordenados por clave
`VecDeque<T>`	Una cola: agregar y quitar por ambos extremos

Consulta las páginas de HashMaps y HashSet y BTreeMap para ver más detalles y ejemplos.

Option y Result

Método	Funciona con	Qué hace
`.unwrap()`	Ambos	Obtiene el valor; hace panic si es `None`/`Err`
`.expect("msg")`	Ambos	Como `.unwrap()`, pero con un mensaje de panic propio
`.unwrap_or(default)`	Ambos	Obtiene el valor, o uno de respaldo
`.is_some()` / `.is_none()`	`Option`	Comprueba qué variante es
`.is_ok()` / `.is_err()`	`Result`	Comprueba qué variante es
`?`	Ambos	Sale antes de tiempo si es `None`/`Err`

Consulta las páginas de Option y Result para ver más detalles y ejemplos.

Especificadores de formato (println!, format!)

Especificador	Qué imprime
`{}`	Formato normal (necesita el trait `Display`)
`{:?}`	Formato de depuración (Debug)
`{:#?}`	Formato de depuración con sangría, más fácil de leer
`{:.2}`	2 decimales
`{:5}`	Rellena hasta un ancho de 5
`{name}`	Inserta directamente una variable llamada `name`

Consulta la página de Salida para ver más detalles y ejemplos.

Comandos de Cargo

Comando	Qué hace
`cargo new name`	Crea un proyecto nuevo
`cargo run`	Compila y ejecuta
`cargo check`	Busca errores rápido, sin generar el ejecutable
`cargo test`	Ejecuta tus tests
`cargo add crate`	Agrega una dependencia
`cargo fmt`	Da formato a tu código
`cargo clippy`	Revisa tu código en busca de errores comunes
`cargo build --release`	Genera un ejecutable optimizado

Consulta la página de Cargo y crates para ver más detalles y ejemplos.

Sintaxis de rangos

Sintaxis	Significado
`1..5`	Del 1 al 5, sin incluir el 5
`1..=5`	Del 1 al 5, incluido el 5
`..3`	Desde el principio hasta el 3, sin incluirlo
`2..`	Desde el 2 hasta el final
`..`	Todo

Consulta las páginas de For y Slices para ver más detalles y ejemplos.

Crates populares

Necesitas…	Crate	Lección
JSON (y otros formatos)	`serde` + `serde_json`	JSON con Serde
Código asíncrono, temporizadores, red	`tokio`	Async/Await
Una interfaz de línea de comandos	`clap`	CLI con clap
Manejo de errores sencillo	`anyhow`, `thiserror`	anyhow y thiserror
Números aleatorios	`rand`	Números aleatorios
Expresiones regulares	`regex`	Expresiones regulares
Fechas y horas	`chrono`	Fechas y horas
Logging (registro de eventos)	`log` + `env_logger`, `tracing`	Logging
Un servidor web	`axum`	API web con Axum

Agrega cualquiera de ellos con cargo add <crate>. Consulta Cargo y crates para saber cómo elegir un buen crate.

Para leer más

Rust Language Cheat Sheet — cheats.rs: una referencia de una página mucho más completa, desde la sintaxis hasta el diseño de memoria (en inglés).
Apéndice B: Operadores y símbolos — El libro de Rust: todos los operadores y símbolos de Rust y lo que significan (en inglés).
std::fmt — documentación de la biblioteca estándar: toda la sintaxis de formato de println! y format!: ancho, relleno, precisión y más (en inglés).
Comandos de Cargo — The Cargo Book: cada comando de cargo con sus opciones (en inglés).