Learn Rust Coding · Lección

Strings y &str

Texto propio y prestado

Strings y &str es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Dos tipos de cadenas

Rust tiene dos tipos principales para representar texto:

String — una cadena propia y ampliable.
&str — una porción de cadena tomada en préstamo, es decir, una vista del texto.

fn main() {
    let owned: String = String::from("hello");
    let borrowed: &str = "world";
    println!("{} {}", owned, borrowed);
}

Los literales de cadena son &str

Al escribir texto entre comillas dobles, obtiene un &str. Es fijo y se almacena en el binario del programa.

fn main() {
    let greeting = "Hi there"; // type is &str
    println!("{}", greeting);
}

Crear una String

Construya una String propia con String::from o con el método .to_string().

fn main() {
    let a = String::from("abc");
    let b = "xyz".to_string();
    println!("{} {}", a, b);
}

Ampliar una String

Como String es propia y ampliable, puede añadirle texto con push_str y push.

fn main() {
    let mut s = String::from("Hello");
    s.push_str(", ");
    s.push_str("Rust");
    s.push('!');
    println!("{}", s);
}

Concatenación

Una cadenas mediante el operador + o la macro format!. format! no consume sus entradas.

fn main() {
    let first = String::from("Hello");
    let second = String::from("World");
    let joined = format!("{} {}", first, second);
    println!("{}", joined);
}

Tomar una String como &str

Puede tomar automáticamente una String como un &str. Esto permite que las funciones acepten cualquiera de los dos tipos.

fn print_text(text: &str) {
    println!("text: {}", text);
}

fn main() {
    let owned = String::from("owned");
    print_text(&owned);
    print_text("literal");
}

Por qué se prefieren parámetros &str

Normalmente, las funciones reciben &str en lugar de String. Es más flexible: quien las llama puede pasar cadenas propias, literales o porciones.

fn shout(s: &str) -> String {
    s.to_uppercase()
}

fn main() {
    println!("{}", shout("quiet"));
}

Longitud en bytes

El método len() devuelve la longitud en bytes, no en caracteres. El texto ASCII usa un byte por carácter.

fn main() {
    let s = "hello";
    println!("{} bytes", s.len());
}

Comprobar el contenido

Entre los métodos de lectura útiles se incluyen contains, starts_with y is_empty.

fn main() {
    let s = "hello world";
    println!("{}", s.contains("world"));
    println!("{}", s.starts_with("hello"));
}

Diferencia de propiedad

Una String es propietaria de sus datos en el montón y es responsable de liberarlos. Un &str solo toma prestados datos existentes y no es propietario de nada.

fn main() {
    let owned = String::from("data");
    let view: &str = &owned[0..2];
    println!("owned {} view {}", owned, view);
}

Convertir entre ambos tipos

Convierta de un tipo al otro:

De &str a String: .to_string() o String::from.
De String a &str: &s o s.as_str().

fn main() {
    let s = String::from("convert");
    let slice: &str = s.as_str();
    let back: String = slice.to_string();
    println!("{} {}", slice, back);
}

Comprobación rápida

Recuerde la diferencia entre los dos tipos de texto.

Repaso

Cadenas en Rust:

String — propia, ampliable y asignada en el montón.
&str — porción o vista tomada en préstamo; es el tipo de los literales.
Créela con String::from o to_string(); amplíela con push_str.
Prefiera &str para los parámetros de las funciones.

fn main() {
    let mut msg = String::from("Rust");
    msg.push_str(" rocks");
    let view: &str = &msg;
    println!("{} ({} bytes)", view, view.len());
}

Preguntas frecuentes

¿La lección «Strings y &str» es gratis?

Sí — el texto completo de «Strings y &str» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Strings y &str»?

Texto propio y prestado Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Strings y &str»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding