|
| 1 | +--- |
| 2 | +title: 'Traits Integrados' |
| 3 | +description: 'Entendiendo los Traits Más Importantes en Rust' |
| 4 | +draft: true |
| 5 | +data: |
| 6 | + type: 'custom' |
| 7 | + topicLevel: 'start' |
| 8 | + position: |
| 9 | + x: 200 |
| 10 | + y: 900 |
| 11 | + sourcePosition: |
| 12 | + cargo: 'top' |
| 13 | + targetPosition: |
| 14 | + smart-pointers: 'bottom' |
| 15 | +--- |
| 16 | +### Entendiendo los Traits Más Importantes en Rust |
| 17 | + |
| 18 | +Rust incluye una rica colección de *traits* estándar que permiten a los tipos integrarse con el lenguaje y aprovechar comportamientos reutilizables. Estos *traits* son contratos que los tipos pueden implementar para adquirir funcionalidades específicas. Aquí exploraremos algunos de los más importantes, explicando sus conceptos y cómo aplicarlos. |
| 19 | + |
| 20 | +### **1. El Trait `Default`: Valores Predeterminados** |
| 21 | +El trait `Default` define un método para crear un valor predeterminado para un tipo. Esto es especialmente útil al inicializar estructuras grandes con valores predecibles. |
| 22 | + |
| 23 | +#### Definición |
| 24 | +```rust |
| 25 | +pub trait Default { |
| 26 | + fn default() -> Self; |
| 27 | +} |
| 28 | +``` |
| 29 | + |
| 30 | +#### Ejemplo |
| 31 | +```rust |
| 32 | +struct Config { |
| 33 | + retries: u32, |
| 34 | + verbose: bool, |
| 35 | +} |
| 36 | + |
| 37 | +impl Default for Config { |
| 38 | + fn default() -> Self { |
| 39 | + Config { |
| 40 | + retries: 3, |
| 41 | + verbose: false, |
| 42 | + } |
| 43 | + } |
| 44 | +} |
| 45 | + |
| 46 | +fn main() { |
| 47 | + let default_config = Config::default(); |
| 48 | + println!("Retries: {}, Verbose: {}", default_config.retries, default_config.verbose); |
| 49 | +} |
| 50 | +``` |
| 51 | + |
| 52 | +### **2. Los Traits `Clone` y `Copy`: Clonación y Copia** |
| 53 | +- **`Clone`**: Proporciona un método explícito para crear una copia profunda de un valor. |
| 54 | +- **`Copy`**: Es una versión implícita y más ligera de clonación, aplicable solo a tipos que se pueden copiar de manera trivial (como números primitivos). |
| 55 | + |
| 56 | +#### Definición |
| 57 | +```rust |
| 58 | +pub trait Clone { |
| 59 | + fn clone(&self) -> Self; |
| 60 | +} |
| 61 | + |
| 62 | +pub trait Copy: Clone {} |
| 63 | +``` |
| 64 | + |
| 65 | +#### Ejemplo |
| 66 | +```rust |
| 67 | +#[derive(Clone, Copy)] |
| 68 | +struct Point { |
| 69 | + x: i32, |
| 70 | + y: i32, |
| 71 | +} |
| 72 | + |
| 73 | +fn main() { |
| 74 | + let p1 = Point { x: 1, y: 2 }; |
| 75 | + let p2 = p1; // Copia implícita |
| 76 | + let p3 = p1.clone(); // Copia explícita |
| 77 | + println!("p1: ({}, {}), p2: ({}, {}), p3: ({}, {})", p1.x, p1.y, p2.x, p2.y, p3.x, p3.y); |
| 78 | +} |
| 79 | +``` |
| 80 | + |
| 81 | +#### Nota sobre `Copy` |
| 82 | +Un tipo que implementa `Copy` no puede tener campos que no lo implementen. |
| 83 | + |
| 84 | +### **3. Comparación: `PartialEq` y `Eq`** |
| 85 | +Rust proporciona dos traits para comparar tipos: |
| 86 | +- **`PartialEq`**: Permite verificar si dos valores son iguales (`==`) o diferentes (`!=`). |
| 87 | +- **`Eq`**: Es un subtipo de `PartialEq` que asegura que el operador `==` siempre sea reflexivo (es decir, `a == a` siempre es verdadero). |
| 88 | + |
| 89 | +#### Ejemplo |
| 90 | +```rust |
| 91 | +#[derive(PartialEq, Eq)] |
| 92 | +struct User { |
| 93 | + id: u32, |
| 94 | + name: String, |
| 95 | +} |
| 96 | + |
| 97 | +fn main() { |
| 98 | + let user1 = User { id: 1, name: "Alice".to_string() }; |
| 99 | + let user2 = User { id: 1, name: "Alice".to_string() }; |
| 100 | + |
| 101 | + if user1 == user2 { |
| 102 | + println!("Users are equal!"); |
| 103 | + } |
| 104 | +} |
| 105 | +``` |
| 106 | + |
| 107 | +### **4. Ordenamiento: `PartialOrd` y `Ord`** |
| 108 | +- **`PartialOrd`**: Permite comparar valores con `<`, `>`, `<=`, `>=`. |
| 109 | +- **`Ord`**: Extiende `PartialOrd` para tipos totalmente ordenables. |
| 110 | + |
| 111 | +#### Ejemplo |
| 112 | +```rust |
| 113 | +#[derive(PartialOrd, Ord, PartialEq, Eq)] |
| 114 | +struct Item { |
| 115 | + price: u32, |
| 116 | +} |
| 117 | + |
| 118 | +fn main() { |
| 119 | + let item1 = Item { price: 10 }; |
| 120 | + let item2 = Item { price: 20 }; |
| 121 | + |
| 122 | + if item1 < item2 { |
| 123 | + println!("Item1 is cheaper than Item2"); |
| 124 | + } |
| 125 | +} |
| 126 | +``` |
| 127 | + |
| 128 | +### **5. Traits de Funciones: `Fn`, `FnMut` y `FnOnce`** |
| 129 | +Estos traits representan diferentes tipos de clausuras (*closures*). |
| 130 | + |
| 131 | +- **`FnOnce`**: Consumo único. |
| 132 | +- **`FnMut`**: Clausura mutable. |
| 133 | +- **`Fn`**: Clausura inmutable. |
| 134 | + |
| 135 | +#### Ejemplo |
| 136 | +```rust |
| 137 | +fn execute<F>(operation: F) |
| 138 | +where |
| 139 | + F: FnOnce(), |
| 140 | +{ |
| 141 | + operation(); |
| 142 | +} |
| 143 | + |
| 144 | +fn main() { |
| 145 | + let greeting = "Hello".to_string(); |
| 146 | + execute(|| println!("{}", greeting)); // FnOnce |
| 147 | +} |
| 148 | +``` |
| 149 | + |
| 150 | +### **6. El Trait `Drop`: Limpiar Recursos** |
| 151 | +Permite ejecutar lógica personalizada cuando un valor sale de alcance. |
| 152 | + |
| 153 | +#### Ejemplo |
| 154 | +```rust |
| 155 | +struct Resource { |
| 156 | + name: String, |
| 157 | +} |
| 158 | + |
| 159 | +impl Drop for Resource { |
| 160 | + fn drop(&mut self) { |
| 161 | + println!("Releasing resource: {}", self.name); |
| 162 | + } |
| 163 | +} |
| 164 | + |
| 165 | +fn main() { |
| 166 | + let _res = Resource { name: "FileHandle".to_string() }; |
| 167 | +} // `_res` se libera aquí automáticamente. |
| 168 | +``` |
| 169 | + |
| 170 | +### **7. Iteradores: `Iterator`** |
| 171 | +El trait `Iterator` es fundamental para trabajar con iteraciones. Define cómo un tipo produce una secuencia de valores. |
| 172 | + |
| 173 | +#### Definición |
| 174 | +```rust |
| 175 | +pub trait Iterator { |
| 176 | + type Item; |
| 177 | + fn next(&mut self) -> Option<Self::Item>; |
| 178 | +} |
| 179 | +``` |
| 180 | + |
| 181 | +#### Ejemplo |
| 182 | +```rust |
| 183 | +struct Counter { |
| 184 | + count: u32, |
| 185 | +} |
| 186 | + |
| 187 | +impl Iterator for Counter { |
| 188 | + type Item = u32; |
| 189 | + |
| 190 | + fn next(&mut self) -> Option<Self::Item> { |
| 191 | + if self.count < 5 { |
| 192 | + self.count += 1; |
| 193 | + Some(self.count) |
| 194 | + } else { |
| 195 | + None |
| 196 | + } |
| 197 | + } |
| 198 | +} |
| 199 | + |
| 200 | +fn main() { |
| 201 | + let mut counter = Counter { count: 0 }; |
| 202 | + while let Some(value) = counter.next() { |
| 203 | + println!("Count: {}", value); |
| 204 | + } |
| 205 | +} |
| 206 | +``` |
| 207 | + |
| 208 | +### **Conclusión** |
| 209 | +Estos traits estándar son esenciales en Rust, ya que forman la base para operaciones comunes como clonación, comparación, iteración y manejo de recursos. Entender cómo y cuándo usarlos es clave para aprovechar todo el potencial de Rust y escribir código más limpio, seguro y eficiente. |
0 commit comments