Rust Arrays

An array is a fixed-size list of values, all of the same type. “Fixed-size” is the key word — once you create an array, it can’t grow or shrink. If you need something that resizes, that’s what a vector is for.

Creating an array

fn main() {
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    println!("{:?}", numbers);
}

The type [i32; 5] reads as “an array of 5 i32 values.” That length is part of the type — a [i32; 5] and a [i32; 3] are considered different types.

▶ Try it Yourself

You can also let Rust infer the type and just write the values:

let numbers = [1, 2, 3, 4, 5];

Same value, repeated

To fill an array with the same value N times, use this shorthand:

fn main() {
    let zeros = [0; 5]; // [0, 0, 0, 0, 0]
    println!("{:?}", zeros);
}

▶ Try it Yourself

Accessing elements

Arrays are indexed starting at 0, using square brackets:

fn main() {
    let fruits = ["apple", "banana", "cherry"];

    println!("{}", fruits[0]); // apple
    println!("{}", fruits[2]); // cherry
    println!("Length: {}", fruits.len());
}

▶ Try it Yourself

Out-of-bounds access is caught

Try to access an index that doesn’t exist, and Rust stops your program instead of quietly reading garbage memory:

fn get_fruit(fruits: &[&str; 3], index: usize) -> &str {
    fruits[index]
}

fn main() {
    let fruits = ["apple", "banana", "cherry"];
    println!("{}", get_fruit(&fruits, 10)); // panics at runtime
}

thread 'main' panicked at src/main.rs:2:5:
index out of bounds: the len is 3 but the index is 10

Note

This example reads the index through a function parameter on purpose. If you write fruits[10] directly with a literal index, the compiler can often work out at compile time that it’s always out of bounds and refuses to build at all — which is even safer, but doesn’t demonstrate a runtime panic. Passing the index in through a variable the compiler can’t fully predict is what makes this an honest runtime example.

In a language like C, reading past the end of an array is undefined behavior — sometimes it crashes, sometimes it silently reads whatever happens to be in memory next (a real source of security bugs). Rust checks the bounds every time and panics cleanly instead. Not free of cost, but far safer.

Looping over an array

fn main() {
    let numbers = [10, 20, 30];

    for n in numbers {
        println!("{n}");
    }
}

▶ Try it Yourself

Arrays vs vectors

Use an array when the size is fixed and known upfront (like the seven days of the week). Use a Vec when you need to add or remove items — which, in practice, is most of the time. Arrays are less common in everyday Rust code than vectors are.

Recap

• Arrays have a fixed length that’s part of their type: [i32; 5].
• Access elements with array[index], starting at 0.
• Out-of-bounds access panics at runtime instead of causing undefined behavior.
• If you need to resize, use a Vec instead.

Quick check

Quick check

1. What's true about a Rust array's length?

It can grow with .push()It's determined at runtime onlyIt's part of the array's type, e.g. [i32; 5]

2. What happens when you access an array index that's out of bounds at runtime?

The program panicsRust returns a default value like 0It reads whatever memory happens to be there, like in C

3. What does let zeros = [0; 5]; create?

An array of 5 different random numbersAn array of five zerosA single value, 0, repeated 5 times when printed

Score: 0 / 3

Read more

• The Array Type — The Rust Book