feat(content): add basic vector

Author: SergioRibera

content/2.basic/29.vector.md

@@ -0,0 +1,153 @@
+---
+title: 'Vec'
+description: 'Explorando Vec<T> en Rust: La Potente Colección de Vectores'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 50
+    y: 600
+  # width: 320
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: 'https://book.rustlang-es.org/ch08-01-vectors'
+    - name: 'Comprehensive Rust'
+      english: false
+      link: 'https://google.github.io/comprehensive-rust/es/std-types/vec.html'
+    - name: 'Documentacion Oficial'
+      english: true
+      link: 'https://doc.rust-lang.org/std/vec/struct.Vec.html'
+---
+## Vec<T> en Rust: La Potente Colección de Vectores
+
+El tipo `Vec<T>` en Rust es una colección dinámica y flexible que permite almacenar una secuencia de elementos del mismo tipo. `Vec<T>` es una parte fundamental de la programación en Rust, proporcionando una manera eficiente de manejar listas de datos que pueden crecer y reducirse dinámicamente. En este blog post, exploraremos el funcionamiento de `Vec<T>`, cómo se utiliza, su representación en memoria, sus ventajas, y algunos patrones de uso comunes.
+
+### ¿Qué es `Vec<T>`?
+
+`Vec<T>`, abreviatura de "vector", es un tipo de dato dinámico en Rust que permite almacenar una colección ordenada de elementos del mismo tipo. A diferencia de los arrays, que tienen un tamaño fijo, los vectores pueden cambiar de tamaño en tiempo de ejecución, lo que los hace extremadamente útiles para muchas aplicaciones.
+
+### Funcionamiento en Memoria
+
+Un `Vec<T>` en Rust se compone de tres partes principales:
+
+1. **Puntero a los Datos:** Apunta al bloque de memoria en el heap donde se almacenan los elementos del vector.
+2. **Capacidad:** Indica cuánta memoria ha sido reservada para el vector, lo que puede ser más que el número de elementos actualmente almacenados.
+3. **Longitud:** Representa el número de elementos actualmente almacenados en el vector.
+
+#### Gráfico: Representación en Memoria de un `Vec<T>`
+
+```plaintext
++-----------------+
+| Puntero         | --> [ 1, 2, 3, 4, 5 ]
++-----------------+
+| Capacidad: 10   |
++-----------------+
+| Longitud: 5     |
++-----------------+
+```
+
+### Creación y Uso de `Vec<T>`
+
+Crear y manipular un `Vec<T>` en Rust es sencillo y directo. Aquí hay algunos ejemplos básicos para ilustrar su uso:
+
+#### Ejemplo 1: Creación y Adición de Elementos
+
+```rust
+fn main() {
+    let mut vec = Vec::new(); // Crear un nuevo vector vacío
+    vec.push(1); // Añadir elementos al vector
+    vec.push(2);
+    vec.push(3);
+
+    println!("{:?}", vec); // Output: [1, 2, 3]
+}
+```
+
+#### Ejemplo 2: Acceso a Elementos
+
+```rust
+fn main() {
+    let vec = vec![1, 2, 3, 4, 5];
+    let primero = vec[0]; // Acceso directo a un elemento
+    let ultimo = vec[vec.len() - 1]; // Acceso al último elemento
+
+    // Acceder a elementos utilizando métodos seguros
+    if let Some(primer_numero) = numeros.get(0) {
+        println!("Primer número: {}", primer_numero);
+    }
+
+    // Modificar un elemento
+    if let Some(segundo_numero) = numeros.get_mut(1) {
+        *segundo_numero = 25;
+    }
+
+    println!("Primer elemento: {}", primero); // Output: 1
+    println!("Último elemento: {}", ultimo); // Output: 5
+}
+```
+
+#### Ejemplo 3: Iteración sobre un `Vec<T>`
+
+```rust
+fn main() {
+    let vec = vec![10, 20, 30, 40];
+    for valor in &vec {
+        println!("{}", valor);
+    }
+}
+```
+
+### Ventajas de Usar `Vec<T>`
+
+- **Flexibilidad Dinámica:** Los vectores pueden crecer y reducirse en tamaño dinámicamente, lo que los hace adecuados para situaciones donde la cantidad de datos no es conocida de antemano.
+- **Eficiencia de Memoria:** `Vec<T>` gestiona eficientemente la memoria al reservar bloques de memoria y redimensionarlos según sea necesario.
+- **Compatibilidad con Iteradores:** Los vectores se integran bien con el sistema de iteradores de Rust, permitiendo un manejo eficiente y seguro de colecciones de datos.
+
+
+### Métodos Seguros para Acceder a Elementos
+
+En Rust, acceder a elementos utilizando `vector[n]` es inseguro porque puede conducir a errores de tiempo de ejecución si el índice `n` está fuera del rango válido del `Vec`. Es preferible utilizar métodos seguros proporcionados por Rust, como `get()`, `get_mut()`, y otros, que garantizan que no se produzcan desbordamientos de índice.
+
+### Métodos Comunes de `Vec<T>`
+
+- `get(index)`: Devuelve una referencia al elemento en la posición `index`, o `None` si el índice está fuera del rango.
+- `get_mut(index)`: Devuelve una referencia mutable al elemento en la posición `index`, o `None` si el índice está fuera del rango.
+- `first()`: Devuelve una referencia al primer elemento del `Vec`, o `None` si el `Vec` está vacío.
+- `last()`: Devuelve una referencia al último elemento del `Vec`, o `None` si el `Vec` está vacío.
+- `push()`: Añade un elemento al final del vector.
+- `pop()`: Elimina y devuelve el último elemento del vector.
+- `len()`: Devuelve el número de elementos en el vector.
+- `is_empty()`: Verifica si el vector está vacío.
+- `insert()`: Inserta un elemento en una posición específica.
+- `remove()`: Elimina un elemento en una posición específica.
+
+#### Ejemplo: Métodos Comunes
+
+```rust
+fn main() {
+    let mut vec = vec![1, 2, 3];
+    vec.push(4); // Añadir un elemento
+    vec.insert(1, 5); // Insertar 5 en la posición 1
+    vec.remove(2); // Eliminar el elemento en la posición 2 (que es el 2)
+
+    println!("{:?}", vec); // Output: [1, 5, 3, 4]
+}
+```
+
+### Seguridad y Prevención de Errores
+
+El uso de métodos seguros como `get()` y `get_mut()` ayuda a prevenir errores de acceso a memoria no válida que podrían ocurrir en otros lenguajes donde acceder a elementos por índice no está tan controlado. Rust enfatiza la seguridad y la prevención de errores en tiempo de compilación, lo que es fundamental para escribir código robusto y confiable.
+
+### Diferencia con Arrays
+
+Los arrays en Rust tienen un tamaño fijo determinado en tiempo de compilación, mientras que los vectores pueden cambiar de tamaño en tiempo de ejecución. Esto hace que los vectores sean más adecuados para colecciones de datos dinámicos.
+
+### Coste Computacional de `Vec<T>`
+
+Manipular vectores implica ciertas operaciones de gestión de memoria, especialmente cuando se redimensionan. Sin embargo, Rust optimiza estas operaciones para minimizar el coste computacional, reservando bloques de memoria de manera eficiente y evitando realocaciones innecesarias.
+
+### Conclusión
+
+`Vec<T>` es una herramienta esencial en Rust para trabajar con colecciones de datos dinámicas. Su flexibilidad, eficiencia y compatibilidad con el sistema de iteradores de Rust lo hacen adecuado para una amplia gama de aplicaciones. Al comprender cómo funciona `Vec<T>` en memoria, sus ventajas y cómo utilizar sus métodos comunes, los desarrolladores pueden aprovechar al máximo las capacidades de Rust para manejar colecciones de datos de manera efectiva y segura.