How to Convert String to &'static str in Rust

By the end of this page, you will understand the difference between String, &str, and &'static str in Rust, why a normal String cannot usually become &'static str, and what safe alternatives to use. You will also see when borrowing is enough, when leaking memory is technically possible, and how real Rust code usually handles this situation.

String and &str are closely related in Rust, but they are not the same type.

• String is an owned, growable string stored on the heap.
• &str is a borrowed view into string data.
• &'static str is a borrowed string slice that is guaranteed to live for the entire duration of the program.

A String can easily be borrowed as a &str because the String owns the text data.

let s = String::from("hello");
let slice: &str = &s;

This works because slice only borrows from s, and s is still alive.

The important part is the lifetime. A borrowed &str can only live as long as the data it points to. Since a normal String is dropped when it goes out of scope, any borrowed from it also becomes invalid at that point.

Think of a String as a notebook that you own.

A &str is like letting someone read a page from your notebook. They can read it only while your notebook still exists.

A &'static str is like text carved into stone in a public square. It stays there for the entire lifetime of the program.

So:

• String = owned notebook
• &str = borrowed page from the notebook
• &'static str = permanent inscription

If you create a String at runtime, it is not automatically permanent. Borrowing from it does not make it permanent either. The borrowed slice is still tied to the owner.

Borrowing String as &str

This is the normal conversion:

let s = String::from("hello");
let slice1: &str = &s;
let slice2: &str = s.as_str();

println!("{} {}", slice1, slice2);

Both &s and s.as_str() give you a &str view into the string.

Why this is not &'static str

fn make_str() -> &str {
    let s = String::from("hello");
    s.as_str()
}

This does not compile, because is dropped when the function ends. Returning a reference to it would create a dangling reference.

Consider this example:

fn main() {
    let s = String::from("hello");
    let slice = s.as_str();
    println!("{}", slice);
}

Step by step:

1. let s = String::from("hello");

   • A String is created on the heap.
   • The variable s owns that heap data.

2. let slice = s.as_str();

   • slice becomes a &str borrowing the contents of s.
   • No new string is allocated.
   • slice points to the same text data owned by s.

3. println!("{}", slice);

Borrow a String as &str

This is common when calling functions that only need read-only access:

fn print_name(name: &str) {
    println!("{}", name);
}

let name = String::from("Ava");
print_name(&name);

Accept either String or &str

Many APIs take &str so callers can pass both string literals and borrowed String data.

fn is_empty_text(text: &str) -> bool {
    text.trim().is_empty()
}

Use &'static str for fixed messages

Useful for constant labels, error messages, and compile-time text:

In real Rust projects, developers usually avoid forcing dynamic strings into &'static str.

Common patterns include:

1. Accept &str in function parameters

This is flexible and ergonomic.

fn log_message(msg: &str) {
    println!("LOG: {}", msg);
}

Callers can pass:

• string literals
• &String
• string slices

2. Return String for computed text

If the function builds text dynamically, return ownership.

fn build_path(user: &str) -> String {
    format!("/home/{}", user)
}

3. Use &'static str for fixed enums or constants

const APP_NAME: &str = "my_app";

Mistake 1: Assuming &str always means 'static

&str does not automatically mean &'static str.

let s = String::from("hello");
let slice: &str = &s; // valid

This slice only lives as long as s does.

Mistake 2: Returning a borrowed slice from a local String

Broken code:

fn bad() -> &str {
    let s = String::from("hello");
    &s
}

Why it fails:

• s is dropped at the end of the function
• the returned reference would dangle

Fix: return instead.

Quick rules

• String -> &str: yes
• String -> &'static str: not normally
• String literal -> &'static str: yes
• as_str() borrows; it does not extend lifetime

Common syntax

let s = String::from("hello");
let a: &str = &s;
let b: &str = s.as_str();

Static string literal

let msg: &'static str = "hello";

Return dynamic text

fn make_text() -> String {
    ::()
}

Can I convert a String to &str in Rust?

Yes. Use &s or s.as_str().

Can I convert a String to &'static str safely?

Not in the normal sense. A runtime String does not live for the entire program, so it cannot naturally become &'static str.

Why do string literals have 'static lifetime?

Because they are stored in the program's compiled binary and exist for the whole runtime of the program.

What does as_str() do?

It returns a borrowed &str view into the String. It does not allocate and does not make the data static.

When should I return String instead of &str?

Return String when the text is created dynamically inside the function.

Is Box::leak a valid way to get ?

• Ownership — explains who owns a value and when it is dropped.
• Borrowing — shows how references like &str work without taking ownership.
• Lifetimes — essential for understanding why &'static str is special.
• String — the owned heap-allocated string type in Rust.
• String slices — covers how &str views string data.
• String literals — important because they naturally have 'static lifetime.
• Box — useful for understanding into_boxed_str() and Box::leak.
• Cow<'a, str> — helpful when code may need either borrowed or owned string data.
• Arc<str> — useful for shared ownership of string data without requiring 'static.