How to Get a Slice of a Vec<T> in Rust

By the end of this page, you will understand how to get a slice from a Vec<T> in Rust, how range syntax works, the difference between borrowing a slice and creating a new vector, and how to avoid common indexing mistakes.

In Rust, a Vec<T> is a growable heap-allocated collection, while a slice (&[T]) is a borrowed view into a sequence of elements.

When you want part of a vector, Rust usually does not create a new vector automatically. Instead, it gives you a slice that points to a section of the existing vector.

For example:

let a = vec![1, 2, 3, 4];
let suba = &a[0..2];

Here, suba is a slice of type &[i32], and it refers to the first two elements: [1, 2].

This matters because:

• It avoids unnecessary copying.
• It is efficient.
• It fits Rust’s ownership and borrowing model.
• It allows functions to work with both arrays and vectors using the same slice type.

If you actually need an independent collection, you can convert the slice into a new Vec<T>:

let a = vec![, , , ];
  = a[..].();

Think of a Vec<T> as a full loaf of bread, and a slice as a few pieces cut from it.

• The vector owns the whole loaf.
• A slice is just a view of part of that loaf.
• Taking a slice does not bake a new loaf.
• If you want a separate loaf, you must copy the pieces into a new vector.

So &a[0..2] means: “Let me look at elements starting at index 0 and stopping before index 2.”

Rust uses range syntax with indexing to create slices.

Basic syntax

let slice = &vec[start..end];

• start is included
• end is excluded

So 0..2 means indices 0 and 1.

Example: get the first two elements

let a = vec![1, 2, 3, 4];
let suba = &a[0..2];

println!("{:?}", suba); // [1, 2]

suba has type:

&[i32]

Example: from a starting index to the end

Consider this example:

let a = vec![10, 20, 30, 40];
let part = &a[1..3];
println!("{:?}", part);

Step by step:

1. let a = vec![10, 20, 30, 40];

   • A vector is created with four elements.
   • Index positions are:
     • 0 -> 10
     • 1 -> 20
     • 2 -> 30
     • 3 -> 40

2. let part = &a[1..3];

   • Rust reads the range 1..3.
   • Start at index 1.
   • Stop before index 3.
   • That includes elements at indices 1 and .

Slicing vectors is useful in many real programs.

Processing part of a dataset

let readings = vec![12, 15, 18, 20, 22, 25];
let recent = &readings[3..];

You might only want the most recent sensor readings.

Pagination or batching

let users = vec!["a", "b", "c", "d", "e"];
let page = &users[0..2];

This can represent one page of results or one batch of records.

Parsing tokens

let tokens = vec!["let", "x", "=", "5", ";"];
let  = &tokens[..];

In real Rust codebases, developers often prefer slices over Vec<T> in APIs when ownership is not needed.

Accept slices in functions

fn average(values: &[f64]) -> f64 {
    let total: f64 = values.iter().sum();
    total / values.len() as f64
}

This lets callers pass:

• a full vector: &v
• part of a vector: &v[1..4]
• an array slice: &arr[..]

Validation before slicing

Direct indexing can panic if the range is invalid. In production code, developers often validate lengths first.

fn first_two(values: &[i32]) -> Option<&[i32]> {
    if values.len() >= 2 {
        Some(&values[..])
    }  {
        
    }
}

1. Expecting a new Vec<T> instead of a slice

This code does not create a new vector:

let a = vec![1, 2, 3, 4];
let suba = &a[0..2];

suba is a slice, not a Vec<i32>.

If you need a new vector:

let suba = a[0..2].to_vec();

2. Forgetting that the end index is excluded

Broken expectation:

let a = vec![1, 2, 3, 4];
let suba = &a[0..2]; // contains [1, 2], not [1, 2, 3]

Quick reference

Get a slice from a vector

let v = vec![1, 2, 3, 4];
let s = &v[0..2];

Result:

[1, 2]

Range rules

• start..end → includes start, excludes end
• ..end → from beginning to end
• start.. → from start to end
• .. → whole slice

Examples:

&v[..2]
&v[1..]
&v[..]

Types

How do I slice a Vec<T> in Rust?

Use range syntax with borrowing:

let part = &vec[0..2];

This returns a slice, not a new vector.

Does slicing a vector copy the data?

No. A slice is just a borrowed view into the original vector.

How do I get a new Vec<T> from part of a vector?

Use .to_vec() on the slice:

let new_vec = vec[0..2].to_vec();

What is the type of &vec[0..2]?

It is &[T], a slice reference.

Can slicing panic in Rust?

Yes. Using an invalid range like &vec[0..10] on a shorter vector will panic.

How can I slice safely without panicking?

Use .get(range):

• Vec<T> — the owned growable collection that slices are taken from.
• slices (&[T]) — the direct concept used to borrow part of a sequence.
• borrowing — explains why slices do not own data.
• ownership — helps explain who owns the vector’s memory.
• lifetimes — relevant because a slice cannot outlive the data it references.
• indexing — useful for understanding vec[start..end] syntax.
• Option — important when using .get() for safe slice access.
• arrays — arrays can also be sliced, and they use the same slice type.