Strings, &str, and Chars

An i32 walks up to a String and asks for its number. The String replies: "Sorry, you're not my type."

Many other languages have a mushy concept of a "string" that can be anything from a null-terminated byte array to a UTF-16 buffer to something else entirely (I'm looking at you, Perl). Rust splits "string" across distinct types:

• char is one Unicode scalar value (always 4 bytes).
• &str is a borrowed view into UTF-8 text. Cheap to pass around.
• String is an owned, growable UTF-8 buffer. You own the memory.

I'll use two words a lot in this course:

• Owned means this value is mine; when I go out of scope, the memory behind it is freed. In C++ terms, think of std::unique_ptr: dropping the owner frees its allocation. Python and Java don't assign that responsibility to one variable.
• Borrowed means I'm looking at someone else's value without taking it over. It's the equivalent of passing a const T& in C++, or handing out a read-only pointer in C. Borrows are written with an & (or &mut if you also want to mutate). The borrow has to end before the owner is dropped, and the compiler enforces that for you, ruling out use-after-free and dangling pointers.

This ownership model is why Rust has two string types in the first place: it tracks who owns each piece of data. The brief version is that every value has one owner, the value is dropped (deleted) when that owner goes out of scope, and you can borrow a value without owning it. The useful mental model is "one owner, many borrows."

This split lets you pass text around without copying it or losing track of who owns it. Taking &str lets a function read text without copying it or allocating a new buffer. A function that produces new text returns String and returns ownership to the caller, who can then decide what to do with it.

You'll see this pattern again and again:

fn underscore_spaces(text: &str) -> String {
    text.replace(' ', "_")
}

let s = String::from("meeting notes");

// &String coerces to &str. The original s is unchanged.
let filename = underscore_spaces(&s);

• &str ("string slice", pronounced stir) is a borrowed view into text that lives somewhere else. Taking name: &str means "I'll just need to read this string; I'm not taking ownership of it."
• String is owned and heap-allocated. Returning -> String means the caller gets a fresh, owned value back.

There's one common gotcha: If you call .len() on a string, it returns the number of bytes, not the number of characters in that string. Rust uses UTF-8 for strings, which means a single visible character can take more than one byte. A visible character can also contain multiple char values, such as a letter followed by a combining accent.

.chars() lets you walk through the char values in a string, one at a time. The returned value is an iterator over those characters. Iterator provides methods such as .next(), .count(), and .any(...) for consuming or inspecting its values. We'll get to iterators in more detail later.

Building a String with format!

A convenient way to assemble a new String is the format! macro. It works like println!, except instead of printing, it returns the formatted text:

let item = "notebooks";
let quantity = 12;
let label: String = format!("{item}: {quantity} in stock");

In the format string, {item} and {quantity} are captured identifiers. Rust pulls the variables from the surrounding scope. You can also pass arguments explicitly: format!("{}: {} in stock", item, quantity). The exclamation mark (!) means format! is a macro rather than a regular function call.

Consuming an Iterator

The simplest way to consume an iterator is a for loop:

for c in "hello".chars() {
    println!("{c}");
}

You can read it as "for each c produced on the right, run the body once." In this case, for each character in the string "hello", do something with it. The loop variable is a fresh binding scoped to each iteration. Ranges, arrays, and collections can also go on the right-hand side because each can produce an iterator.

Useful Resources

• std::fmt contains everything the formatting macros can do (padding, precision, hex, debug output…).
• str: the inventory of operations available on any &str.

A Welcome Message

Time to put &str and String together. Implement format_welcome_message so it returns the string "Welcome, {name}!".

The signature already tells you what to do:

fn format_welcome_message(name: &str) -> String

You borrow the &str to read the name and return a new String that the caller owns.

Counting Characters

In many languages, asking for the "length" of a string gives you back the number of characters. In Rust, str::len returns the number of bytes in the underlying UTF-8 buffer. For "hello" the byte count and char count both happen to be 5, but "café" is 5 bytes and 4 chars. That's because the é is two bytes in UTF-8.

Use chars() to count Unicode scalar values rather than bytes.

Useful from the Standard Library

• str::chars iterates over the chars of a string.
• Iterator::count consumes an iterator and returns how many items it produced.

Borrow In, Own Out

Here you borrow text to read it, then return an uppercase String that the caller owns. You'll often see &str in and String out when a function reads existing text to produce new text.

Useful from the Standard Library

• str::to_uppercase returns a new String with the text converted to uppercase.

Iterating over Characters

Strings aren't directly indexable in Rust, because UTF-8 characters have varying widths, but you can walk through their chars. A for c in text.chars() loop works. The exercise asks whether the text contains an uppercase character, including non-ASCII ones such as É or Ω. You can use any(), which stops as soon as it finds a match. It takes a closure: an anonymous function such as |n| n > 10. The name between the pipes is the parameter; the expression after them is the result. Here, any passes each item to the closure and checks the returned bool. A for loop is fine too.

Useful from the Standard Library

• Iterator::any returns true if any item in the iterator matches a predicate. It stops at the first match, so you don't have to inspect the rest of the string.
• char::is_uppercase checks whether a character is uppercase according to Unicode, including letters such as É and Ω.

Wrapping Up Strings and Chars

You counted UTF-8 characters, took a &str and produced a new String, and walked a string character by character.

What We Learned

• &str is a borrowed view into UTF-8 text; String is an owned, growable buffer; char is one Unicode scalar value. Functions that read text can take a &str, while functions that produce new text return a String.
• str::len returns the byte length. Use s.chars().count() when you want the number of char values.
• str::chars() returns an iterator. You can use it in a loop or with iterator methods: for c in s.chars(), s.chars().any(...), s.chars().count(), and so on.
• Case conversion (to_uppercase, to_lowercase) returns a new String. It doesn't change the original string.
• char::is_uppercase recognizes Unicode uppercase characters, including letters outside ASCII. char::is_ascii_uppercase only checks for A through Z, so it would miss uppercase letters such as É and Ω.