Slices
Vistas prestadas
Slices 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.
¿Qué es una porción?
Una porción es una vista tomada en préstamo de una parte contigua de una colección. No es propietaria de los datos — apunta a datos existentes.
Las porciones se escriben con un rango entre corchetes.
fn main() {
let arr = [1, 2, 3, 4, 5];
let part = &arr[1..4];
println!("{:?}", part);
}Sintaxis de rangos de porciones
Los rangos seleccionan un índice inicial y uno final. El final es exclusivo.
&v[1..4]— índices 1, 2 y 3.&v[..3]— desde el principio hasta 3.&v[2..]— desde 2 hasta el final.
fn main() {
let v = vec![10, 20, 30, 40];
println!("{:?}", &v[..2]);
println!("{:?}", &v[2..]);
}Porciones de cadenas
Una porción de cadena &str es una vista de una parte de una String. Los rangos de índices se expresan por posición de byte.
fn main() {
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
println!("{} {}", hello, world);
}Porciones de colecciones completas
Use &v[..] para crear una porción de toda la colección. Así es como un Vec se toma prestado como una porción.
fn main() {
let v = vec![1, 2, 3];
let whole = &v[..];
println!("{:?}", whole);
}Porciones como parámetros
Las funciones que reciben &[T] aceptan tanto matrices como vectores. Esto las hace flexibles.
fn sum(items: &[i32]) -> i32 {
let mut total = 0;
for x in items {
total += x;
}
total
}
fn main() {
let v = vec![1, 2, 3];
let a = [4, 5, 6];
println!("{} {}", sum(&v), sum(&a));
}Las porciones toman prestado, no son propietarias
Como una porción toma datos prestados, la colección original debe seguir activa mientras se use la porción. El compilador lo garantiza.
fn main() {
let v = vec![100, 200, 300];
let s = &v[0..2];
println!("slice {:?}, original {:?}", s, v);
}Longitud de una porción
Al igual que otras colecciones, las porciones tienen un método len() que indica el número de elementos que abarcan.
fn main() {
let v = vec![5, 6, 7, 8, 9];
let middle = &v[1..4];
println!("length {}", middle.len());
}first y last
Las porciones proporcionan first() y last(), que devuelven Option para gestionar las porciones vacías de forma segura.
fn main() {
let data = [10, 20, 30];
let s = &data[..];
println!("{:?} {:?}", s.first(), s.last());
}Iterar una porción
Puede iterar una porción igual que cualquier colección.
fn main() {
let v = vec![1, 2, 3, 4];
for x in &v[1..3] {
println!("{}", x);
}
}Una función para obtener la primera palabra
Un caso de uso habitual de las porciones: devolver una porción de texto existente, como la primera palabra de una oración.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[0..i];
}
}
s
}
fn main() {
println!("{}", first_word("hello there"));
}Por qué las porciones son seguras
Las porciones evitan copiar datos y, al mismo tiempo, impiden las referencias colgantes. El comprobador de préstamos garantiza que los datos subyacentes duren más que la porción.
fn main() {
let words = vec!["a", "b", "c", "d"];
let pair = &words[1..3];
println!("{:?}", pair);
}Comprobación rápida
Recuerde qué representa una porción.
Repaso
Porciones en Rust:
- Una vista tomada en préstamo:
&v[start..end], con el final exclusivo. &stres una porción de cadena;&[T]es una porción de matriz o vector.- Los parámetros de tipo porción aceptan tanto matrices como vectores.
- El comprobador de préstamos mantiene la seguridad de las porciones.
fn average(nums: &[i32]) -> i32 {
nums.iter().sum::<i32>() / nums.len() as i32
}
fn main() {
let v = vec![4, 8, 12];
println!("{}", average(&v[..]));
}Preguntas frecuentes
¿La lección «Slices» es gratis?
Sí — el texto completo de «Slices» 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 «Slices»?
Vistas prestadas 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 «Slices»?
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.