String vs &str — The Two Faces of Strings Ruby Doesn't Have

In Ruby, strings are simple. One String. Create, modify, pass around. In Rust, there are two kinds.

String — owned string

let s = String::from("hello");
let s = "hello".to_string();  // same result

Heap-allocated. Growable. Closest to Ruby's regular String.

&str — borrowed string

let s: &str = "hello";  // string literals are always &str

A reference (slice) to string data somewhere. Can't resize. Closer to Ruby's frozen string.

When to use which

Function parameters → &str

// ✅ good — accepts both String and &str
fn greet(name: &str) {
    println!("Hello, {}!", name);
}
greet("world");           // pass &str
greet(&my_string);        // String auto-converts to &str

// ❌ unnecessarily restrictive
fn greet(name: String) {  // only accepts String
    println!("Hello, {}!", name);
}

Struct fields → String

struct User {
    name: String,  // needs to own it
}

Conversion

// &str → String
let owned: String = "hello".to_string();
let owned: String = String::from("hello");
let owned: String = "hello".to_owned();

// String → &str
let borrowed: &str = &owned;
let borrowed: &str = owned.as_str();

String concatenation — more verbose than Ruby

Ruby's "Hello, " + name or "Hello, #{name}" is simple. Rust is different.

// format! — equivalent to Ruby's "#{}" / sprintf
let msg = format!("Hello, {}!", name);

// + operator — left side must be String
let msg = String::from("Hello, ") + name;

// push_str — append &str to String
let mut msg = String::from("Hello, ");
msg.push_str(name);

format! works most of the time. Closest to Ruby's string interpolation.

Why two kinds

Performance and ownership. &str points to existing string data without copying. When passing strings to functions, you pass a reference without heap allocation. This is one reason Rust is fast.