ZetCode

Rust array

last modified October 11, 2022

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.

main.rs
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.

main.rs
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].

main.rs
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.

main.rs
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.

main.rs
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.

main.rs
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.

main.rs
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.

main.rs
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.