Exerpad
🔥 1
10 XP
Log In
Lesson · Chapter: Strings+10 XP for reading

Working with Strings

Text is everywhere in programs — names, messages, stories, and more! In Rust, working with text (called strings) is super important. Let's learn how!

Two Kinds of Strings

Rust has two main string types:

  • &str (called a "string slice") — a piece of text that can't be changed. When you write "hello" in your code, that's a &str.
  • String — a growable, changeable piece of text that lives on the heap.

Think of &str like a sign on a wall (you can read it but can't change it) and String like a whiteboard (you can write on it and erase it).

rust
fn main() {
let greeting: &str = "Hello!";
let name: String = String::from("Rustacean");
println!("{} {}", greeting, name);
}
Output
Press Run to see the output.

You can turn a &str into a String two ways:

  • String::from("hello")
  • "hello".to_string()

Both do the same thing!

String Length and Checking Content

Use .len() to find out how many bytes a string has, and .contains() to check if a string includes some text:

rust
fn main() {
let message = String::from("I love Rust!");
println!("Length: {}", message.len());
println!("Has Rust? {}", message.contains("Rust"));
println!("Has Python? {}", message.contains("Python"));
}
Output
Press Run to see the output.

Changing Case and Trimming

Rust gives you handy methods to change how text looks:

  • .to_uppercase() — makes everything SHOUTY
  • .to_lowercase() — makes everything quiet
  • .trim() — removes extra spaces from the beginning and end
rust
fn main() {
let shout = "hello world".to_uppercase();
println!("{}", shout);

let whisper = "HELLO WORLD".to_lowercase();
println!("{}", whisper);

let messy = " extra spaces ";
println!("'{}'", messy.trim());
}
Output
Press Run to see the output.

Replacing Text

Use .replace() to swap one piece of text for another:

rust
fn main() {
let sentence = String::from("I like cats and cats like me");
let new_sentence = sentence.replace("cats", "dogs");
println!("{}", new_sentence);
}
Output
Press Run to see the output.

Combining Strings with format!()

The best way to combine strings in Rust is with format!(). It works just like println!() but gives you back a new String instead of printing:

rust
fn main() {
let first = "Ferris";
let last = "the Crab";
let full = format!("{} {}", first, last);
println!("{}", full);
}
Output
Press Run to see the output.

You can use + to combine strings, but it's tricky because + takes ownership of the first string. format!() is easier and safer!

Working with Characters

A string is made up of individual characters. Use .chars() to get each character one at a time:

rust
fn main() {
let word = "Rust";
for ch in word.chars() {
println!("{}", ch);
}
}
Output
Press Run to see the output.

You can also grab a slice of a string using &s[start..end] (this works with byte positions):

rust
fn main() {
let word = String::from("Rustacean");
let first_four = &word[0..4];
println!("{}", first_four);
}
Output
Press Run to see the output.

This prints Rust — the characters from position 0 up to (but not including) position 4.

Summary

MethodWhat it does
String::from("hi")Creates a String from text
"hi".to_string()Also creates a String from text
.len()Returns the length in bytes
.contains("x")Checks if a string contains text
.to_uppercase()Returns an ALL CAPS version
.to_lowercase()Returns an all lowercase version
.trim()Removes leading/trailing whitespace
.replace("a", "b")Replaces all "a" with "b"
format!("{} {}", a, b)Combines values into a new String
.chars()Iterates over each character
&s[0..4]Gets a slice of the string

Now let's practice working with strings!