Skip to content

Commit 8966417

Browse files
committed
feat(content:traits): add integrated traits
1 parent 1024c8b commit 8966417

File tree

1 file changed

+209
-0
lines changed

1 file changed

+209
-0
lines changed

content/5.traits/integrated.md

Lines changed: 209 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,209 @@
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

Comments
 (0)