Rust Programming: Read Elements of Vectors

There are two ways to reference a value stored in a vector in Rust: via indexing or using the get method.

Indexing

To access a value in a vector using indexing, you use the square brackets ([]) operator and pass in the index of the element you want. The index of the first element in a vector is 0, so the second element has index 1, and so on.

For example, the following code accesses the third element in a vector of integers:

Rust

let v = vec![1, 2, 3, 4, 5];

let third = &v[2];

The & operator tells Rust that we want a reference to the element at index 2, not the element itself. This is because vectors are mutable, so if we didn't use the & operator, we could accidentally modify the element in the vector.

Get method

The get method is a safer way to access a value in a vector. It returns an Option<&T> value, where T is the type of the elements in the vector. If the index is valid, the get method returns a Some(&T) value, which contains a reference to the element at the specified index. If the index is out of bounds, the get method returns a None value.

For example, the following code uses the get method to access the third element in the same vector of integers as before:

Rust

let v = vec![1, 2, 3, 4, 5];

let third = v.get(2);

match third {
    Some(third) => println!("The third element is {third}"),
    None => println!("There is no third element."),
}

The match expression is used to handle the two possible cases: if the get method returned a Some(&T) value, the match expression will print the value of the element to the console. If the get method returned a None value, the match expression will print a message saying that there is no third element.

Which method should I use?

If you know that the index you are using is valid, then you can use the indexing operator. However, if you are unsure whether the index is valid, or if you want to handle the case where the index is out of bounds, then you should use the get method.

The get method is also a good choice if you are writing code that needs to be compatible with older versions of Rust. In older versions of Rust, the indexing operator would cause the program to crash if the index was out of bounds. However, the get method has always returned a None value in this case.

Example of using the get method to handle an out-of-bounds index

The following code uses the get method to handle an out-of-bounds index in a safe way:

Rust

let v = vec![1, 2, 3, 4, 5];

let index = 100;

let element = v.get(index);

if let Some(element) = element {
    println!("The element at index {index} is {element}");
} else {
    println!("There is no element at index {index}");
}

If the index variable is greater than or equal to the length of the vector, then the get method will return a None value. The if expression will then print a message saying that there is no element at the specified index. Otherwise, the get method will return a Some(&T) value, and the if expression will print the value of the element to the console.