Rust array
last modified October 18, 2023
In this article we show how to work with arrays in Rust.
An array is a fixed collection of elements of the same type. Each element can be referred to by an index. The indexes are zero-based. (The index of the first element is zero.)
Arrays are created with a pair of [] brackets.
The array type is [T; length].
Rust init array
In the first example, we initialize arrays in Rust.
fn main() {
let vals: [i32; 5] = [1, 2, 3, 4, 5];
println!("{:?}", vals);
let words = ["soup", "falcon", "water", "tree"];
println!("{:?}", words);
let vals2: [i32; 10] = [3; 10];
println!("{:?}", vals2);
let vals3 = [0; 5];
println!("{:?}", vals3);
}
In the example, we define four arrays.
let vals: [i32; 5] = [1, 2, 3, 4, 5];
We define an array of five i32 integers. We explicitly specify
the array type with [i32; 5]. On the right side of the assignment,
we specify the array elements insice a pair of [] brackets. The
elements are separated with a comma character.
println!("{:?}", vals);
We print the contents of the array to the console.
let words = ["soup", "falcon", "water", "tree"];
We define an array of strings. The type declaration is omitted; Rust will automatically infer the type from the right side of the assignment.
let vals2: [i32; 10] = [3; 10];
Here we define an array of ten integers of the same value; in our case, all spots in the array are filled with number 3.
let vals3 = [0; 5];
println!("{:?}", vals3);
The second syntax also allows to omit the type declaration.
λ cargo run -q [1, 2, 3, 4, 5] ["soup", "falcon", "water", "tree"] [3, 3, 3, 3, 3, 3, 3, 3, 3, 3] [0, 0, 0, 0, 0]
Rust array length
The length of an array can be determined with len function.
fn main() {
let vals = [1, 2, 3, 4, 5];
let n = vals.len();
println!("The length of the array is {n}");
let words = ["soup", "falcon", "water", "tree"];
let n2 = words.len();
println!("The length of the array is {n2}");
}
In the example, we determine the size of two arrays.
λ cargo run -q The length of the array is 5 The length of the array is 4
Rust access array elements
Arrays elements are accessed with the array access notation [i].
fn main() {
let vals = [1, 2, 3, 4, 5];
let n = vals.len();
println!("The first element is: {}", vals[0]);
println!("The second element is: {}", vals[1]);
println!("The last element is: {}", vals[n-1]);
println!("-----------------------");
println!("The first element is: {}", vals.first().unwrap());
println!("The last element is: {}", vals.last().unwrap());
}
To access an array element, we specify the array name followed by a pair of
[] brackets in which we put the index of the element.
println!("The first element is: {}", vals[0]);
We print the first element.
println!("The last element is: {}", vals[n-1]);
The last element is returned by calculating the lenght of the array and subtracting 1.
println!("The first element is: {}", vals.first().unwrap());
println!("The last element is: {}", vals.last().unwrap());
There are also convenient first and last functions.
λ cargo run -q The first element is: 1 The second element is: 2 The last element is: 5 ----------------------- The first element is: 1 The last element is: 5
Rust array get
The get function returns a reference to an element or subslice.
fn main() {
let vals = [1, 2, 3, 4, 5];
let first = vals.get(0).unwrap();
let first_two = vals.get(0..2).unwrap();
println!("The first element is: {}", first);
println!("The first two elemetns: {:?}", first_two);
}
In the example, we use the get function to retrieve the first and
then the first two elements.
let first_two = vals.get(0..2).unwrap();
We get a subslice if we pass a range to the get.
λ cargo run -q The first element is: 1 The first two elemetns: [1, 2]
Rust array modify elements
In the next example, we modify elements of an array.
fn main() {
let mut vals: [i32; 5] = [0; 5];
println!("{:?}", vals);
vals[0] = 5;
vals[1] = 6;
vals[2] = 7;
vals[3] = 8;
vals[4] = 9;
println!("{:?}", vals);
}
We define a mutable array of integers. Later, we modify the elements to new values.
let mut vals: [i32; 5] = [0; 5];
A mutable array of five zeros is defined.
vals[0] = 5; vals[1] = 6; vals[2] = 7; vals[3] = 8; vals[4] = 9;
The elements are modified through the array index notation. There are five elements in the array; the first has index 0, the fifth 4.
λ cargo run -q [0, 0, 0, 0, 0] [5, 6, 7, 8, 9]
Rust array loop
With a for loop, we can easily loop over the elements of the array.
fn main() {
let vals = [1, 2, 3, 4, 5];
for e in vals {
println!("{e}");
}
let n = vals.len();
for i in 0..n {
println!("{} -> {}", i, vals[i]);
}
for e in vals.iter().enumerate() {
let (i, x) = e;
println!("vals[{i}] = {x}");
}
}
The program goes through the elements of the array three times.
for e in vals {
println!("{e}");
}
In the first case, we simply go over the elements one by one. In each for cycle,
the e contains the current element.
let n = vals.len();
for i in 0..n {
println!("{} -> {}", i, vals[i]);
}
In the second case, we loop over the array by creating a range of array index values.
for e in vals.iter().enumerate() {
let (i, x) = e;
println!("vals[{i}] = {x}");
}
The enumerate function creates an iterator which gives the current
index and the current value.
λ cargo run -q 1 2 3 4 5 0 -> 1 1 -> 2 2 -> 3 3 -> 4 4 -> 5 vals[0] = 1 vals[1] = 2 vals[2] = 3 vals[3] = 4 vals[4] = 5
Rust array filter
We can filter arrays with the filter function.
fn main() {
let vals = [1, -2, -3, 4, 5];
let res: Vec<_> = vals.iter().filter(|&e| *e > 0).collect();
println!("{:?}", res);
}
In the program, we define an array of integers. We filter out all positive values.
λ cargo run -q [1, 4, 5]
Rust array sort
In the next example, we sort arrays. The sorting is stable and desctructive.
fn main() {
let mut vals = [5, -2, -3, 4, 1, 2];
vals.sort();
println!("{:?}", vals);
let mut words = ["war", "atom", "be", "it", "cup", "forest", "book"];
words.sort_by(|e1, e2| e1.len().cmp(&e2.len()));
println!("{:?}", words);
}
The program sorts an array of integers and an array of strings.
vals.sort();
With sort, we sort the integers in-place.
words.sort_by(|e1, e2| e1.len().cmp(&e2.len()));
In the second case, we sort the strings by their length.
λ cargo run -q [-3, -2, 1, 2, 4, 5] ["be", "it", "war", "cup", "atom", "book", "forest"]
In this article we have worked with arrays in Rust.