Hoja de Trucos de Rust
Última actualización
Hola Mundo y estructura
Un programa Rust empieza en fn main; las sentencias terminan en punto y coma.
| Operación | Sintaxis |
|---|---|
| Punto de entrada | fn main() { ... } |
| Imprimir una línea | println!("Hello, World!"); |
| Imprimir con valores | println!("{} is {}", name, age); |
| Imprimir en forma de depuración | println!("{:?}", value); |
| Comentario de línea | // comment |
| Usar un elemento de un módulo | use std::collections::HashMap; |
| Compilar y ejecutar | cargo run |
| Compilar un binario de release | cargo build --release |
Variables y tipos (let / mut)
Los enlaces son inmutables por defecto; añade mut para permitir la reasignación.
| Operación | Sintaxis |
|---|---|
| Enlace inmutable | let x = 5; |
| Enlace mutable | let mut count = 0; |
| Tipo explícito | let age: u32 = 30; |
| Constante | const MAX: u32 = 100; |
| Shadowing | let x = x + 1; |
| Tipos enteros | i32, u32, i64, usize |
| Otros escalares | f64, bool, char |
| Tupla | let pair: (i32, &str) = (1, "a"); |
| Conversión de tipo | let f = x as f64; |
Control de flujo
if es una expresión, y Rust tiene tres formas de bucle.
| Operación | Sintaxis |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If como expresión | let y = if x > 0 { 1 } else { -1 }; |
| Bucle infinito | loop { ... } |
| Bucle que devuelve un valor | let v = loop { break 5; }; |
| Bucle while | while x < 100 { ... } |
| For sobre un rango | for i in 0..10 { ... } |
| For sobre una colección | for item in &items { ... } |
| Break / continue | break;, continue; |
Funciones
La última expresión (sin punto y coma) es el valor de retorno.
| Operación | Sintaxis |
|---|---|
| Función básica | fn add(a: i32, b: i32) -> i32 { a + b } |
| Retorno explícito | fn f() -> i32 { return 5; } |
| Sin valor de retorno | fn log(msg: &str) { ... } |
| Tomar una referencia | fn len(s: &String) -> usize { s.len() } |
| Clausura | let add = |a, b| a + b; |
| Clausura con tipo | let sq = |x: i32| -> i32 { x * x }; |
| Función como argumento | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership y borrowing
Cada valor tiene un único propietario; las referencias lo toman prestado sin asumir la propiedad.
| Operación | Sintaxis |
|---|---|
| Move (la propiedad se transfiere) | let b = a; (a ya no es válido) |
| Clone (copia profunda) | let b = a.clone(); |
| Préstamo inmutable | let r = &x; |
| Préstamo mutable | let r = &mut x; |
| Préstamo en una función | fn read(s: &String) { ... } |
| Desreferencia | *r |
| Regla de préstamo | Muchos & O un solo &mut a la vez, no ambos |
| Slice (toma prestado un rango) | let part = &arr[1..3]; |
Structs y enums
Los structs agrupan datos relacionados; los enums modelan un valor que es una de varias variantes.
| Operación | Sintaxis |
|---|---|
| Definir un struct | struct Point { x: i32, y: i32 } |
| Crear una instancia | let p = Point { x: 1, y: 2 }; |
| Acceder a un campo | p.x |
| Struct de tupla | struct Pair(i32, i32); |
| Método (bloque impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Función asociada | impl Point { fn new() -> Self { ... } } |
| Definir un enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum con campos nombrados | enum Msg { Move { x: i32, y: i32 } } |
| Derivar traits | #[derive(Debug, Clone)] |
Coincidencia de patrones (match)
match compara un valor con patrones y debe ser exhaustivo.
| Operación | Sintaxis |
|---|---|
| Coincidir con valores | match x { 1 => "one", _ => "other" } |
| Coincidir con un enum | match shape { Shape::Circle(r) => ... } |
| Coincidir con un rango | match n { 1..=5 => ..., _ => ... } |
| Enlazar con una guarda | match x { n if n > 0 => ... } |
| Coincidir con una tupla | match point { (0, y) => ..., (x, _) => ... } |
| if let (un solo patrón) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Desestructurar un struct | let Point { x, y } = p; |
Traits y genéricos
Los traits definen un comportamiento compartido; los genéricos hacen que el código funcione con muchos tipos.
| Operación | Sintaxis |
|---|---|
| Definir un trait | trait Area { fn area(&self) -> f64; } |
| Implementar un trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Método por defecto | trait Greet { fn hi(&self) { ... } } |
| Función genérica | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Struct genérico | struct Wrapper<T> { value: T } |
| Restricción de trait (where) | fn f<T>(x: T) where T: Display { ... } |
| Argumento impl Trait | fn print(item: impl Display) { ... } |
| Objeto trait | let shapes: Vec<Box<dyn Area>> = ...; |
Manejo de errores (Result / Option)
Rust modela la ausencia con Option y los errores recuperables con Result.
| Operación | Sintaxis |
|---|---|
| Valor opcional | Option<T>: Some(v) o None |
| Tipo Result | Result<T, E>: Ok(v) o Err(e) |
| Devolver un Result | fn read() -> Result<String, Error> { ... } |
| Propagar con ? | let data = read()?; |
| Unwrap (provoca panic en None/Err) | opt.unwrap() |
| Valor por defecto | opt.unwrap_or(0) |
| Mapear un valor | opt.map(|v| v + 1) |
| Manejar ambas ramas | match res { Ok(v) => ..., Err(e) => ... } |
| Convertir Option a Result | opt.ok_or("missing")? |
Colecciones comunes (Vec / HashMap)
Vec es un array que crece; HashMap es un almacén clave-valor.
| Operación | Sintaxis |
|---|---|
| Crear un vector | let mut v: Vec<i32> = Vec::new(); |
| Literal de vector | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Acceso por índice | v[0] |
| Acceso seguro | v.get(0) devuelve Option<&T> |
| Iterar | for x in &v { ... } |
| Longitud | v.len() |
| Crear un mapa | let mut m: HashMap<String, i32> = HashMap::new(); |
| Insertar / obtener | m.insert(k, v);, m.get(&k) |
| API Entry | *m.entry(k).or_insert(0) += 1; |
La sintaxis de Rust que más usas, en una sola página. Esta hoja de trucos de Rust es una referencia rápida para el núcleo del lenguaje: variables y mutabilidad, ownership y borrowing, structs y enums, coincidencia de patrones, traits y genéricos, y los tipos Result y Option que respaldan el manejo de errores de Rust.
Todo lo que hay aquí es Rust estándar que compila en una cadena de herramientas estable reciente. Copia lo que necesites o prueba cada fragmento en vivo en el playground de Rust, sin necesidad de instalar cargo.
Preguntas frecuentes sobre la hoja de trucos de Rust
¿Esta hoja de trucos de Rust es gratis?
Sí. Esta hoja de trucos de Rust es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar un patrón de match, una restricción de trait o un método de colección.
¿Qué son el ownership y el borrowing en Rust?
El ownership es el modelo de memoria de Rust: cada valor tiene exactamente un propietario, y el valor se libera cuando ese propietario sale de ámbito. El borrowing te permite acceder a un valor sin asumir su propiedad usando una referencia:
&x para un préstamo inmutable o &mut x para uno mutable. El compilador impone una regla: puedes tener muchos préstamos inmutables o exactamente un préstamo mutable a la vez, lo cual previene las condiciones de carrera en tiempo de compilación.¿Cuál es la diferencia entre Result y Option en Rust?
Option<T> representa un valor que puede estar ausente: es Some(v) o None, y lo usas cuando no hay ningún error que reportar, solo un valor faltante. Result<T, E> representa una operación que puede fallar: es Ok(v) o Err(e), y lleva un valor de error cuando algo sale mal. Usa Option para "quizás está ahí" y Result para "esto podría fallar"; el operador ? propaga ambos.¿Puedo practicar Rust en línea?
Sí. Abre el playground de Rust para compilar y ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar cargo ni ninguna cadena de herramientas. Cuando quieras estructura, el curso interactivo y gratuito de Rust de Coddy te lleva paso a paso desde las variables y el ownership hasta los traits y el manejo de errores.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los temas más comunes (variables, control de flujo, funciones) hasta los avanzados (traits, genéricos, manejo de errores), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el ownership y el resto.
Recursos relacionados
Más hojas de referencia
