Introducción
En Rust, los slices son una vista de una secuencia de elementos en una colección, como un array o un vector. Los slices permiten acceder a una porción de una colección sin necesidad de copiar los datos. Son útiles cuando necesitas trabajar con subpartes de una colección de manera eficiente.
Conceptos Clave
- Slice: Una referencia a una porción continua de una colección.
- Inmutabilidad: Los slices son inmutables por defecto, pero también pueden ser mutables.
- Rango: Los slices se definen usando rangos, que especifican el inicio y el final de la porción.
Sintaxis de Slices
Creación de un Slice
Para crear un slice, necesitas una colección y un rango. Aquí hay un ejemplo básico:
fn main() {
let arr = [1, 2, 3, 4, 5];
let slice = &arr[1..4]; // Slice de los elementos 2, 3 y 4
println!("{:?}", slice);
}Explicación del Código
- Declaración del Array:
let arr = [1, 2, 3, 4, 5];- Aquí,
arres un array de 5 elementos.
- Aquí,
- Creación del Slice:
let slice = &arr[1..4];&arr[1..4]crea un slice que incluye los elementos desde el índice 1 hasta el índice 3 (el índice final es exclusivo).
- Impresión del Slice:
println!("{:?}", slice);{:?}se usa para imprimir el slice en formato de depuración.
Slices Mutables
También puedes crear slices mutables si necesitas modificar la colección subyacente:
fn main() {
let mut arr = [1, 2, 3, 4, 5];
let slice = &mut arr[1..4]; // Slice mutable de los elementos 2, 3 y 4
slice[0] = 10; // Modifica el primer elemento del slice
println!("{:?}", slice);
println!("{:?}", arr);
}Explicación del Código
- Declaración del Array Mutable:
let mut arr = [1, 2, 3, 4, 5];arres un array mutable.
- Creación del Slice Mutable:
let slice = &mut arr[1..4];&mut arr[1..4]crea un slice mutable.
- Modificación del Slice:
slice[0] = 10;- Cambia el primer elemento del slice a 10.
- Impresión del Slice y del Array:
println!("{:?}", slice);yprintln!("{:?}", arr);- Muestra el slice modificado y el array original para ver los cambios.
Ejercicios Prácticos
Ejercicio 1: Crear un Slice
Instrucciones: Dado un array de enteros, crea un slice que contenga los elementos del segundo al cuarto.
Solución:
fn main() {
let arr = [10, 20, 30, 40, 50];
let slice = &arr[1..4];
println!("{:?}", slice); // Debería imprimir [20, 30, 40]
}Ejercicio 2: Modificar un Slice Mutable
Instrucciones: Dado un array mutable de enteros, crea un slice mutable y modifica el segundo elemento del slice.
fn main() {
let mut arr = [5, 10, 15, 20, 25];
// Tu código aquí
println!("{:?}", slice);
println!("{:?}", arr);
}Solución:
fn main() {
let mut arr = [5, 10, 15, 20, 25];
let slice = &mut arr[1..4];
slice[1] = 100;
println!("{:?}", slice); // Debería imprimir [10, 100, 20]
println!("{:?}", arr); // Debería imprimir [5, 10, 100, 20, 25]
}Errores Comunes y Consejos
- Índices Fuera de Rango: Asegúrate de que los índices del slice estén dentro del rango de la colección original. De lo contrario, el programa se bloqueará.
- Inmutabilidad vs. Mutabilidad: No intentes modificar un slice inmutable. Usa
&mutpara crear un slice mutable si necesitas cambiar los datos. - Rangos Exclusivos: Recuerda que el índice final en un rango es exclusivo. Por ejemplo,
&arr[1..4]incluye los elementos en los índices 1, 2 y 3, pero no el 4.
Conclusión
Los slices son una herramienta poderosa en Rust para trabajar con subpartes de colecciones de manera eficiente y segura. Entender cómo crear y usar slices, tanto inmutables como mutables, es fundamental para escribir código Rust efectivo y seguro. En el próximo módulo, exploraremos cómo definir y usar structs para organizar datos de manera más compleja.
Curso de Programación en Rust
Módulo 1: Introducción a Rust
- ¿Qué es Rust?
- Configuración del Entorno de Rust
- Programa "Hola, Mundo!"
- Sintaxis y Estructura Básica