CodeBlanks Logo Icon CodeBlanks
Login Register

&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.

Practice 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.

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

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

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

Expected output

Merhaba Ada
Merhaba Can

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 If a function only reads text, which parameter type is most flexible?

  • &mut String
  • Vec<char>
  • &str Correct answer
  • String

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

2 Owned text

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

Explanation: String::from creates an owned, growable String from a &str.

3 Type and property

Term Meaning
&str Borrowed, immutable
String Owned, grows
"metin" &'static str
&String → &str Automatic conversion

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter