String slices in Rust

Introduction

String slices let you look at parts of a string without making a new copy. This saves memory and time.

When you want to read or use just a part of a string.

When you want to check or compare a section of a string.

When you want to pass a part of a string to a function without copying it.

When you want to split a string into smaller pieces.

When you want to avoid changing the original string but still work with its parts.

Syntax

Rust

let slice = &string[start_index..end_index];

The slice uses & and square brackets with two dots .. between start and end positions.

The start index is included, the end index is excluded (like counting from start up to but not including end).

Examples

This takes the first two letters "he" from the string.

Rust

let s = String::from("hello");
let slice = &s[0..2];
println!("{}", slice);

This takes letters from index 1 to 3, which is "orl".

Rust

let s = "world";
let slice = &s[1..4];
println!("{}", slice);

Leaving out the start means start from 0, so this gets "rust".

Rust

let s = String::from("rustacean");
let slice = &s[..4];
println!("{}", slice);

Leaving out the end means go to the end, so this gets "acean".

Rust

let s = String::from("rustacean");
let slice = &s[4..];
println!("{}", slice);

Sample Program

This program takes two slices from the greeting string: "Hello" and "world". Then it prints them with a space.

Rust

fn main() {
    let greeting = String::from("Hello, world!");
    let hello = &greeting[0..5];
    let world = &greeting[7..12];
    println!("{} {}", hello, world);
}

Important Notes

String slices must be on valid character boundaries, or Rust will give an error.

String slices are references, so they do not own the data and cannot outlive the original string.

You can also slice string literals directly, like let s = &"hello"[1..4];

Summary

String slices let you use parts of a string without copying.

Use &string[start..end] to get a slice from start to end-1.

Slices are fast and memory-friendly because they borrow the original string.

Practice

1. What is a string slice in Rust?

easy

A. A type of integer used for indexing strings

B. A reference to a part of a string without copying it

C. A function that modifies a string in place

D. A new string created by copying characters

Solution

1. Step 1: Understand string slice concept

   A string slice is a reference to a part of a string, not a new string.

2. Step 2: Compare options

   Only A reference to a part of a string without copying it describes a reference without copying, which matches string slices.

3. Final Answer:

   A reference to a part of a string without copying it -> Option B

4. Quick Check:

   String slice = reference without copy [OK]

Hint: Remember: slices borrow, not copy strings [OK]

Common Mistakes:

• Thinking slices create new strings
• Confusing slices with string modification
• Believing slices are integer types

2. Which of the following is the correct syntax to get a slice of the first 4 characters from a string text?

easy

A. &text[0..4]

B. text.slice(0, 4)

C. &text[1..5]

D. text[0:4]

Solution

1. Step 1: Recall Rust slice syntax

   Rust uses &string[start..end] to get a slice from start to end-1.

2. Step 2: Check options

   &text[0..4] uses &text[0..4], which correctly slices first 4 chars (indices 0 to 3).

3. Final Answer:

   &text[0..4] -> Option A

4. Quick Check:

   Slice syntax = &string[start..end] [OK]

Hint: Use &string[start..end] for slices, not methods or colons [OK]

Common Mistakes:

• Using method calls like slice() which don't exist
• Using 1-based indexing instead of 0-based
• Using Python-style slicing with colons

3. What will the following Rust code print?

let s = String::from("hello world");
let slice = &s[6..11];
println!("{}", slice);

medium

A. hello

B. Syntax error

C. hello world

D. world

Solution

1. Step 1: Understand slicing indices

   The slice &s[6..11] takes characters from index 6 up to 10 (11 excluded).

2. Step 2: Identify substring

   In "hello world", index 6 is 'w' and index 10 is 'd', so slice is "world".

3. Final Answer:

   world -> Option D

4. Quick Check:

   Slice &s[6..11] = "world" [OK]

Hint: Remember slice end index is excluded [OK]

Common Mistakes:

• Including the end index character
• Confusing start and end indices
• Expecting full string output

4. Identify the error in this Rust code snippet:

let s = String::from("rustacean");
let slice = &s[0..5];
println!("{}", slice);
let invalid_slice = &s[5..15];

medium

A. The slice &s[5..15] causes a runtime panic due to out-of-bounds

B. The slice &s[0..5] is invalid syntax

C. The println! macro is missing a semicolon

D. String::from cannot create strings with length 9

Solution

1. Step 1: Check slice ranges

   The string "rustacean" has length 9, so valid indices are 0 to 8.

2. Step 2: Analyze invalid slice

   The slice &s[5..15] tries to access indices beyond length, causing runtime panic.

3. Final Answer:

   The slice &s[5..15] causes a runtime panic due to out-of-bounds -> Option A

4. Quick Check:

   Out-of-bounds slice = panic [OK]

Hint: Slice end must be ≤ string length to avoid panic [OK]

Common Mistakes:

• Assuming slices auto-adjust to string length
• Thinking &s[0..5] is invalid syntax
• Ignoring runtime panics from invalid slices

5. Given a string text, how can you safely get a slice of the first n characters without risking a runtime panic if n is larger than the string length?

hard

A. Use text.get(0..n).unwrap()

B. Use &text[0..n] without checks

C. Use &text[0..n.min(text.len())]

D. Use &text[0..=n]

Solution

1. Step 1: Understand safe slicing

   To avoid panic, slice end must not exceed string length.

2. Step 2: Use min to limit slice end

   Using n.min(text.len()) ensures slice end is at most string length.

3. Final Answer:

   Use &text[0..n.min(text.len())] -> Option C

4. Quick Check:

   Safe slice end = min(n, length) [OK]

Hint: Use min() to limit slice end safely [OK]

Common Mistakes:

• Slicing without length check causing panic
• Using unwrap() which can panic if None
• Using inclusive range which is invalid for slices