El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Cadenas

Siguiente ►
►

En Rust, las cadenas de texto son un tipo de dato fundamental que se utiliza para almacenar y manipular texto. Rust proporciona dos tipos principales de cadenas: String y &str. En esta sección, exploraremos ambos tipos, sus diferencias, y cómo trabajar con ellos de manera efectiva.

Tipos de Cadenas

String

  • Descripción: String es un tipo de dato que representa una cadena de texto mutable y con capacidad de crecimiento. Se almacena en el heap, lo que permite que su tamaño cambie en tiempo de ejecución.
  • Uso Común: Se utiliza cuando necesitas una cadena que pueda cambiar de tamaño o cuando necesitas poseer la cadena.

&str

  • Descripción: &str es una referencia a una cadena de texto inmutable. Se almacena en el stack y su tamaño es fijo en tiempo de compilación.
  • Uso Común: Se utiliza para cadenas de texto que no necesitan cambiar y cuando no necesitas poseer la cadena.

Creación de Cadenas

Creación de un String

fn main() {
    let mut s = String::from("Hola");
    s.push_str(", mundo!");
    println!("{}", s); // Salida: Hola, mundo!
}
  • Explicación:
    • String::from("Hola") crea una nueva cadena String a partir de un literal de cadena.
    • push_str agrega una cadena de texto al final de s.

Creación de un &str

fn main() {
    let s = "Hola, mundo!";
    println!("{}", s); // Salida: Hola, mundo!
}
  • Explicación:
    • "Hola, mundo!" es un literal de cadena que se almacena como &str.

Conversión entre String y &str

De &str a String

fn main() {
    let s = "Hola, mundo!";
    let string_s = s.to_string();
    println!("{}", string_s); // Salida: Hola, mundo!
}
  • Explicación:
    • to_string convierte un &str en un String.

De String a &str

fn main() {
    let s = String::from("Hola, mundo!");
    let str_s: &str = &s;
    println!("{}", str_s); // Salida: Hola, mundo!
}
  • Explicación:
    • &s crea una referencia a la cadena String, convirtiéndola en &str.

Métodos Comunes de String

Concatenación

fn main() {
    let s1 = String::from("Hola");
    let s2 = String::from(", mundo!");
    let s3 = s1 + &s2; // s1 se mueve aquí y ya no es válido
    println!("{}", s3); // Salida: Hola, mundo!
}
  • Explicación:
    • El operador + se utiliza para concatenar dos cadenas. Nota que s1 se mueve y ya no es válido después de la concatenación.

Formateo

fn main() {
    let s1 = String::from("Hola");
    let s2 = String::from(", mundo!");
    let s3 = format!("{}{}", s1, s2);
    println!("{}", s3); // Salida: Hola, mundo!
}
  • Explicación:
    • format! se utiliza para concatenar cadenas sin mover las variables originales.

Ejercicios Prácticos

Ejercicio 1: Concatenación de Cadenas

Escribe un programa que concatene tres cadenas de texto y las imprima.

fn main() {
    let part1 = String::from("Rust");
    let part2 = String::from(" es");
    let part3 = String::from(" genial!");
    let sentence = part1 + &part2 + &part3;
    println!("{}", sentence); // Salida esperada: Rust es genial!
}

Ejercicio 2: Conversión de &str a String

Escribe un programa que convierta un &str a String y luego lo modifique.

fn main() {
    let s = "Hola, mundo!";
    let mut string_s = s.to_string();
    string_s.push_str(" ¿Cómo estás?");
    println!("{}", string_s); // Salida esperada: Hola, mundo! ¿Cómo estás?
}

Ejercicio 3: Uso de format!

Escribe un programa que use format! para combinar varias cadenas y las imprima.

fn main() {
    let s1 = String::from("Aprender");
    let s2 = String::from(" Rust");
    let s3 = String::from(" es divertido!");
    let sentence = format!("{}{}{}", s1, s2, s3);
    println!("{}", sentence); // Salida esperada: Aprender Rust es divertido!
}

Resumen

En esta sección, hemos aprendido sobre los dos tipos principales de cadenas en Rust: String y &str. Hemos visto cómo crear, convertir y manipular estos tipos de cadenas. También hemos explorado algunos métodos comunes y prácticos para trabajar con cadenas en Rust. Con estos conocimientos, estás listo para manejar texto de manera efectiva en tus programas de Rust.

En el próximo módulo, exploraremos cómo trabajar con HashMaps para almacenar y manipular datos clave-valor.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados