Day 12b: Slicing, Borrowing, and Common Use Cases for Arrays in Rust

In the previous post, we learned about the basics of arrays in Rust. Today, we’re taking it a step further by looking into slicing and borrowing arrays. These concepts will help you work more efficiently with parts of an array and are critical when dealing with functions that need to access or manipulate array elements without taking ownership.

1. Slicing Arrays in Rust

A slice is a reference to a contiguous sequence of elements within an array. Slices are useful when you want to work with a portion of an array without copying data or taking ownership of the entire array.

a. Creating a Slice

You can create a slice by specifying a range of indices in the array.

Example:

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    let slice = &numbers[1..4]; // Slice of elements from index 1 to 3

    println!("Slice: {:?}", slice);
}

In this example, &numbers[1..4] creates a slice containing the elements [20, 30, 40]. The range is inclusive of the start index (1) and exclusive of the end index (4).

b. Slices as Function Parameters

Slices are often used as function parameters to avoid copying an entire array, allowing the function to borrow only part of the data.

Example:

fn main() {
    let data = [1, 2, 3, 4, 5];
    print_slice(&data[1..4]);
}

fn print_slice(slice: &[i32]) {
    println!("Slice: {:?}", slice);
}

Here, the function print_slice takes a slice as its argument, which allows it to access a portion of the array without taking ownership.

2. Borrowing Arrays

Borrowing allows you to access an array without transferring ownership, which is important for maintaining control over data and avoiding unnecessary copies. In Rust, borrowing is achieved through references.

a. Immutable and Mutable Borrowing

You can borrow an array as an immutable reference (&) or a mutable reference (&mut). Immutable references allow read-only access, while mutable references allow you to modify the array.

Immutable Borrowing Example:

fn main() {
    let data = [10, 20, 30];
    let borrow = &data;

    println!("Borrowed array: {:?}", borrow);
}

Mutable Borrowing Example:

fn main() {
    let mut data = [1, 2, 3];
    let borrow = &mut data;

    borrow[1] = 20; // Modify the array through the mutable reference
    println!("Modified array: {:?}", data);
}

In the mutable borrowing example, &mut data allows us to modify the original array through the reference.

3. Common Use Cases for Arrays in Rust

Arrays are suitable for a variety of common use cases where a fixed number of elements is needed.

a. Storing Fixed Sets of Data

Arrays are perfect for storing a fixed set of related data, such as RGB color values or temperature readings for a given day.

Example:

fn main() {
    let rgb: [u8; 3] = [255, 0, 127]; // RGB color representation
    println!("RGB values: {:?}", rgb);
}

b. Working with Static Data

If you know the data won't change or grow in size, arrays are an ideal choice for storing static data.

Example:

fn main() {
    let weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"];
    println!("Weekdays: {:?}", weekdays);
}

The weekdays array is a fixed list of strings that represent the days of the workweek, and its size will not change.

Conclusion

Slicing and borrowing arrays allow you to work with parts of an array efficiently and safely. Slices are especially useful for passing portions of an array to functions without taking ownership. Borrowing helps you avoid copying data unnecessarily, making your Rust code more memory efficient and performant.

In the next post, Day 12c, we’ll explore advanced operations like iteration, indexing, and mutability with arrays in Rust.