Why String slices in Rust? - Purpose & Use Cases

The Big Idea

Discover how to handle text like a pro without wasting memory or time!

The Scenario

Imagine you have a long sentence and you want to grab just a few words from it. Doing this by copying each word manually is like cutting out pieces of paper one by one--slow and messy.

The Problem

Manually copying parts of a string wastes memory and time. It's easy to make mistakes, like grabbing the wrong part or forgetting to update when the original text changes.

The Solution

String slices let you point to just the part of the text you want, without copying it. It's like using a bookmark to mark a section in a book instead of rewriting the pages.

Before vs After

✗ Before

let part = original_string.clone(); // copying whole string
let word = part[0..5].to_string(); // slicing after copy

✓ After

let word = &original_string[0..5]; // slice directly without copying

What It Enables

It makes your programs faster and lighter by working with parts of strings efficiently without extra copying.

Real Life Example

When building a search tool, you can quickly check parts of user input without making new strings every time, saving memory and speeding up results.

Key Takeaways

String slices let you access parts of text without copying.

This saves memory and improves speed.

It helps keep your code clean and efficient.

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