# String vs \&str

## String

* Owned by the variable, meaning the variable controls the memory.
* Can be mutated.
* Ideal for strings whose size can change or need to persist beyond the scope of their original reference.

## \&str

* Borrowed, immutable string slice.
* Represents a view into a string, rather than owning the data.
* Usually refers to a segment of a String or a string literal.
* Immutable by default.

## Conversions Between String and \&str

Convert \&str to String: Use the to\_string or String::from methods.

```rust
let slice: &str = "Hello";
let owned: String = slice.to_string();
let owned2: String = String::from(slice);
```

Convert String to \&str: Borrow a string using & or .as\_str().

```rust
let owned: String = String::from("Hello");
let slice: &str = &owned;
let slice2: &str = owned.as_str();
```

## Examples

```rust
fn main() {
    let x = "hello ";
    println!("\"{}\"", x.trim()); // ok
    println!("\"{}\"", x + "world"); // error
}
```

* In above example the `x.trim` function will work because it doesn't manipulate the string.
* Instead it return a slice of original string.
* But `x + "world"` got compile error because you cannot mutate the variable `x: &str`.

```rust
fn main() {
    let x = "hello ".to_string();
    println!("\"{}\"", x + "world"); // ok
}
```

* Above example will work because `x` is converted to `String` and can be mutated.
* In other words, any function or method that manipulate the value will not work using `&str` but will work using `String` type.

## References

* <https://doc.rust-lang.org/book/ch08-02-strings.html#what-is-a-string>