&str vs String

Learn the difference and use cases of &str and String.

&str vs String

Rust has two main text types. &str (a string slice) is an immutable view that borrows UTF-8 bytes living elsewhere. String is owned, growable text on the heap.

let sabit: &str = "merhaba";          // embedded in the program
let mut sahip: String = String::from("merhaba");
sahip.push_str(" dünya");             // a String can grow

Function parameters usually take &str; it accepts both &String and string literals.

The ownership difference

When a String is assigned to another variable, ownership moves and the old variable can't be used; a &str is a copyable reference:

let a = String::from("Go");
let b = a;            // ownership moved to b
// println!("{a}");   // compile error: a was moved
let s1 = "Rust";
let s2 = s1;          // &str is copied, both are usable

This rule is covered in detail in the ownership lesson.

Exercise Greet

Let fn selam(ad: &str) -> String return format!("Merhaba {ad}"). Call it with both selam("Ada") and let s = String::from("Can"); selam(&s) and print both results.

Show example solution

fn selam(ad: &str) -> String {
    format!("Merhaba {ad}")
}

fn main() {
    let s = String::from("Can");
    println!("{}", selam("Ada"));
    println!("{}", selam(&s));
}

Test yourself

If a function only reads text, which parameter type is most flexible?
- &mut String
- Vec<char>
- &str
- String
Show answer

&str — &String converts to &str automatically (deref coercion); taking a String would force the caller to give up ownership.

Owned text

let mut ad = ____::from("Ada");
ad.push_str(" Lovelace");

Show answer

let mut ad = String::from("Ada");
ad.push_str(" Lovelace");

Type and property

&str

Borrowed, immutable
String

Owned, grows
"metin"

&'static str
&String → &str

Automatic conversion

Next lesson: Creating a String

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies