feat(content): add str type content

content/2.basic/20.str.md

@@ -0,0 +1,139 @@
+---
+title: 'str'
+description: 'El Tipo de Dato `str` en Rust'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: -50
+    y: 400
+  width: 280
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: ''
+    - name: 'Ferrous System'
+      english: true
+      link: ''
+    - name: 'Ferrocene Language Specification'
+      english: true
+      link: 'https://public-docs.ferrocene.dev/main/specification/types-and-traits.html#str-type'
+---
+## El Tipo de Dato `str` en Rust
+
+En Rust, el tipo de dato `str` es fundamental para trabajar con cadenas de caracteres. A diferencia de muchos otros lenguajes, Rust trata las cadenas de forma única, lo que puede parecer complicado al principio, pero proporciona una gran eficiencia y seguridad. Este artículo detalla las características del tipo `str`, sus usos, métodos comunes y cómo manejarlo en memoria.
+
+### Características del Tipo `str`
+
+#### 1. Inmutabilidad
+- **Descripción:** En Rust, las cadenas de tipo `str` son inmutables. Esto significa que una vez creada, una cadena `str` no puede ser modificada. 
+- **Ventaja:** La inmutabilidad garantiza la seguridad y coherencia de los datos a lo largo de la ejecución del programa.
+
+#### 2. Almacenamiento en Memoria
+- **Descripción:** El tipo `str` en Rust se almacena como una secuencia contigua de bytes en memoria.
+- **Codificación:** Las cadenas `str` están codificadas en UTF-8, lo que permite representar una amplia variedad de caracteres Unicode.
+- **Referencia:** En general, las cadenas `str` se manipulan mediante referencias (`&str`) para evitar copias innecesarias y mejorar el rendimiento.
+
+#### 3. Tamaño Dinámico
+- **Descripción:** El tamaño de un `str` está determinado en tiempo de ejecución, lo que lo convierte en un tipo de tamaño dinámico (DST, por sus siglas en inglés).
+- **Manipulación:** Para trabajar con `str`, generalmente utilizamos una referencia (`&str`) que incluye un puntero al inicio de la cadena y una longitud que indica su tamaño.
+
+### Usos del Tipo `str`
+
+- **Texto Inmutable:** Se utiliza para representar texto que no necesita ser modificado, como mensajes de error, etiquetas y textos constantes.
+- **Comparaciones y Búsquedas:** Es útil para realizar comparaciones y búsquedas dentro de cadenas de texto, asegurando eficiencia y seguridad.
+- **Datos Multilingües:** Gracias a su codificación en UTF-8, `str` es ideal para manejar texto en múltiples idiomas, incluidos caracteres especiales y emojis.
+
+### Métodos Más Comunes
+
+Aunque el tipo `str` no tiene métodos asociados directamente, Rust proporciona una serie de funciones y métodos a través del tipo de referencia `&str` para manipular y trabajar con cadenas de manera efectiva. Aquí algunos de los métodos más utilizados:
+
+#### 1. `len()`
+- **Descripción:** Devuelve la longitud de la cadena en bytes.
+- **Ejemplo:**
+
+```rust
+let s = "Hola, mundo!";
+println!("La longitud de s es: {}", s.len());
+```
+
+#### 2. `is_empty()`
+- **Descripción:** Verifica si la cadena está vacía.
+- **Ejemplo:**
+
+```rust
+let s = "";
+println!("¿Está s vacía?: {}", s.is_empty());
+```
+
+#### 3. `contains()`
+- **Descripción:** Comprueba si una subcadena está presente en la cadena.
+- **Ejemplo:**
+
+```rust
+let s = "Hola, mundo!";
+println!("¿Contiene 'mundo'?: {}", s.contains("mundo"));
+```
+
+#### 4. `split()`
+- **Descripción:** Divide la cadena en subcadenas basadas en un delimitador.
+- **Ejemplo:**
+
+```rust
+let s = "Hola, mundo!";
+for part in s.split(", ") {
+    println!("{}", part);
+}
+```
+
+#### 5. `to_uppercase()`
+- **Descripción:** Convierte la cadena a mayúsculas.
+- **Ejemplo:**
+
+```rust
+let s = "Hola, mundo!";
+println!("En mayúsculas: {}", s.to_uppercase());
+```
+
+### Ejemplo de Uso en Rust
+
+```rust
+fn main() {
+    let saludo: &str = "Hola, mundo!";
+
+    // Métodos comunes
+    println!("Longitud: {}", saludo.len());
+    println!("¿Está vacío?: {}", saludo.is_empty());
+    println!("¿Contiene 'mundo'?: {}", saludo.contains("mundo"));
+
+    // División de la cadena
+    for parte in saludo.split(", ") {
+        println!("Parte: {}", parte);
+    }
+
+    // Conversión a mayúsculas
+    println!("En mayúsculas: {}", saludo.to_uppercase());
+}
+```
+
+### Espacio en Memoria
+
+En Rust, el tipo `str` es almacenado en memoria de manera contigua y codificado en UTF-8, permitiendo una representación eficiente y compacta de texto Unicode. A continuación, se ilustra cómo se gestiona en memoria:
+
+**Gráfico: Almacenamiento de una Cadena `str` en Memoria**
+
+```plaintext
++---+---+---+---+---+---+---+---+---+---+---+---+
+| H | o | l | a | , |   | m | u | n | d | o | ! |
++---+---+---+---+---+---+---+---+---+---+---+---+
+0   1   2   3   4   5   6   7   8   9   10  11
+
+Dirección de memoria contigua:
+  Puntero al inicio -> 0
+  Longitud en bytes -> 12
+```
+
+### Conclusión
+
+El tipo `str` en Rust es una poderosa herramienta para trabajar con cadenas de texto de manera segura y eficiente. Su inmutabilidad, codificación en UTF-8 y manejo dinámico de tamaños lo hacen ideal para aplicaciones que requieren un manejo robusto de texto. Comprender cómo utilizar `str` y sus métodos asociados permite a los desarrolladores escribir código más seguro y eficiente en Rust.