feat(content): add basic range

Author: SergioRibera

content/2.basic/28.range.md

@@ -0,0 +1,135 @@
+---
+title: 'Rangos'
+description: 'Explorando los Rangos en Rust: Uso en Slices, Vectores, Iteraciones y Más'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: -50
+    y: 600
+  # width: 320
+  externalLinks:
+    - name: 'Libro Oficial - Match Binding'
+      english: false
+      link: 'https://book.rustlang-es.org/ch18-03-pattern-syntax#-bindings'
+    - name: 'Libro de Referencia Rust'
+      english: true
+      link: 'https://doc.rust-lang.org/reference/expressions/range-expr.html'
+    - name: 'Documentacion Oficial sobre los Rangos'
+      english: true
+      link: 'https://doc.rust-lang.org/std/ops/struct.Range.html'
+---
+## Rangos en Rust
+
+En Rust, los rangos son una característica poderosa y versátil que facilita la manipulación de secuencias y colecciones de datos. Los rangos pueden ser utilizados en diversas situaciones, incluyendo slices, vectores, iteraciones, validaciones, y más. Este blog post ofrece una exploración detallada de los rangos en Rust, mostrando ejemplos prácticos y destacando su utilidad en diferentes contextos.
+
+> [!IMPORTANT]
+> Los rangos son una característica mas que un Tipo.
+
+### Concepto Básico de Rangos en Rust
+
+Un rango en Rust se define utilizando la sintaxis `start..end` o `start..=end`, donde `start` es el valor inicial del rango y `end` es el valor final. La diferencia clave entre estas dos sintaxis es que `..` excluye el valor final, mientras que `..=` lo incluye.
+
+#### Ejemplo:
+
+```rust
+fn main() {
+    let rango_exclusivo = 0..5; // 0, 1, 2, 3, 4
+    let rango_inclusivo = 0..=5; // 0, 1, 2, 3, 4, 5
+
+    println!("Rango exclusivo: {:?}", rango_exclusivo);
+    println!("Rango inclusivo: {:?}", rango_inclusivo);
+}
+```
+
+### Uso de Rangos en Slices
+
+Los rangos son particularmente útiles cuando se trabaja con slices de arreglos. Permiten seleccionar una subsección de un arreglo de manera simple y eficiente.
+
+#### Ejemplo:
+
+```rust
+fn main() {
+    let arreglo = [1, 2, 3, 4, 5];
+    let slice = &arreglo[1..4]; // Selecciona los elementos en las posiciones 1, 2 y 3
+
+    println!("Slice: {:?}", slice); // Output: [2, 3, 4]
+}
+```
+
+### Rangos en Vectores
+
+De manera similar a los slices, los rangos también pueden ser utilizados para obtener subvecotres de un vector. Esto es útil cuando se necesita manipular o acceder a una parte específica del vector.
+
+#### Ejemplo:
+
+```rust
+fn main() {
+    let vector = vec![10, 20, 30, 40, 50];
+    let subvector = &vector[2..]; // Selecciona los elementos desde la posición 2 hasta el final
+
+    println!("Subvector: {:?}", subvector); // Output: [30, 40, 50]
+}
+```
+
+### Iteraciones con Rangos
+
+Los rangos son frecuentemente utilizados para iterar sobre secuencias de números. Esto es muy útil en bucles `for`, donde se necesita ejecutar un bloque de código un número específico de veces.
+
+#### Ejemplo:
+
+```rust
+fn main() {
+    for i in 0..5 {
+        println!("Número: {}", i); // Output: 0, 1, 2, 3, 4
+    }
+
+    for j in 0..=5 {
+        println!("Número: {}", j); // Output: 0, 1, 2, 3, 4, 5
+    }
+}
+```
+
+### Validaciones con Rangos
+
+Los rangos también se pueden utilizar para realizar validaciones, como verificar si un valor está dentro de un rango específico.
+
+#### Ejemplo:
+
+```rust
+fn main() {
+    let edad = 25;
+    if (18..=30).contains(&edad) {
+        println!("La edad está dentro del rango permitido.");
+    } else {
+        println!("La edad está fuera del rango permitido.");
+    }
+}
+```
+
+### Otras Situaciones Donde los Rangos Pueden Destacar
+
+1. **Generación de Números:** Los rangos pueden ser utilizados para generar secuencias de números fácilmente.
+2. **Operaciones en Colecciones:** Facilitan la selección y manipulación de subconjuntos de datos en colecciones.
+3. **Particionamiento de Datos:** Permiten dividir datos en partes más pequeñas de manera eficiente.
+
+### Gráficos: Visualizando Rangos
+
+#### Representación de Rangos en Slices
+
+```plaintext
+Arreglo: [1, 2, 3, 4, 5]
+Slice (1..4): [2, 3, 4]
+
++---+---+---+---+---+
+| 1 | 2 | 3 | 4 | 5 |
++---+---+---+---+---+
+    ^   ^   ^   ^
+    |   |   |   |
+    |---|---|---|
+```
+
+### Conclusión
+
+Los rangos en Rust son una herramienta versátil que facilita la manipulación y acceso a secuencias de datos. Desde slices y vectores hasta iteraciones y validaciones, los rangos ofrecen una manera simple y eficiente de trabajar con subconjuntos de datos. Al comprender y aprovechar las capacidades de los rangos, los desarrolladores pueden escribir código más limpio, eficiente y expresivo en Rust.