Advanced Strings

# Advanced Strings

---

There are several different kinds of strings in Rust.

Most common are `String` and `&str`.

---
## `String`

-   *Owns* the data it stores, and can be mutated freely
-   The bytes it points at exist on the *heap*
-   Does not implement `Copy`, but implements `Clone`

<figure>
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">


<svg width="434pt" height="118pt"
 viewBox="0.00 0.00 433.61 118.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 114)">
<title>%3</title>
<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-114 429.6096,-114 429.6096,4 -4,4"/>

<g id="node1" class="node">
<title>string:</title>
<text text-anchor="middle" x="30.9995" y="-86.1" font-family="Times,serif" font-size="18.00" fill="#000000">string:</text>
</g>

<g id="node2" class="node">
<title>_inner</title>
<polygon fill="#00cd00" stroke="#0000ff" points="74.3894,-.5 74.3894,-36.5 425.6096,-36.5 425.6096,-.5 74.3894,-.5"/>
<text text-anchor="middle" x="96.3894" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x48</text>
<polyline fill="none" stroke="#0000ff" points="118.3894,-.5 118.3894,-36.5 "/>
<text text-anchor="middle" x="140.3894" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x65</text>
<polyline fill="none" stroke="#0000ff" points="162.3894,-.5 162.3894,-36.5 "/>
<text text-anchor="middle" x="183.9967" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x6c</text>
<polyline fill="none" stroke="#0000ff" points="205.604,-.5 205.604,-36.5 "/>
<text text-anchor="middle" x="227.2113" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x6c</text>
<polyline fill="none" stroke="#0000ff" points="248.8186,-.5 248.8186,-36.5 "/>
<text text-anchor="middle" x="269.6489" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x6f</text>
<polyline fill="none" stroke="#0000ff" points="290.4792,-.5 290.4792,-36.5 "/>
<text text-anchor="middle" x="312.4792" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x21</text>
<polyline fill="none" stroke="#0000ff" points="334.4792,-.5 334.4792,-36.5 "/>
<text text-anchor="middle" x="357.2618" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0xFF</text>
<polyline fill="none" stroke="#0000ff" points="380.0444,-.5 380.0444,-36.5 "/>
<text text-anchor="middle" x="402.827" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0xFF</text>
</g>

<g id="node3" class="node">
<title>string</title>
<polygon fill="#add8e6" stroke="#0000ff" points="79.9995,-73.5 79.9995,-109.5 223.9995,-109.5 223.9995,-73.5 79.9995,-73.5"/>
<text text-anchor="middle" x="95.7751" y="-87.3" font-family="Times,serif" font-size="14.00" fill="#000000">ptr</text>
<polyline fill="none" stroke="#0000ff" points="111.5507,-73.5 111.5507,-109.5 "/>
<text text-anchor="middle" x="139.0506" y="-87.3" font-family="Times,serif" font-size="14.00" fill="#000000">len = 6</text>
<polyline fill="none" stroke="#0000ff" points="166.5505,-73.5 166.5505,-109.5 "/>
<text text-anchor="middle" x="195.2124" y="-87.3" font-family="Times,serif" font-size="14.00" fill="#000000">cap = 8</text>
</g>

<g id="edge1" class="edge">
<title>string:p0->_inner:f0</title>
<path fill="none" stroke="#000000" d="M95.9995,-73.5C95.9995,-61.0382 95.9995,-55.6592 95.9995,-46.6281"/>
<polygon fill="#000000" stroke="#000000" points="99.4996,-46.5 95.9995,-36.5 92.4996,-46.5 99.4996,-46.5"/>
</g>
</g>
</svg>
</figure>

---
## `&str`

-   A "string slice reference" (or just "string slice")
-   Usually only seen as a borrowed value
-   The bytes it points at may be anywhere: heap, stack, or in read-only memory

<figure>
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">


<svg width="313pt" height="118pt"
 viewBox="0.00 0.00 312.72 118.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 114)">
<title>%3</title>
<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-114 308.7216,-114 308.7216,4 -4,4"/>

<g id="node1" class="node">
<title>str:</title>
<text text-anchor="middle" x="27" y="-86.1" font-family="Times,serif" font-size="18.00" fill="#000000">str:</text>
</g>

<g id="node2" class="node">
<title>bytes</title>
<polygon fill="#add8e6" stroke="#0000ff" points="79.2784,-.5 79.2784,-36.5 304.7216,-36.5 304.7216,-.5 79.2784,-.5"/>
<text text-anchor="middle" x="102.4467" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0xC2</text>
<polyline fill="none" stroke="#0000ff" points="125.615,-.5 125.615,-36.5 "/>
<text text-anchor="middle" x="149.1683" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0xA3</text>
<polyline fill="none" stroke="#0000ff" points="172.7216,-.5 172.7216,-36.5 "/>
<text text-anchor="middle" x="194.7216" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x39</text>
<polyline fill="none" stroke="#0000ff" points="216.7216,-.5 216.7216,-36.5 "/>
<text text-anchor="middle" x="238.7216" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x39</text>
<polyline fill="none" stroke="#0000ff" points="260.7216,-.5 260.7216,-36.5 "/>
<text text-anchor="middle" x="282.7216" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">0x21</text>
</g>

<g id="node3" class="node">
<title>str</title>
<polygon fill="#add8e6" stroke="#0000ff" points="72,-73.5 72,-109.5 216,-109.5 216,-73.5 72,-73.5"/>
<text text-anchor="middle" x="101.7756" y="-87.3" font-family="Times,serif" font-size="14.00" fill="#000000">ptr</text>
<polyline fill="none" stroke="#0000ff" points="131.5512,-73.5 131.5512,-109.5 "/>
<text text-anchor="middle" x="173.5511" y="-87.3" font-family="Times,serif" font-size="14.00" fill="#000000">len = 5</text>
</g>

<g id="edge1" class="edge">
<title>str:p0->bytes:f0</title>
<path fill="none" stroke="#000000" d="M102,-73.5C102,-61.0382 102,-55.6592 102,-46.6281"/>
<polygon fill="#000000" stroke="#000000" points="105.5001,-46.5 102,-36.5 98.5001,-46.5 105.5001,-46.5"/>
</g>
</g>
</svg>
</figure>

---
## Creation

```rust []
fn main() {
    // &'static str
    let this = "Hello";
    // String
    let that: String = String::from("Hello");
    // &str
    let other = that.as_str();
}
```

---
## When to Use What?

-   `String` is the *easiest* to use when starting out. Refine later.
-   `String` owns its data, so works well as a field of a `struct` or `enum`.
-   `&str` is typically used in function arguments.

---
## `Deref` Coercion

Just because multiple types exist doesn't mean they can't work in harmony.

```rust []
fn main() {
    let part_one = String::from("Hello ");
    let part_two = String::from("there ");
    let whole = part_one + &part_two + "world!";
    println!("{}", whole);
}
```

This is because `String` s implement `Deref<Target=str>` .

---
## Exotic String types

-   `OsStr` and `OsString` may show up when working with file systems or system calls.

-   `CStr` and `CString` may show up when working with FFI.

The differences between `[Os|C]Str` and `[Os|C]String` are generally the same as the normal types.

---
## `OsString` & `OsStr`

These types represent *platform native* strings. This is necessary because Unix and Windows strings have different characteristics.

---
## Behind the `OsString` Scenes

-   Unix strings are often arbitrary non-zero 8-bit sequences, usually interpreted as UTF-8.
-   Windows strings are often arbitrary non-zero 16-bit sequences, usually interpreted as UTF-16.
-   Rust strings are always valid UTF-8, and may contain `NUL` bytes.

`OsString` and `OsStr` bridge this gap and allow for conversion to and from `String` and `str`.

Note:

In particular, UNIX file paths are not required to be valid UTF-8 and you might encounter such paths when looking at someone's disk.

Windows file paths are also not required to be valid UTF-16 (i.e. might contain invalid surrogate pairs) and you might encounter such paths when looking at someone's disk.

---
## `CString` & `CStr`

These types represent valid C compatible strings.

They are predominantly used when doing FFI with external code.

It is strongly recommended you read *all* of the [documentation](https://doc.rust-lang.org/std/ffi/index.html) on these types before using them.

---
## Common String Tasks

Splitting:

```rust []
fn main() {
    let words = "Cow says moo";
    let each: Vec<_> = words.split(" ").collect();
    println!("{:?}", each);
}
```

---
## Common String Tasks

Concatenation:

```rust []
fn main() {
    let animal = String::from("Cow");
    let sound = String::from("moo");
    let words = [&animal, " says ", &sound].concat();
    println!("{:?}", words);
}
```

---
## Common String Tasks

Replacing:

```rust []
fn main() {
    let words = "Cow says moo";
    let replaced = words.replace("moo", "roar");
    println!("{}", replaced);
}
```

---
## Accepting `String` or `str`

It's possible to accept either rather painlessly:

```rust []
fn accept_either<S>(thing: S) -> String
where S: AsRef<str> {
    String::from("foo") + thing.as_ref()
}

fn main() {
    println!("{}", accept_either("blah"));
    println!("{}", accept_either(String::from("blah")));
}
```

---
## Raw String Literals

-   Starts with `r` followed by zero or more `#` followed by `"`
-   Ends with `"` followed by the same number of `#`
-   Can span multiple lines, leading spaces become part of the line
-   Escape sequences are not processed

```rust []
fn main () {
    let json = r##"
{
    "name": "Rust Analyzer",
    "brandColor": "#5bbad5"
}
"##;
    assert_eq!(r"\n", "\\n");
}
```

---
## Byte String Literals

* not really strings
* used to declare static byte slices (have a `&[u8]` type)

```rust []
fn main() {
    let byte_string: &[u8] = b"allows ASCII and \xF0\x9F\x98\x80 only";
    println!("Can Debug fmt but not Display fmt: {:?}", byte_string);
    if let Ok(string) = std::str::from_utf8(byte_string) {
        println!("Now can Display '{}'", string);
    }
}
```